Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / sculpt_paint / paint_cursor.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) 2009 by Nicholas Bishop
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edsculpt
22  */
23
24 #include "MEM_guardedalloc.h"
25
26 #include "BLI_math.h"
27 #include "BLI_rect.h"
28 #include "BLI_task.h"
29 #include "BLI_utildefines.h"
30
31 #include "DNA_brush_types.h"
32 #include "DNA_customdata_types.h"
33 #include "DNA_color_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36 #include "DNA_screen_types.h"
37 #include "DNA_space_types.h"
38 #include "DNA_userdef_types.h"
39 #include "DNA_view3d_types.h"
40
41 #include "BKE_brush.h"
42 #include "BKE_context.h"
43 #include "BKE_curve.h"
44 #include "BKE_image.h"
45 #include "BKE_node.h"
46 #include "BKE_paint.h"
47 #include "BKE_colortools.h"
48
49 #include "WM_api.h"
50
51 #include "IMB_imbuf_types.h"
52
53 #include "ED_view3d.h"
54
55 #include "GPU_draw.h"
56 #include "GPU_immediate.h"
57 #include "GPU_immediate_util.h"
58 #include "GPU_matrix.h"
59 #include "GPU_state.h"
60
61 #include "UI_resources.h"
62
63 #include "paint_intern.h"
64 /* still needed for sculpt_stroke_get_location, should be
65  * removed eventually (TODO) */
66 #include "sculpt_intern.h"
67
68 /* TODOs:
69  *
70  * Some of the cursor drawing code is doing non-draw stuff
71  * (e.g. updating the brush rake angle). This should be cleaned up
72  * still.
73  *
74  * There is also some ugliness with sculpt-specific code.
75  */
76
77 typedef struct TexSnapshot {
78   GLuint overlay_texture;
79   int winx;
80   int winy;
81   int old_size;
82   float old_zoom;
83   bool old_col;
84 } TexSnapshot;
85
86 typedef struct CursorSnapshot {
87   GLuint overlay_texture;
88   int size;
89   int zoom;
90 } CursorSnapshot;
91
92 static TexSnapshot primary_snap = {0};
93 static TexSnapshot secondary_snap = {0};
94 static CursorSnapshot cursor_snap = {0};
95
96 /* delete overlay cursor textures to preserve memory and invalidate all overlay flags */
97 void paint_cursor_delete_textures(void)
98 {
99   if (primary_snap.overlay_texture) {
100     glDeleteTextures(1, &primary_snap.overlay_texture);
101   }
102   if (secondary_snap.overlay_texture) {
103     glDeleteTextures(1, &secondary_snap.overlay_texture);
104   }
105   if (cursor_snap.overlay_texture) {
106     glDeleteTextures(1, &cursor_snap.overlay_texture);
107   }
108
109   memset(&primary_snap, 0, sizeof(TexSnapshot));
110   memset(&secondary_snap, 0, sizeof(TexSnapshot));
111   memset(&cursor_snap, 0, sizeof(CursorSnapshot));
112
113   BKE_paint_invalidate_overlay_all();
114 }
115
116 static int same_tex_snap(TexSnapshot *snap, MTex *mtex, ViewContext *vc, bool col, float zoom)
117 {
118   return (/* make brush smaller shouldn't cause a resample */
119           //(mtex->brush_map_mode != MTEX_MAP_MODE_VIEW ||
120           //(BKE_brush_size_get(vc->scene, brush) <= snap->BKE_brush_size_get)) &&
121
122           (mtex->brush_map_mode != MTEX_MAP_MODE_TILED ||
123            (vc->ar->winx == snap->winx && vc->ar->winy == snap->winy)) &&
124           (mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL || snap->old_zoom == zoom) &&
125           snap->old_col == col);
126 }
127
128 static void make_tex_snap(TexSnapshot *snap, ViewContext *vc, float zoom)
129 {
130   snap->old_zoom = zoom;
131   snap->winx = vc->ar->winx;
132   snap->winy = vc->ar->winy;
133 }
134
135 typedef struct LoadTexData {
136   Brush *br;
137   ViewContext *vc;
138
139   MTex *mtex;
140   GLubyte *buffer;
141   bool col;
142
143   struct ImagePool *pool;
144   int size;
145   float rotation;
146   float radius;
147 } LoadTexData;
148
149 static void load_tex_task_cb_ex(void *__restrict userdata,
150                                 const int j,
151                                 const ParallelRangeTLS *__restrict tls)
152 {
153   LoadTexData *data = userdata;
154   Brush *br = data->br;
155   ViewContext *vc = data->vc;
156
157   MTex *mtex = data->mtex;
158   GLubyte *buffer = data->buffer;
159   const bool col = data->col;
160
161   struct ImagePool *pool = data->pool;
162   const int size = data->size;
163   const float rotation = data->rotation;
164   const float radius = data->radius;
165
166   bool convert_to_linear = false;
167   struct ColorSpace *colorspace = NULL;
168
169   if (mtex->tex && mtex->tex->type == TEX_IMAGE && mtex->tex->ima) {
170     ImBuf *tex_ibuf = BKE_image_pool_acquire_ibuf(mtex->tex->ima, &mtex->tex->iuser, pool);
171     /* For consistency, sampling always returns color in linear space */
172     if (tex_ibuf && tex_ibuf->rect_float == NULL) {
173       convert_to_linear = true;
174       colorspace = tex_ibuf->rect_colorspace;
175     }
176     BKE_image_pool_release_ibuf(mtex->tex->ima, tex_ibuf, pool);
177   }
178
179   for (int i = 0; i < size; i++) {
180     // largely duplicated from tex_strength
181
182     int index = j * size + i;
183
184     float x = (float)i / size;
185     float y = (float)j / size;
186     float len;
187
188     if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
189       x *= vc->ar->winx / radius;
190       y *= vc->ar->winy / radius;
191     }
192     else {
193       x = (x - 0.5f) * 2.0f;
194       y = (y - 0.5f) * 2.0f;
195     }
196
197     len = sqrtf(x * x + y * y);
198
199     if (ELEM(mtex->brush_map_mode, MTEX_MAP_MODE_TILED, MTEX_MAP_MODE_STENCIL) || len <= 1.0f) {
200       /* It is probably worth optimizing for those cases where the texture is not rotated by
201        * skipping the calls to atan2, sqrtf, sin, and cos. */
202       if (mtex->tex && (rotation > 0.001f || rotation < -0.001f)) {
203         const float angle = atan2f(y, x) + rotation;
204
205         x = len * cosf(angle);
206         y = len * sinf(angle);
207       }
208
209       if (col) {
210         float rgba[4];
211
212         paint_get_tex_pixel_col(
213             mtex, x, y, rgba, pool, tls->thread_id, convert_to_linear, colorspace);
214
215         buffer[index * 4] = rgba[0] * 255;
216         buffer[index * 4 + 1] = rgba[1] * 255;
217         buffer[index * 4 + 2] = rgba[2] * 255;
218         buffer[index * 4 + 3] = rgba[3] * 255;
219       }
220       else {
221         float avg = paint_get_tex_pixel(mtex, x, y, pool, tls->thread_id);
222
223         avg += br->texture_sample_bias;
224
225         /* clamp to avoid precision overflow */
226         CLAMP(avg, 0.0f, 1.0f);
227         buffer[index] = 255 - (GLubyte)(255 * avg);
228       }
229     }
230     else {
231       if (col) {
232         buffer[index * 4] = 0;
233         buffer[index * 4 + 1] = 0;
234         buffer[index * 4 + 2] = 0;
235         buffer[index * 4 + 3] = 0;
236       }
237       else {
238         buffer[index] = 0;
239       }
240     }
241   }
242 }
243
244 static int load_tex(Brush *br, ViewContext *vc, float zoom, bool col, bool primary)
245 {
246   bool init;
247   TexSnapshot *target;
248
249   MTex *mtex = (primary) ? &br->mtex : &br->mask_mtex;
250   eOverlayControlFlags overlay_flags = BKE_paint_get_overlay_flags();
251   GLubyte *buffer = NULL;
252
253   int size;
254   bool refresh;
255   eOverlayControlFlags invalid = ((primary) ?
256                                       (overlay_flags & PAINT_OVERLAY_INVALID_TEXTURE_PRIMARY) :
257                                       (overlay_flags & PAINT_OVERLAY_INVALID_TEXTURE_SECONDARY));
258   target = (primary) ? &primary_snap : &secondary_snap;
259
260   refresh = !target->overlay_texture || (invalid != 0) ||
261             !same_tex_snap(target, mtex, vc, col, zoom);
262
263   init = (target->overlay_texture != 0);
264
265   if (refresh) {
266     struct ImagePool *pool = NULL;
267     /* stencil is rotated later */
268     const float rotation = (mtex->brush_map_mode != MTEX_MAP_MODE_STENCIL) ? -mtex->rot : 0.0f;
269     const float radius = BKE_brush_size_get(vc->scene, br) * zoom;
270
271     make_tex_snap(target, vc, zoom);
272
273     if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
274       int s = BKE_brush_size_get(vc->scene, br);
275       int r = 1;
276
277       for (s >>= 1; s > 0; s >>= 1) {
278         r++;
279       }
280
281       size = (1 << r);
282
283       if (size < 256) {
284         size = 256;
285       }
286
287       if (size < target->old_size) {
288         size = target->old_size;
289       }
290     }
291     else {
292       size = 512;
293     }
294
295     if (target->old_size != size) {
296       if (target->overlay_texture) {
297         glDeleteTextures(1, &target->overlay_texture);
298         target->overlay_texture = 0;
299       }
300
301       init = false;
302
303       target->old_size = size;
304     }
305     if (col) {
306       buffer = MEM_mallocN(sizeof(GLubyte) * size * size * 4, "load_tex");
307     }
308     else {
309       buffer = MEM_mallocN(sizeof(GLubyte) * size * size, "load_tex");
310     }
311
312     pool = BKE_image_pool_new();
313
314     if (mtex->tex && mtex->tex->nodetree) {
315       /* has internal flag to detect it only does it once */
316       ntreeTexBeginExecTree(mtex->tex->nodetree);
317     }
318
319     LoadTexData data = {
320         .br = br,
321         .vc = vc,
322         .mtex = mtex,
323         .buffer = buffer,
324         .col = col,
325         .pool = pool,
326         .size = size,
327         .rotation = rotation,
328         .radius = radius,
329     };
330
331     ParallelRangeSettings settings;
332     BLI_parallel_range_settings_defaults(&settings);
333     BLI_task_parallel_range(0, size, &data, load_tex_task_cb_ex, &settings);
334
335     if (mtex->tex && mtex->tex->nodetree) {
336       ntreeTexEndExecTree(mtex->tex->nodetree->execdata);
337     }
338
339     if (pool) {
340       BKE_image_pool_free(pool);
341     }
342
343     if (!target->overlay_texture) {
344       glGenTextures(1, &target->overlay_texture);
345     }
346   }
347   else {
348     size = target->old_size;
349   }
350
351   glActiveTexture(GL_TEXTURE0);
352   glBindTexture(GL_TEXTURE_2D, target->overlay_texture);
353
354   if (refresh) {
355     GLenum format = col ? GL_RGBA : GL_RED;
356     GLenum internalformat = col ? GL_RGBA8 : GL_R8;
357
358     if (!init || (target->old_col != col)) {
359       glTexImage2D(
360           GL_TEXTURE_2D, 0, internalformat, size, size, 0, format, GL_UNSIGNED_BYTE, buffer);
361     }
362     else {
363       glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size, size, format, GL_UNSIGNED_BYTE, buffer);
364     }
365
366     if (buffer) {
367       MEM_freeN(buffer);
368     }
369
370     target->old_col = col;
371   }
372
373   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
374   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
375
376   if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
377     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
378     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
379   }
380
381   BKE_paint_reset_overlay_invalid(invalid);
382
383   return 1;
384 }
385
386 static void load_tex_cursor_task_cb(void *__restrict userdata,
387                                     const int j,
388                                     const ParallelRangeTLS *__restrict UNUSED(tls))
389 {
390   LoadTexData *data = userdata;
391   Brush *br = data->br;
392
393   GLubyte *buffer = data->buffer;
394
395   const int size = data->size;
396
397   for (int i = 0; i < size; i++) {
398     // largely duplicated from tex_strength
399
400     const int index = j * size + i;
401     const float x = (((float)i / size) - 0.5f) * 2.0f;
402     const float y = (((float)j / size) - 0.5f) * 2.0f;
403     const float len = sqrtf(x * x + y * y);
404
405     if (len <= 1.0f) {
406       float avg = BKE_brush_curve_strength_clamped(br, len, 1.0f); /* Falloff curve */
407
408       buffer[index] = 255 - (GLubyte)(255 * avg);
409     }
410     else {
411       buffer[index] = 0;
412     }
413   }
414 }
415
416 static int load_tex_cursor(Brush *br, ViewContext *vc, float zoom)
417 {
418   bool init;
419
420   eOverlayControlFlags overlay_flags = BKE_paint_get_overlay_flags();
421   GLubyte *buffer = NULL;
422
423   int size;
424   const bool refresh = !cursor_snap.overlay_texture ||
425                        (overlay_flags & PAINT_OVERLAY_INVALID_CURVE) || cursor_snap.zoom != zoom;
426
427   init = (cursor_snap.overlay_texture != 0);
428
429   if (refresh) {
430     int s, r;
431
432     cursor_snap.zoom = zoom;
433
434     s = BKE_brush_size_get(vc->scene, br);
435     r = 1;
436
437     for (s >>= 1; s > 0; s >>= 1) {
438       r++;
439     }
440
441     size = (1 << r);
442
443     if (size < 256) {
444       size = 256;
445     }
446
447     if (size < cursor_snap.size) {
448       size = cursor_snap.size;
449     }
450
451     if (cursor_snap.size != size) {
452       if (cursor_snap.overlay_texture) {
453         glDeleteTextures(1, &cursor_snap.overlay_texture);
454         cursor_snap.overlay_texture = 0;
455       }
456
457       init = false;
458
459       cursor_snap.size = size;
460     }
461     buffer = MEM_mallocN(sizeof(GLubyte) * size * size, "load_tex");
462
463     curvemapping_initialize(br->curve);
464
465     LoadTexData data = {
466         .br = br,
467         .buffer = buffer,
468         .size = size,
469     };
470
471     ParallelRangeSettings settings;
472     BLI_parallel_range_settings_defaults(&settings);
473     BLI_task_parallel_range(0, size, &data, load_tex_cursor_task_cb, &settings);
474
475     if (!cursor_snap.overlay_texture) {
476       glGenTextures(1, &cursor_snap.overlay_texture);
477     }
478   }
479   else {
480     size = cursor_snap.size;
481   }
482
483   glActiveTexture(GL_TEXTURE0);
484   glBindTexture(GL_TEXTURE_2D, cursor_snap.overlay_texture);
485
486   if (refresh) {
487     if (!init) {
488       glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, size, size, 0, GL_RED, GL_UNSIGNED_BYTE, buffer);
489     }
490     else {
491       glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size, size, GL_RED, GL_UNSIGNED_BYTE, buffer);
492     }
493
494     if (buffer) {
495       MEM_freeN(buffer);
496     }
497   }
498
499   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
500   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
501
502   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
503   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
504
505   BKE_paint_reset_overlay_invalid(PAINT_OVERLAY_INVALID_CURVE);
506
507   return 1;
508 }
509
510 static int project_brush_radius(ViewContext *vc, float radius, const float location[3])
511 {
512   float view[3], nonortho[3], ortho[3], offset[3], p1[2], p2[2];
513
514   ED_view3d_global_to_vector(vc->rv3d, location, view);
515
516   /* create a vector that is not orthogonal to view */
517
518   if (fabsf(view[0]) < 0.1f) {
519     nonortho[0] = view[0] + 1.0f;
520     nonortho[1] = view[1];
521     nonortho[2] = view[2];
522   }
523   else if (fabsf(view[1]) < 0.1f) {
524     nonortho[0] = view[0];
525     nonortho[1] = view[1] + 1.0f;
526     nonortho[2] = view[2];
527   }
528   else {
529     nonortho[0] = view[0];
530     nonortho[1] = view[1];
531     nonortho[2] = view[2] + 1.0f;
532   }
533
534   /* get a vector in the plane of the view */
535   cross_v3_v3v3(ortho, nonortho, view);
536   normalize_v3(ortho);
537
538   /* make a point on the surface of the brush tangent to the view */
539   mul_v3_fl(ortho, radius);
540   add_v3_v3v3(offset, location, ortho);
541
542   /* project the center of the brush, and the tangent point to the view onto the screen */
543   if ((ED_view3d_project_float_global(vc->ar, location, p1, V3D_PROJ_TEST_NOP) ==
544        V3D_PROJ_RET_OK) &&
545       (ED_view3d_project_float_global(vc->ar, offset, p2, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK)) {
546     /* the distance between these points is the size of the projected brush in pixels */
547     return len_v2v2(p1, p2);
548   }
549   else {
550     BLI_assert(0); /* assert because the code that sets up the vectors should disallow this */
551     return 0;
552   }
553 }
554
555 static bool sculpt_get_brush_geometry(bContext *C,
556                                       ViewContext *vc,
557                                       int x,
558                                       int y,
559                                       int *pixel_radius,
560                                       float location[3],
561                                       UnifiedPaintSettings *ups)
562 {
563   Scene *scene = CTX_data_scene(C);
564   Paint *paint = BKE_paint_get_active_from_context(C);
565   float mouse[2];
566   bool hit = false;
567
568   mouse[0] = x;
569   mouse[1] = y;
570
571   if (vc->obact->sculpt && vc->obact->sculpt->pbvh) {
572     if (!ups->stroke_active) {
573       hit = sculpt_stroke_get_location(C, location, mouse);
574     }
575     else {
576       hit = ups->last_hit;
577       copy_v3_v3(location, ups->last_location);
578     }
579   }
580
581   if (hit) {
582     Brush *brush = BKE_paint_brush(paint);
583
584     *pixel_radius = project_brush_radius(
585         vc, BKE_brush_unprojected_radius_get(scene, brush), location);
586
587     if (*pixel_radius == 0) {
588       *pixel_radius = BKE_brush_size_get(scene, brush);
589     }
590
591     mul_m4_v3(vc->obact->obmat, location);
592   }
593   else {
594     Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
595     Brush *brush = BKE_paint_brush(&sd->paint);
596
597     *pixel_radius = BKE_brush_size_get(scene, brush);
598   }
599
600   return hit;
601 }
602
603 /* Draw an overlay that shows what effect the brush's texture will
604  * have on brush strength */
605 static void paint_draw_tex_overlay(UnifiedPaintSettings *ups,
606                                    Brush *brush,
607                                    ViewContext *vc,
608                                    int x,
609                                    int y,
610                                    float zoom,
611                                    bool col,
612                                    bool primary)
613 {
614   rctf quad;
615   /* check for overlay mode */
616
617   MTex *mtex = (primary) ? &brush->mtex : &brush->mask_mtex;
618   bool valid = ((primary) ? (brush->overlay_flags & BRUSH_OVERLAY_PRIMARY) != 0 :
619                             (brush->overlay_flags & BRUSH_OVERLAY_SECONDARY) != 0);
620   int overlay_alpha = (primary) ? brush->texture_overlay_alpha : brush->mask_overlay_alpha;
621
622   if (!(mtex->tex) ||
623       !((mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL) ||
624         (valid && ELEM(mtex->brush_map_mode, MTEX_MAP_MODE_VIEW, MTEX_MAP_MODE_TILED)))) {
625     return;
626   }
627
628   if (load_tex(brush, vc, zoom, col, primary)) {
629     GPU_blend(true);
630
631     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
632     glDepthMask(GL_FALSE);
633     glDepthFunc(GL_ALWAYS);
634
635     if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
636       GPU_matrix_push();
637
638       /* brush rotation */
639       GPU_matrix_translate_2f(x, y);
640       GPU_matrix_rotate_2d(-RAD2DEGF(primary ? ups->brush_rotation : ups->brush_rotation_sec));
641       GPU_matrix_translate_2f(-x, -y);
642
643       /* scale based on tablet pressure */
644       if (primary && ups->stroke_active && BKE_brush_use_size_pressure(vc->scene, brush)) {
645         const float scale = ups->size_pressure_value;
646         GPU_matrix_translate_2f(x, y);
647         GPU_matrix_scale_2f(scale, scale);
648         GPU_matrix_translate_2f(-x, -y);
649       }
650
651       if (ups->draw_anchored) {
652         quad.xmin = ups->anchored_initial_mouse[0] - ups->anchored_size;
653         quad.ymin = ups->anchored_initial_mouse[1] - ups->anchored_size;
654         quad.xmax = ups->anchored_initial_mouse[0] + ups->anchored_size;
655         quad.ymax = ups->anchored_initial_mouse[1] + ups->anchored_size;
656       }
657       else {
658         const int radius = BKE_brush_size_get(vc->scene, brush) * zoom;
659         quad.xmin = x - radius;
660         quad.ymin = y - radius;
661         quad.xmax = x + radius;
662         quad.ymax = y + radius;
663       }
664     }
665     else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
666       quad.xmin = 0;
667       quad.ymin = 0;
668       quad.xmax = BLI_rcti_size_x(&vc->ar->winrct);
669       quad.ymax = BLI_rcti_size_y(&vc->ar->winrct);
670     }
671     /* Stencil code goes here */
672     else {
673       if (primary) {
674         quad.xmin = -brush->stencil_dimension[0];
675         quad.ymin = -brush->stencil_dimension[1];
676         quad.xmax = brush->stencil_dimension[0];
677         quad.ymax = brush->stencil_dimension[1];
678       }
679       else {
680         quad.xmin = -brush->mask_stencil_dimension[0];
681         quad.ymin = -brush->mask_stencil_dimension[1];
682         quad.xmax = brush->mask_stencil_dimension[0];
683         quad.ymax = brush->mask_stencil_dimension[1];
684       }
685       GPU_matrix_push();
686       if (primary) {
687         GPU_matrix_translate_2fv(brush->stencil_pos);
688       }
689       else {
690         GPU_matrix_translate_2fv(brush->mask_stencil_pos);
691       }
692       GPU_matrix_rotate_2d(RAD2DEGF(mtex->rot));
693     }
694
695     /* set quad color. Colored overlay does not get blending */
696     GPUVertFormat *format = immVertexFormat();
697     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
698     uint texCoord = GPU_vertformat_attr_add(format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
699
700     if (col) {
701       immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_COLOR);
702       immUniformColor4f(1.0f, 1.0f, 1.0f, overlay_alpha * 0.01f);
703     }
704     else {
705       GPU_blend_set_func(GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
706       immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_ALPHA_COLOR);
707       immUniformColor3fvAlpha(U.sculpt_paint_overlay_col, overlay_alpha * 0.01f);
708     }
709
710     /* draw textured quad */
711     immUniform1i("image", 0);
712
713     immBegin(GPU_PRIM_TRI_FAN, 4);
714     immAttr2f(texCoord, 0.0f, 0.0f);
715     immVertex2f(pos, quad.xmin, quad.ymin);
716     immAttr2f(texCoord, 1.0f, 0.0f);
717     immVertex2f(pos, quad.xmax, quad.ymin);
718     immAttr2f(texCoord, 1.0f, 1.0f);
719     immVertex2f(pos, quad.xmax, quad.ymax);
720     immAttr2f(texCoord, 0.0f, 1.0f);
721     immVertex2f(pos, quad.xmin, quad.ymax);
722     immEnd();
723
724     immUnbindProgram();
725     GPU_blend_set_func(GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA);
726
727     if (ELEM(mtex->brush_map_mode, MTEX_MAP_MODE_STENCIL, MTEX_MAP_MODE_VIEW)) {
728       GPU_matrix_pop();
729     }
730   }
731 }
732
733 /* Draw an overlay that shows what effect the brush's texture will
734  * have on brush strength */
735 static void paint_draw_cursor_overlay(
736     UnifiedPaintSettings *ups, Brush *brush, ViewContext *vc, int x, int y, float zoom)
737 {
738   rctf quad;
739   /* check for overlay mode */
740
741   if (!(brush->overlay_flags & BRUSH_OVERLAY_CURSOR)) {
742     return;
743   }
744
745   if (load_tex_cursor(brush, vc, zoom)) {
746     bool do_pop = false;
747     float center[2];
748     GPU_blend(true);
749
750     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
751     glDepthMask(GL_FALSE);
752     glDepthFunc(GL_ALWAYS);
753
754     if (ups->draw_anchored) {
755       copy_v2_v2(center, ups->anchored_initial_mouse);
756       quad.xmin = ups->anchored_initial_mouse[0] - ups->anchored_size;
757       quad.ymin = ups->anchored_initial_mouse[1] - ups->anchored_size;
758       quad.xmax = ups->anchored_initial_mouse[0] + ups->anchored_size;
759       quad.ymax = ups->anchored_initial_mouse[1] + ups->anchored_size;
760     }
761     else {
762       const int radius = BKE_brush_size_get(vc->scene, brush) * zoom;
763       center[0] = x;
764       center[1] = y;
765
766       quad.xmin = x - radius;
767       quad.ymin = y - radius;
768       quad.xmax = x + radius;
769       quad.ymax = y + radius;
770     }
771
772     /* scale based on tablet pressure */
773     if (ups->stroke_active && BKE_brush_use_size_pressure(vc->scene, brush)) {
774       do_pop = true;
775       GPU_matrix_push();
776       GPU_matrix_translate_2fv(center);
777       GPU_matrix_scale_1f(ups->size_pressure_value);
778       GPU_matrix_translate_2f(-center[0], -center[1]);
779     }
780
781     GPUVertFormat *format = immVertexFormat();
782     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
783     uint texCoord = GPU_vertformat_attr_add(format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
784
785     GPU_blend_set_func(GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
786     immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_ALPHA_COLOR);
787
788     immUniformColor3fvAlpha(U.sculpt_paint_overlay_col, brush->cursor_overlay_alpha * 0.01f);
789
790     /* draw textured quad */
791
792     /* draw textured quad */
793     immUniform1i("image", 0);
794
795     immBegin(GPU_PRIM_TRI_FAN, 4);
796     immAttr2f(texCoord, 0.0f, 0.0f);
797     immVertex2f(pos, quad.xmin, quad.ymin);
798     immAttr2f(texCoord, 1.0f, 0.0f);
799     immVertex2f(pos, quad.xmax, quad.ymin);
800     immAttr2f(texCoord, 1.0f, 1.0f);
801     immVertex2f(pos, quad.xmax, quad.ymax);
802     immAttr2f(texCoord, 0.0f, 1.0f);
803     immVertex2f(pos, quad.xmin, quad.ymax);
804     immEnd();
805
806     immUnbindProgram();
807
808     GPU_blend_set_func(GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA);
809
810     if (do_pop) {
811       GPU_matrix_pop();
812     }
813   }
814 }
815
816 static void paint_draw_alpha_overlay(UnifiedPaintSettings *ups,
817                                      Brush *brush,
818                                      ViewContext *vc,
819                                      int x,
820                                      int y,
821                                      float zoom,
822                                      ePaintMode mode)
823 {
824   /* Color means that primary brush texture is colored and
825    * secondary is used for alpha/mask control. */
826   bool col = ELEM(mode, PAINT_MODE_TEXTURE_3D, PAINT_MODE_TEXTURE_2D, PAINT_MODE_VERTEX);
827   eOverlayControlFlags flags = BKE_paint_get_overlay_flags();
828   gpuPushAttr(GPU_DEPTH_BUFFER_BIT | GPU_BLEND_BIT);
829
830   /* Translate to region. */
831   GPU_matrix_push();
832   GPU_matrix_translate_2f(vc->ar->winrct.xmin, vc->ar->winrct.ymin);
833   x -= vc->ar->winrct.xmin;
834   y -= vc->ar->winrct.ymin;
835
836   /* coloured overlay should be drawn separately */
837   if (col) {
838     if (!(flags & PAINT_OVERLAY_OVERRIDE_PRIMARY)) {
839       paint_draw_tex_overlay(ups, brush, vc, x, y, zoom, true, true);
840     }
841     if (!(flags & PAINT_OVERLAY_OVERRIDE_SECONDARY)) {
842       paint_draw_tex_overlay(ups, brush, vc, x, y, zoom, false, false);
843     }
844     if (!(flags & PAINT_OVERLAY_OVERRIDE_CURSOR)) {
845       paint_draw_cursor_overlay(ups, brush, vc, x, y, zoom);
846     }
847   }
848   else {
849     if (!(flags & PAINT_OVERLAY_OVERRIDE_PRIMARY) && (mode != PAINT_MODE_WEIGHT)) {
850       paint_draw_tex_overlay(ups, brush, vc, x, y, zoom, false, true);
851     }
852     if (!(flags & PAINT_OVERLAY_OVERRIDE_CURSOR)) {
853       paint_draw_cursor_overlay(ups, brush, vc, x, y, zoom);
854     }
855   }
856
857   GPU_matrix_pop();
858   gpuPopAttr();
859 }
860
861 BLI_INLINE void draw_tri_point(
862     unsigned int pos, float sel_col[4], float pivot_col[4], float *co, float width, bool selected)
863 {
864   immUniformColor4fv(selected ? sel_col : pivot_col);
865
866   GPU_line_width(3.0f);
867
868   float w = width / 2.0f;
869   float tri[3][2] = {
870       {co[0], co[1] + w},
871       {co[0] - w, co[1] - w},
872       {co[0] + w, co[1] - w},
873   };
874
875   immBegin(GPU_PRIM_LINE_LOOP, 3);
876   immVertex2fv(pos, tri[0]);
877   immVertex2fv(pos, tri[1]);
878   immVertex2fv(pos, tri[2]);
879   immEnd();
880
881   immUniformColor4f(1.0f, 1.0f, 1.0f, 0.5f);
882   GPU_line_width(1.0f);
883
884   immBegin(GPU_PRIM_LINE_LOOP, 3);
885   immVertex2fv(pos, tri[0]);
886   immVertex2fv(pos, tri[1]);
887   immVertex2fv(pos, tri[2]);
888   immEnd();
889 }
890
891 BLI_INLINE void draw_rect_point(
892     unsigned int pos, float sel_col[4], float handle_col[4], float *co, float width, bool selected)
893 {
894   immUniformColor4fv(selected ? sel_col : handle_col);
895
896   GPU_line_width(3.0f);
897
898   float w = width / 2.0f;
899   float minx = co[0] - w;
900   float miny = co[1] - w;
901   float maxx = co[0] + w;
902   float maxy = co[1] + w;
903
904   imm_draw_box_wire_2d(pos, minx, miny, maxx, maxy);
905
906   immUniformColor4f(1.0f, 1.0f, 1.0f, 0.5f);
907   GPU_line_width(1.0f);
908
909   imm_draw_box_wire_2d(pos, minx, miny, maxx, maxy);
910 }
911
912 BLI_INLINE void draw_bezier_handle_lines(unsigned int pos, float sel_col[4], BezTriple *bez)
913 {
914   immUniformColor4f(0.0f, 0.0f, 0.0f, 0.5f);
915   GPU_line_width(3.0f);
916
917   immBegin(GPU_PRIM_LINE_STRIP, 3);
918   immVertex2fv(pos, bez->vec[0]);
919   immVertex2fv(pos, bez->vec[1]);
920   immVertex2fv(pos, bez->vec[2]);
921   immEnd();
922
923   GPU_line_width(1.0f);
924
925   if (bez->f1 || bez->f2) {
926     immUniformColor4fv(sel_col);
927   }
928   else {
929     immUniformColor4f(1.0f, 1.0f, 1.0f, 0.5f);
930   }
931   immBegin(GPU_PRIM_LINES, 2);
932   immVertex2fv(pos, bez->vec[0]);
933   immVertex2fv(pos, bez->vec[1]);
934   immEnd();
935
936   if (bez->f3 || bez->f2) {
937     immUniformColor4fv(sel_col);
938   }
939   else {
940     immUniformColor4f(1.0f, 1.0f, 1.0f, 0.5f);
941   }
942   immBegin(GPU_PRIM_LINES, 2);
943   immVertex2fv(pos, bez->vec[1]);
944   immVertex2fv(pos, bez->vec[2]);
945   immEnd();
946 }
947
948 static void paint_draw_curve_cursor(Brush *brush, ViewContext *vc)
949 {
950   GPU_matrix_push();
951   GPU_matrix_translate_2f(vc->ar->winrct.xmin, vc->ar->winrct.ymin);
952
953   if (brush->paint_curve && brush->paint_curve->points) {
954     int i;
955     PaintCurve *pc = brush->paint_curve;
956     PaintCurvePoint *cp = pc->points;
957
958     GPU_line_smooth(true);
959     GPU_blend(true);
960
961     /* draw the bezier handles and the curve segment between the current and next point */
962     uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
963
964     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
965
966     float selec_col[4], handle_col[4], pivot_col[4];
967     UI_GetThemeColor4fv(TH_VERTEX_SELECT, selec_col);
968     UI_GetThemeColor4fv(TH_PAINT_CURVE_HANDLE, handle_col);
969     UI_GetThemeColor4fv(TH_PAINT_CURVE_PIVOT, pivot_col);
970
971     for (i = 0; i < pc->tot_points - 1; i++, cp++) {
972       int j;
973       PaintCurvePoint *cp_next = cp + 1;
974       float data[(PAINT_CURVE_NUM_SEGMENTS + 1) * 2];
975       /* use color coding to distinguish handles vs curve segments  */
976       draw_bezier_handle_lines(pos, selec_col, &cp->bez);
977       draw_tri_point(pos, selec_col, pivot_col, &cp->bez.vec[1][0], 10.0f, cp->bez.f2);
978       draw_rect_point(
979           pos, selec_col, handle_col, &cp->bez.vec[0][0], 8.0f, cp->bez.f1 || cp->bez.f2);
980       draw_rect_point(
981           pos, selec_col, handle_col, &cp->bez.vec[2][0], 8.0f, cp->bez.f3 || cp->bez.f2);
982
983       for (j = 0; j < 2; j++) {
984         BKE_curve_forward_diff_bezier(cp->bez.vec[1][j],
985                                       cp->bez.vec[2][j],
986                                       cp_next->bez.vec[0][j],
987                                       cp_next->bez.vec[1][j],
988                                       data + j,
989                                       PAINT_CURVE_NUM_SEGMENTS,
990                                       sizeof(float[2]));
991       }
992
993       float(*v)[2] = (float(*)[2])data;
994
995       immUniformColor4f(0.0f, 0.0f, 0.0f, 0.5f);
996       GPU_line_width(3.0f);
997       immBegin(GPU_PRIM_LINE_STRIP, PAINT_CURVE_NUM_SEGMENTS + 1);
998       for (j = 0; j <= PAINT_CURVE_NUM_SEGMENTS; j++) {
999         immVertex2fv(pos, v[j]);
1000       }
1001       immEnd();
1002
1003       immUniformColor4f(0.9f, 0.9f, 1.0f, 0.5f);
1004       GPU_line_width(1.0f);
1005       immBegin(GPU_PRIM_LINE_STRIP, PAINT_CURVE_NUM_SEGMENTS + 1);
1006       for (j = 0; j <= PAINT_CURVE_NUM_SEGMENTS; j++) {
1007         immVertex2fv(pos, v[j]);
1008       }
1009       immEnd();
1010     }
1011
1012     /* draw last line segment */
1013     draw_bezier_handle_lines(pos, selec_col, &cp->bez);
1014     draw_tri_point(pos, selec_col, pivot_col, &cp->bez.vec[1][0], 10.0f, cp->bez.f2);
1015     draw_rect_point(
1016         pos, selec_col, handle_col, &cp->bez.vec[0][0], 8.0f, cp->bez.f1 || cp->bez.f2);
1017     draw_rect_point(
1018         pos, selec_col, handle_col, &cp->bez.vec[2][0], 8.0f, cp->bez.f3 || cp->bez.f2);
1019
1020     GPU_blend(false);
1021     GPU_line_smooth(false);
1022
1023     immUnbindProgram();
1024   }
1025   GPU_matrix_pop();
1026 }
1027
1028 /* Special actions taken when paint cursor goes over mesh */
1029 /* TODO: sculpt only for now */
1030 static void paint_cursor_on_hit(UnifiedPaintSettings *ups,
1031                                 Brush *brush,
1032                                 ViewContext *vc,
1033                                 const float location[3])
1034 {
1035   float unprojected_radius, projected_radius;
1036
1037   /* update the brush's cached 3D radius */
1038   if (!BKE_brush_use_locked_size(vc->scene, brush)) {
1039     /* get 2D brush radius */
1040     if (ups->draw_anchored) {
1041       projected_radius = ups->anchored_size;
1042     }
1043     else {
1044       if (brush->flag & BRUSH_ANCHORED) {
1045         projected_radius = 8;
1046       }
1047       else {
1048         projected_radius = BKE_brush_size_get(vc->scene, brush);
1049       }
1050     }
1051
1052     /* convert brush radius from 2D to 3D */
1053     unprojected_radius = paint_calc_object_space_radius(vc, location, projected_radius);
1054
1055     /* scale 3D brush radius by pressure */
1056     if (ups->stroke_active && BKE_brush_use_size_pressure(vc->scene, brush)) {
1057       unprojected_radius *= ups->size_pressure_value;
1058     }
1059
1060     /* set cached value in either Brush or UnifiedPaintSettings */
1061     BKE_brush_unprojected_radius_set(vc->scene, brush, unprojected_radius);
1062   }
1063 }
1064
1065 static bool ommit_cursor_drawing(Paint *paint, ePaintMode mode, Brush *brush)
1066 {
1067   if (paint->flags & PAINT_SHOW_BRUSH) {
1068     if (ELEM(mode, PAINT_MODE_TEXTURE_2D, PAINT_MODE_TEXTURE_3D) &&
1069         brush->imagepaint_tool == PAINT_TOOL_FILL) {
1070       return true;
1071     }
1072     return false;
1073   }
1074   return true;
1075 }
1076
1077 static void paint_draw_cursor(bContext *C, int x, int y, void *UNUSED(unused))
1078 {
1079   Scene *scene = CTX_data_scene(C);
1080   ARegion *ar = CTX_wm_region(C);
1081   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
1082   Paint *paint = BKE_paint_get_active_from_context(C);
1083   Brush *brush = BKE_paint_brush(paint);
1084   ePaintMode mode = BKE_paintmode_get_active_from_context(C);
1085
1086   /* check that brush drawing is enabled */
1087   if (ommit_cursor_drawing(paint, mode, brush)) {
1088     return;
1089   }
1090
1091   /* can't use stroke vc here because this will be called during
1092    * mouse over too, not just during a stroke */
1093   ViewContext vc;
1094   ED_view3d_viewcontext_init(C, &vc);
1095
1096   if (vc.rv3d && (vc.rv3d->rflag & RV3D_NAVIGATING)) {
1097     return;
1098   }
1099
1100   /* skip everything and draw brush here */
1101   if (brush->flag & BRUSH_CURVE) {
1102     paint_draw_curve_cursor(brush, &vc);
1103     return;
1104   }
1105
1106   float zoomx, zoomy;
1107   get_imapaint_zoom(C, &zoomx, &zoomy);
1108   zoomx = max_ff(zoomx, zoomy);
1109
1110   /* set various defaults */
1111   const float *outline_col = brush->add_col;
1112   const float outline_alpha = 0.5f;
1113   float translation[2] = {x, y};
1114   float final_radius = (BKE_brush_size_get(scene, brush) * zoomx);
1115
1116   /* don't calculate rake angles while a stroke is active because the rake variables are global
1117    * and we may get interference with the stroke itself.
1118    * For line strokes, such interference is visible */
1119   if (!ups->stroke_active) {
1120     paint_calculate_rake_rotation(ups, brush, translation);
1121   }
1122
1123   /* draw overlay */
1124   paint_draw_alpha_overlay(ups, brush, &vc, x, y, zoomx, mode);
1125
1126   /* TODO: as sculpt and other paint modes are unified, this
1127    * special mode of drawing will go away */
1128   if ((mode == PAINT_MODE_SCULPT) && vc.obact->sculpt) {
1129     float location[3];
1130     int pixel_radius;
1131
1132     /* test if brush is over the mesh */
1133     bool hit = sculpt_get_brush_geometry(C, &vc, x, y, &pixel_radius, location, ups);
1134
1135     if (BKE_brush_use_locked_size(scene, brush)) {
1136       BKE_brush_size_set(scene, brush, pixel_radius);
1137     }
1138
1139     /* check if brush is subtracting, use different color then */
1140     /* TODO: no way currently to know state of pen flip or
1141      * invert key modifier without starting a stroke */
1142     if (((ups->draw_inverted == 0) ^ ((brush->flag & BRUSH_DIR_IN) == 0)) &&
1143         BKE_brush_sculpt_has_secondary_color(brush)) {
1144       outline_col = brush->sub_col;
1145     }
1146
1147     /* only do if brush is over the mesh */
1148     if (hit) {
1149       paint_cursor_on_hit(ups, brush, &vc, location);
1150     }
1151   }
1152
1153   if (ups->draw_anchored) {
1154     final_radius = ups->anchored_size;
1155     copy_v2_fl2(translation,
1156                 ups->anchored_initial_mouse[0] + ar->winrct.xmin,
1157                 ups->anchored_initial_mouse[1] + ar->winrct.ymin);
1158   }
1159
1160   /* make lines pretty */
1161   GPU_line_width(1.0f);
1162   GPU_blend(true); /* TODO: also set blend mode? */
1163   GPU_line_smooth(true);
1164
1165   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1166   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1167
1168   /* set brush color */
1169   immUniformColor3fvAlpha(outline_col, outline_alpha);
1170
1171   /* draw brush outline */
1172   if (ups->stroke_active && BKE_brush_use_size_pressure(scene, brush)) {
1173     /* inner at full alpha */
1174     imm_draw_circle_wire_2d(
1175         pos, translation[0], translation[1], final_radius * ups->size_pressure_value, 40);
1176     /* outer at half alpha */
1177     immUniformColor3fvAlpha(outline_col, outline_alpha * 0.5f);
1178   }
1179   imm_draw_circle_wire_2d(pos, translation[0], translation[1], final_radius, 40);
1180
1181   immUnbindProgram();
1182
1183   /* restore GL state */
1184   GPU_blend(false);
1185   GPU_line_smooth(false);
1186 }
1187
1188 /* Public API */
1189
1190 void paint_cursor_start(bContext *C, bool (*poll)(bContext *C))
1191 {
1192   Paint *p = BKE_paint_get_active_from_context(C);
1193
1194   if (p && !p->paint_cursor) {
1195     p->paint_cursor = WM_paint_cursor_activate(
1196         CTX_wm_manager(C), SPACE_TYPE_ANY, RGN_TYPE_ANY, poll, paint_draw_cursor, NULL);
1197   }
1198
1199   /* invalidate the paint cursors */
1200   BKE_paint_invalidate_overlay_all();
1201 }
1202
1203 void paint_cursor_start_explicit(Paint *p, wmWindowManager *wm, bool (*poll)(bContext *C))
1204 {
1205   if (p && !p->paint_cursor) {
1206     p->paint_cursor = WM_paint_cursor_activate(
1207         wm, SPACE_TYPE_ANY, RGN_TYPE_ANY, poll, paint_draw_cursor, NULL);
1208   }
1209 }