Industry Compat keymap: cleanup
[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 #include "BKE_object.h"
49
50 #include "WM_api.h"
51 #include "wm_cursors.h"
52
53 #include "IMB_imbuf_types.h"
54
55 #include "ED_view3d.h"
56
57 #include "DEG_depsgraph.h"
58
59 #include "GPU_draw.h"
60 #include "GPU_immediate.h"
61 #include "GPU_immediate_util.h"
62 #include "GPU_matrix.h"
63 #include "GPU_state.h"
64
65 #include "UI_resources.h"
66
67 #include "paint_intern.h"
68 /* still needed for sculpt_stroke_get_location, should be
69  * removed eventually (TODO) */
70 #include "sculpt_intern.h"
71
72 /* TODOs:
73  *
74  * Some of the cursor drawing code is doing non-draw stuff
75  * (e.g. updating the brush rake angle). This should be cleaned up
76  * still.
77  *
78  * There is also some ugliness with sculpt-specific code.
79  */
80
81 typedef struct TexSnapshot {
82   GLuint overlay_texture;
83   int winx;
84   int winy;
85   int old_size;
86   float old_zoom;
87   bool old_col;
88 } TexSnapshot;
89
90 typedef struct CursorSnapshot {
91   GLuint overlay_texture;
92   int size;
93   int zoom;
94   int curve_preset;
95 } CursorSnapshot;
96
97 static TexSnapshot primary_snap = {0};
98 static TexSnapshot secondary_snap = {0};
99 static CursorSnapshot cursor_snap = {0};
100
101 /* delete overlay cursor textures to preserve memory and invalidate all overlay flags */
102 void paint_cursor_delete_textures(void)
103 {
104   if (primary_snap.overlay_texture) {
105     glDeleteTextures(1, &primary_snap.overlay_texture);
106   }
107   if (secondary_snap.overlay_texture) {
108     glDeleteTextures(1, &secondary_snap.overlay_texture);
109   }
110   if (cursor_snap.overlay_texture) {
111     glDeleteTextures(1, &cursor_snap.overlay_texture);
112   }
113
114   memset(&primary_snap, 0, sizeof(TexSnapshot));
115   memset(&secondary_snap, 0, sizeof(TexSnapshot));
116   memset(&cursor_snap, 0, sizeof(CursorSnapshot));
117
118   BKE_paint_invalidate_overlay_all();
119 }
120
121 static int same_tex_snap(TexSnapshot *snap, MTex *mtex, ViewContext *vc, bool col, float zoom)
122 {
123   return (/* make brush smaller shouldn't cause a resample */
124           //(mtex->brush_map_mode != MTEX_MAP_MODE_VIEW ||
125           //(BKE_brush_size_get(vc->scene, brush) <= snap->BKE_brush_size_get)) &&
126
127           (mtex->brush_map_mode != MTEX_MAP_MODE_TILED ||
128            (vc->ar->winx == snap->winx && vc->ar->winy == snap->winy)) &&
129           (mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL || snap->old_zoom == zoom) &&
130           snap->old_col == col);
131 }
132
133 static void make_tex_snap(TexSnapshot *snap, ViewContext *vc, float zoom)
134 {
135   snap->old_zoom = zoom;
136   snap->winx = vc->ar->winx;
137   snap->winy = vc->ar->winy;
138 }
139
140 typedef struct LoadTexData {
141   Brush *br;
142   ViewContext *vc;
143
144   MTex *mtex;
145   GLubyte *buffer;
146   bool col;
147
148   struct ImagePool *pool;
149   int size;
150   float rotation;
151   float radius;
152 } LoadTexData;
153
154 static void load_tex_task_cb_ex(void *__restrict userdata,
155                                 const int j,
156                                 const TaskParallelTLS *__restrict tls)
157 {
158   LoadTexData *data = userdata;
159   Brush *br = data->br;
160   ViewContext *vc = data->vc;
161
162   MTex *mtex = data->mtex;
163   GLubyte *buffer = data->buffer;
164   const bool col = data->col;
165
166   struct ImagePool *pool = data->pool;
167   const int size = data->size;
168   const float rotation = data->rotation;
169   const float radius = data->radius;
170
171   bool convert_to_linear = false;
172   struct ColorSpace *colorspace = NULL;
173
174   if (mtex->tex && mtex->tex->type == TEX_IMAGE && mtex->tex->ima) {
175     ImBuf *tex_ibuf = BKE_image_pool_acquire_ibuf(mtex->tex->ima, &mtex->tex->iuser, pool);
176     /* For consistency, sampling always returns color in linear space */
177     if (tex_ibuf && tex_ibuf->rect_float == NULL) {
178       convert_to_linear = true;
179       colorspace = tex_ibuf->rect_colorspace;
180     }
181     BKE_image_pool_release_ibuf(mtex->tex->ima, tex_ibuf, pool);
182   }
183
184   for (int i = 0; i < size; i++) {
185     // largely duplicated from tex_strength
186
187     int index = j * size + i;
188
189     float x = (float)i / size;
190     float y = (float)j / size;
191     float len;
192
193     if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
194       x *= vc->ar->winx / radius;
195       y *= vc->ar->winy / radius;
196     }
197     else {
198       x = (x - 0.5f) * 2.0f;
199       y = (y - 0.5f) * 2.0f;
200     }
201
202     len = sqrtf(x * x + y * y);
203
204     if (ELEM(mtex->brush_map_mode, MTEX_MAP_MODE_TILED, MTEX_MAP_MODE_STENCIL) || len <= 1.0f) {
205       /* It is probably worth optimizing for those cases where the texture is not rotated by
206        * skipping the calls to atan2, sqrtf, sin, and cos. */
207       if (mtex->tex && (rotation > 0.001f || rotation < -0.001f)) {
208         const float angle = atan2f(y, x) + rotation;
209
210         x = len * cosf(angle);
211         y = len * sinf(angle);
212       }
213
214       if (col) {
215         float rgba[4];
216
217         paint_get_tex_pixel_col(
218             mtex, x, y, rgba, pool, tls->thread_id, convert_to_linear, colorspace);
219
220         buffer[index * 4] = rgba[0] * 255;
221         buffer[index * 4 + 1] = rgba[1] * 255;
222         buffer[index * 4 + 2] = rgba[2] * 255;
223         buffer[index * 4 + 3] = rgba[3] * 255;
224       }
225       else {
226         float avg = paint_get_tex_pixel(mtex, x, y, pool, tls->thread_id);
227
228         avg += br->texture_sample_bias;
229
230         /* clamp to avoid precision overflow */
231         CLAMP(avg, 0.0f, 1.0f);
232         buffer[index] = 255 - (GLubyte)(255 * avg);
233       }
234     }
235     else {
236       if (col) {
237         buffer[index * 4] = 0;
238         buffer[index * 4 + 1] = 0;
239         buffer[index * 4 + 2] = 0;
240         buffer[index * 4 + 3] = 0;
241       }
242       else {
243         buffer[index] = 0;
244       }
245     }
246   }
247 }
248
249 static int load_tex(Brush *br, ViewContext *vc, float zoom, bool col, bool primary)
250 {
251   bool init;
252   TexSnapshot *target;
253
254   MTex *mtex = (primary) ? &br->mtex : &br->mask_mtex;
255   ePaintOverlayControlFlags overlay_flags = BKE_paint_get_overlay_flags();
256   GLubyte *buffer = NULL;
257
258   int size;
259   bool refresh;
260   ePaintOverlayControlFlags invalid =
261       ((primary) ? (overlay_flags & PAINT_OVERLAY_INVALID_TEXTURE_PRIMARY) :
262                    (overlay_flags & PAINT_OVERLAY_INVALID_TEXTURE_SECONDARY));
263   target = (primary) ? &primary_snap : &secondary_snap;
264
265   refresh = !target->overlay_texture || (invalid != 0) ||
266             !same_tex_snap(target, mtex, vc, col, zoom);
267
268   init = (target->overlay_texture != 0);
269
270   if (refresh) {
271     struct ImagePool *pool = NULL;
272     /* stencil is rotated later */
273     const float rotation = (mtex->brush_map_mode != MTEX_MAP_MODE_STENCIL) ? -mtex->rot : 0.0f;
274     const float radius = BKE_brush_size_get(vc->scene, br) * zoom;
275
276     make_tex_snap(target, vc, zoom);
277
278     if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
279       int s = BKE_brush_size_get(vc->scene, br);
280       int r = 1;
281
282       for (s >>= 1; s > 0; s >>= 1) {
283         r++;
284       }
285
286       size = (1 << r);
287
288       if (size < 256) {
289         size = 256;
290       }
291
292       if (size < target->old_size) {
293         size = target->old_size;
294       }
295     }
296     else {
297       size = 512;
298     }
299
300     if (target->old_size != size) {
301       if (target->overlay_texture) {
302         glDeleteTextures(1, &target->overlay_texture);
303         target->overlay_texture = 0;
304       }
305
306       init = false;
307
308       target->old_size = size;
309     }
310     if (col) {
311       buffer = MEM_mallocN(sizeof(GLubyte) * size * size * 4, "load_tex");
312     }
313     else {
314       buffer = MEM_mallocN(sizeof(GLubyte) * size * size, "load_tex");
315     }
316
317     pool = BKE_image_pool_new();
318
319     if (mtex->tex && mtex->tex->nodetree) {
320       /* has internal flag to detect it only does it once */
321       ntreeTexBeginExecTree(mtex->tex->nodetree);
322     }
323
324     LoadTexData data = {
325         .br = br,
326         .vc = vc,
327         .mtex = mtex,
328         .buffer = buffer,
329         .col = col,
330         .pool = pool,
331         .size = size,
332         .rotation = rotation,
333         .radius = radius,
334     };
335
336     TaskParallelSettings settings;
337     BLI_parallel_range_settings_defaults(&settings);
338     BLI_task_parallel_range(0, size, &data, load_tex_task_cb_ex, &settings);
339
340     if (mtex->tex && mtex->tex->nodetree) {
341       ntreeTexEndExecTree(mtex->tex->nodetree->execdata);
342     }
343
344     if (pool) {
345       BKE_image_pool_free(pool);
346     }
347
348     if (!target->overlay_texture) {
349       glGenTextures(1, &target->overlay_texture);
350     }
351   }
352   else {
353     size = target->old_size;
354   }
355
356   glActiveTexture(GL_TEXTURE0);
357   glBindTexture(GL_TEXTURE_2D, target->overlay_texture);
358
359   if (refresh) {
360     GLenum format = col ? GL_RGBA : GL_RED;
361     GLenum internalformat = col ? GL_RGBA8 : GL_R8;
362
363     if (!init || (target->old_col != col)) {
364       glTexImage2D(
365           GL_TEXTURE_2D, 0, internalformat, size, size, 0, format, GL_UNSIGNED_BYTE, buffer);
366     }
367     else {
368       glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size, size, format, GL_UNSIGNED_BYTE, buffer);
369     }
370
371     if (buffer) {
372       MEM_freeN(buffer);
373     }
374
375     target->old_col = col;
376   }
377
378   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
379   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
380
381   if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
382     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
383     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
384   }
385
386   BKE_paint_reset_overlay_invalid(invalid);
387
388   return 1;
389 }
390
391 static void load_tex_cursor_task_cb(void *__restrict userdata,
392                                     const int j,
393                                     const TaskParallelTLS *__restrict UNUSED(tls))
394 {
395   LoadTexData *data = userdata;
396   Brush *br = data->br;
397
398   GLubyte *buffer = data->buffer;
399
400   const int size = data->size;
401
402   for (int i = 0; i < size; i++) {
403     // largely duplicated from tex_strength
404
405     const int index = j * size + i;
406     const float x = (((float)i / size) - 0.5f) * 2.0f;
407     const float y = (((float)j / size) - 0.5f) * 2.0f;
408     const float len = sqrtf(x * x + y * y);
409
410     if (len <= 1.0f) {
411       float avg = BKE_brush_curve_strength_clamped(br, len, 1.0f); /* Falloff curve */
412
413       buffer[index] = (GLubyte)(255 * avg);
414     }
415     else {
416       buffer[index] = 0;
417     }
418   }
419 }
420
421 static int load_tex_cursor(Brush *br, ViewContext *vc, float zoom)
422 {
423   bool init;
424
425   ePaintOverlayControlFlags overlay_flags = BKE_paint_get_overlay_flags();
426   GLubyte *buffer = NULL;
427
428   int size;
429   const bool refresh = !cursor_snap.overlay_texture ||
430                        (overlay_flags & PAINT_OVERLAY_INVALID_CURVE) || cursor_snap.zoom != zoom ||
431                        cursor_snap.curve_preset != br->curve_preset;
432
433   init = (cursor_snap.overlay_texture != 0);
434
435   if (refresh) {
436     int s, r;
437
438     cursor_snap.zoom = zoom;
439
440     s = BKE_brush_size_get(vc->scene, br);
441     r = 1;
442
443     for (s >>= 1; s > 0; s >>= 1) {
444       r++;
445     }
446
447     size = (1 << r);
448
449     if (size < 256) {
450       size = 256;
451     }
452
453     if (size < cursor_snap.size) {
454       size = cursor_snap.size;
455     }
456
457     if (cursor_snap.size != size) {
458       if (cursor_snap.overlay_texture) {
459         glDeleteTextures(1, &cursor_snap.overlay_texture);
460         cursor_snap.overlay_texture = 0;
461       }
462
463       init = false;
464
465       cursor_snap.size = size;
466     }
467     buffer = MEM_mallocN(sizeof(GLubyte) * size * size, "load_tex");
468
469     BKE_curvemapping_initialize(br->curve);
470
471     LoadTexData data = {
472         .br = br,
473         .buffer = buffer,
474         .size = size,
475     };
476
477     TaskParallelSettings settings;
478     BLI_parallel_range_settings_defaults(&settings);
479     BLI_task_parallel_range(0, size, &data, load_tex_cursor_task_cb, &settings);
480
481     if (!cursor_snap.overlay_texture) {
482       glGenTextures(1, &cursor_snap.overlay_texture);
483     }
484   }
485   else {
486     size = cursor_snap.size;
487   }
488
489   glActiveTexture(GL_TEXTURE0);
490   glBindTexture(GL_TEXTURE_2D, cursor_snap.overlay_texture);
491
492   if (refresh) {
493     if (!init) {
494       glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, size, size, 0, GL_RED, GL_UNSIGNED_BYTE, buffer);
495     }
496     else {
497       glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size, size, GL_RED, GL_UNSIGNED_BYTE, buffer);
498     }
499
500     if (buffer) {
501       MEM_freeN(buffer);
502     }
503   }
504
505   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
506   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
507
508   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
509   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
510
511   cursor_snap.curve_preset = br->curve_preset;
512   BKE_paint_reset_overlay_invalid(PAINT_OVERLAY_INVALID_CURVE);
513
514   return 1;
515 }
516
517 static int project_brush_radius(ViewContext *vc, float radius, const float location[3])
518 {
519   float view[3], nonortho[3], ortho[3], offset[3], p1[2], p2[2];
520
521   ED_view3d_global_to_vector(vc->rv3d, location, view);
522
523   /* create a vector that is not orthogonal to view */
524
525   if (fabsf(view[0]) < 0.1f) {
526     nonortho[0] = view[0] + 1.0f;
527     nonortho[1] = view[1];
528     nonortho[2] = view[2];
529   }
530   else if (fabsf(view[1]) < 0.1f) {
531     nonortho[0] = view[0];
532     nonortho[1] = view[1] + 1.0f;
533     nonortho[2] = view[2];
534   }
535   else {
536     nonortho[0] = view[0];
537     nonortho[1] = view[1];
538     nonortho[2] = view[2] + 1.0f;
539   }
540
541   /* get a vector in the plane of the view */
542   cross_v3_v3v3(ortho, nonortho, view);
543   normalize_v3(ortho);
544
545   /* make a point on the surface of the brush tangent to the view */
546   mul_v3_fl(ortho, radius);
547   add_v3_v3v3(offset, location, ortho);
548
549   /* project the center of the brush, and the tangent point to the view onto the screen */
550   if ((ED_view3d_project_float_global(vc->ar, location, p1, V3D_PROJ_TEST_NOP) ==
551        V3D_PROJ_RET_OK) &&
552       (ED_view3d_project_float_global(vc->ar, offset, p2, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK)) {
553     /* the distance between these points is the size of the projected brush in pixels */
554     return len_v2v2(p1, p2);
555   }
556   else {
557     BLI_assert(0); /* assert because the code that sets up the vectors should disallow this */
558     return 0;
559   }
560 }
561
562 static bool sculpt_get_brush_geometry(bContext *C,
563                                       ViewContext *vc,
564                                       int x,
565                                       int y,
566                                       int *pixel_radius,
567                                       float location[3],
568                                       UnifiedPaintSettings *ups)
569 {
570   Scene *scene = CTX_data_scene(C);
571   Paint *paint = BKE_paint_get_active_from_context(C);
572   float mouse[2];
573   bool hit = false;
574
575   mouse[0] = x;
576   mouse[1] = y;
577
578   if (vc->obact->sculpt && vc->obact->sculpt->pbvh) {
579     if (!ups->stroke_active) {
580       hit = sculpt_stroke_get_location(C, location, mouse);
581     }
582     else {
583       hit = ups->last_hit;
584       copy_v3_v3(location, ups->last_location);
585     }
586   }
587
588   if (hit) {
589     Brush *brush = BKE_paint_brush(paint);
590
591     *pixel_radius = project_brush_radius(
592         vc, BKE_brush_unprojected_radius_get(scene, brush), location);
593
594     if (*pixel_radius == 0) {
595       *pixel_radius = BKE_brush_size_get(scene, brush);
596     }
597
598     mul_m4_v3(vc->obact->obmat, location);
599   }
600   else {
601     Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
602     Brush *brush = BKE_paint_brush(&sd->paint);
603
604     *pixel_radius = BKE_brush_size_get(scene, brush);
605   }
606
607   return hit;
608 }
609
610 /* Draw an overlay that shows what effect the brush's texture will
611  * have on brush strength */
612 static bool paint_draw_tex_overlay(UnifiedPaintSettings *ups,
613                                    Brush *brush,
614                                    ViewContext *vc,
615                                    int x,
616                                    int y,
617                                    float zoom,
618                                    bool col,
619                                    bool primary)
620 {
621   rctf quad;
622   /* check for overlay mode */
623
624   MTex *mtex = (primary) ? &brush->mtex : &brush->mask_mtex;
625   bool valid = ((primary) ? (brush->overlay_flags & BRUSH_OVERLAY_PRIMARY) != 0 :
626                             (brush->overlay_flags & BRUSH_OVERLAY_SECONDARY) != 0);
627   int overlay_alpha = (primary) ? brush->texture_overlay_alpha : brush->mask_overlay_alpha;
628
629   if (!(mtex->tex) ||
630       !((mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL) ||
631         (valid && ELEM(mtex->brush_map_mode, MTEX_MAP_MODE_VIEW, MTEX_MAP_MODE_TILED)))) {
632     return false;
633   }
634
635   if (load_tex(brush, vc, zoom, col, primary)) {
636     GPU_blend(true);
637
638     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
639     glDepthMask(GL_FALSE);
640     glDepthFunc(GL_ALWAYS);
641
642     if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
643       GPU_matrix_push();
644
645       /* brush rotation */
646       GPU_matrix_translate_2f(x, y);
647       GPU_matrix_rotate_2d(-RAD2DEGF(primary ? ups->brush_rotation : ups->brush_rotation_sec));
648       GPU_matrix_translate_2f(-x, -y);
649
650       /* scale based on tablet pressure */
651       if (primary && ups->stroke_active && BKE_brush_use_size_pressure(brush)) {
652         const float scale = ups->size_pressure_value;
653         GPU_matrix_translate_2f(x, y);
654         GPU_matrix_scale_2f(scale, scale);
655         GPU_matrix_translate_2f(-x, -y);
656       }
657
658       if (ups->draw_anchored) {
659         quad.xmin = ups->anchored_initial_mouse[0] - ups->anchored_size;
660         quad.ymin = ups->anchored_initial_mouse[1] - ups->anchored_size;
661         quad.xmax = ups->anchored_initial_mouse[0] + ups->anchored_size;
662         quad.ymax = ups->anchored_initial_mouse[1] + ups->anchored_size;
663       }
664       else {
665         const int radius = BKE_brush_size_get(vc->scene, brush) * zoom;
666         quad.xmin = x - radius;
667         quad.ymin = y - radius;
668         quad.xmax = x + radius;
669         quad.ymax = y + radius;
670       }
671     }
672     else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
673       quad.xmin = 0;
674       quad.ymin = 0;
675       quad.xmax = BLI_rcti_size_x(&vc->ar->winrct);
676       quad.ymax = BLI_rcti_size_y(&vc->ar->winrct);
677     }
678     /* Stencil code goes here */
679     else {
680       if (primary) {
681         quad.xmin = -brush->stencil_dimension[0];
682         quad.ymin = -brush->stencil_dimension[1];
683         quad.xmax = brush->stencil_dimension[0];
684         quad.ymax = brush->stencil_dimension[1];
685       }
686       else {
687         quad.xmin = -brush->mask_stencil_dimension[0];
688         quad.ymin = -brush->mask_stencil_dimension[1];
689         quad.xmax = brush->mask_stencil_dimension[0];
690         quad.ymax = brush->mask_stencil_dimension[1];
691       }
692       GPU_matrix_push();
693       if (primary) {
694         GPU_matrix_translate_2fv(brush->stencil_pos);
695       }
696       else {
697         GPU_matrix_translate_2fv(brush->mask_stencil_pos);
698       }
699       GPU_matrix_rotate_2d(RAD2DEGF(mtex->rot));
700     }
701
702     /* set quad color. Colored overlay does not get blending */
703     GPUVertFormat *format = immVertexFormat();
704     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
705     uint texCoord = GPU_vertformat_attr_add(format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
706
707     if (col) {
708       immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_COLOR);
709       immUniformColor4f(1.0f, 1.0f, 1.0f, overlay_alpha * 0.01f);
710     }
711     else {
712       GPU_blend_set_func(GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
713       immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_ALPHA_COLOR);
714       immUniformColor3fvAlpha(U.sculpt_paint_overlay_col, overlay_alpha * 0.01f);
715     }
716
717     /* draw textured quad */
718     immUniform1i("image", 0);
719
720     immBegin(GPU_PRIM_TRI_FAN, 4);
721     immAttr2f(texCoord, 0.0f, 0.0f);
722     immVertex2f(pos, quad.xmin, quad.ymin);
723     immAttr2f(texCoord, 1.0f, 0.0f);
724     immVertex2f(pos, quad.xmax, quad.ymin);
725     immAttr2f(texCoord, 1.0f, 1.0f);
726     immVertex2f(pos, quad.xmax, quad.ymax);
727     immAttr2f(texCoord, 0.0f, 1.0f);
728     immVertex2f(pos, quad.xmin, quad.ymax);
729     immEnd();
730
731     immUnbindProgram();
732     GPU_blend_set_func(GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA);
733
734     if (ELEM(mtex->brush_map_mode, MTEX_MAP_MODE_STENCIL, MTEX_MAP_MODE_VIEW)) {
735       GPU_matrix_pop();
736     }
737   }
738   return true;
739 }
740
741 /* Draw an overlay that shows what effect the brush's texture will
742  * have on brush strength */
743 static bool paint_draw_cursor_overlay(
744     UnifiedPaintSettings *ups, Brush *brush, ViewContext *vc, int x, int y, float zoom)
745 {
746   rctf quad;
747   /* check for overlay mode */
748
749   if (!(brush->overlay_flags & BRUSH_OVERLAY_CURSOR)) {
750     return false;
751   }
752
753   if (load_tex_cursor(brush, vc, zoom)) {
754     bool do_pop = false;
755     float center[2];
756     GPU_blend(true);
757
758     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
759     glDepthMask(GL_FALSE);
760     glDepthFunc(GL_ALWAYS);
761
762     if (ups->draw_anchored) {
763       copy_v2_v2(center, ups->anchored_initial_mouse);
764       quad.xmin = ups->anchored_initial_mouse[0] - ups->anchored_size;
765       quad.ymin = ups->anchored_initial_mouse[1] - ups->anchored_size;
766       quad.xmax = ups->anchored_initial_mouse[0] + ups->anchored_size;
767       quad.ymax = ups->anchored_initial_mouse[1] + ups->anchored_size;
768     }
769     else {
770       const int radius = BKE_brush_size_get(vc->scene, brush) * zoom;
771       center[0] = x;
772       center[1] = y;
773
774       quad.xmin = x - radius;
775       quad.ymin = y - radius;
776       quad.xmax = x + radius;
777       quad.ymax = y + radius;
778     }
779
780     /* scale based on tablet pressure */
781     if (ups->stroke_active && BKE_brush_use_size_pressure(brush)) {
782       do_pop = true;
783       GPU_matrix_push();
784       GPU_matrix_translate_2fv(center);
785       GPU_matrix_scale_1f(ups->size_pressure_value);
786       GPU_matrix_translate_2f(-center[0], -center[1]);
787     }
788
789     GPUVertFormat *format = immVertexFormat();
790     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
791     uint texCoord = GPU_vertformat_attr_add(format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
792
793     GPU_blend_set_func(GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
794     immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_ALPHA_COLOR);
795
796     immUniformColor3fvAlpha(U.sculpt_paint_overlay_col, brush->cursor_overlay_alpha * 0.01f);
797
798     /* draw textured quad */
799
800     /* draw textured quad */
801     immUniform1i("image", 0);
802
803     immBegin(GPU_PRIM_TRI_FAN, 4);
804     immAttr2f(texCoord, 0.0f, 0.0f);
805     immVertex2f(pos, quad.xmin, quad.ymin);
806     immAttr2f(texCoord, 1.0f, 0.0f);
807     immVertex2f(pos, quad.xmax, quad.ymin);
808     immAttr2f(texCoord, 1.0f, 1.0f);
809     immVertex2f(pos, quad.xmax, quad.ymax);
810     immAttr2f(texCoord, 0.0f, 1.0f);
811     immVertex2f(pos, quad.xmin, quad.ymax);
812     immEnd();
813
814     immUnbindProgram();
815
816     GPU_blend_set_func(GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA);
817
818     if (do_pop) {
819       GPU_matrix_pop();
820     }
821   }
822   return true;
823 }
824
825 static bool paint_draw_alpha_overlay(UnifiedPaintSettings *ups,
826                                      Brush *brush,
827                                      ViewContext *vc,
828                                      int x,
829                                      int y,
830                                      float zoom,
831                                      ePaintMode mode)
832 {
833   /* Color means that primary brush texture is colored and
834    * secondary is used for alpha/mask control. */
835   bool col = ELEM(mode, PAINT_MODE_TEXTURE_3D, PAINT_MODE_TEXTURE_2D, PAINT_MODE_VERTEX);
836
837   bool alpha_overlay_active = false;
838
839   ePaintOverlayControlFlags flags = BKE_paint_get_overlay_flags();
840   gpuPushAttr(GPU_DEPTH_BUFFER_BIT | GPU_BLEND_BIT);
841
842   /* Translate to region. */
843   GPU_matrix_push();
844   GPU_matrix_translate_2f(vc->ar->winrct.xmin, vc->ar->winrct.ymin);
845   x -= vc->ar->winrct.xmin;
846   y -= vc->ar->winrct.ymin;
847
848   /* Colored overlay should be drawn separately. */
849   if (col) {
850     if (!(flags & PAINT_OVERLAY_OVERRIDE_PRIMARY)) {
851       alpha_overlay_active = paint_draw_tex_overlay(ups, brush, vc, x, y, zoom, true, true);
852     }
853     if (!(flags & PAINT_OVERLAY_OVERRIDE_SECONDARY)) {
854       alpha_overlay_active = paint_draw_tex_overlay(ups, brush, vc, x, y, zoom, false, false);
855     }
856     if (!(flags & PAINT_OVERLAY_OVERRIDE_CURSOR)) {
857       alpha_overlay_active = paint_draw_cursor_overlay(ups, brush, vc, x, y, zoom);
858     }
859   }
860   else {
861     if (!(flags & PAINT_OVERLAY_OVERRIDE_PRIMARY) && (mode != PAINT_MODE_WEIGHT)) {
862       alpha_overlay_active = paint_draw_tex_overlay(ups, brush, vc, x, y, zoom, false, true);
863     }
864     if (!(flags & PAINT_OVERLAY_OVERRIDE_CURSOR)) {
865       alpha_overlay_active = paint_draw_cursor_overlay(ups, brush, vc, x, y, zoom);
866     }
867   }
868
869   GPU_matrix_pop();
870   gpuPopAttr();
871
872   return alpha_overlay_active;
873 }
874
875 BLI_INLINE void draw_tri_point(unsigned int pos,
876                                const float sel_col[4],
877                                float pivot_col[4],
878                                float *co,
879                                float width,
880                                bool selected)
881 {
882   immUniformColor4fv(selected ? sel_col : pivot_col);
883
884   GPU_line_width(3.0f);
885
886   float w = width / 2.0f;
887   const float tri[3][2] = {
888       {co[0], co[1] + w},
889       {co[0] - w, co[1] - w},
890       {co[0] + w, co[1] - w},
891   };
892
893   immBegin(GPU_PRIM_LINE_LOOP, 3);
894   immVertex2fv(pos, tri[0]);
895   immVertex2fv(pos, tri[1]);
896   immVertex2fv(pos, tri[2]);
897   immEnd();
898
899   immUniformColor4f(1.0f, 1.0f, 1.0f, 0.5f);
900   GPU_line_width(1.0f);
901
902   immBegin(GPU_PRIM_LINE_LOOP, 3);
903   immVertex2fv(pos, tri[0]);
904   immVertex2fv(pos, tri[1]);
905   immVertex2fv(pos, tri[2]);
906   immEnd();
907 }
908
909 BLI_INLINE void draw_rect_point(unsigned int pos,
910                                 const float sel_col[4],
911                                 float handle_col[4],
912                                 float *co,
913                                 float width,
914                                 bool selected)
915 {
916   immUniformColor4fv(selected ? sel_col : handle_col);
917
918   GPU_line_width(3.0f);
919
920   float w = width / 2.0f;
921   float minx = co[0] - w;
922   float miny = co[1] - w;
923   float maxx = co[0] + w;
924   float maxy = co[1] + w;
925
926   imm_draw_box_wire_2d(pos, minx, miny, maxx, maxy);
927
928   immUniformColor4f(1.0f, 1.0f, 1.0f, 0.5f);
929   GPU_line_width(1.0f);
930
931   imm_draw_box_wire_2d(pos, minx, miny, maxx, maxy);
932 }
933
934 BLI_INLINE void draw_bezier_handle_lines(unsigned int pos, float sel_col[4], BezTriple *bez)
935 {
936   immUniformColor4f(0.0f, 0.0f, 0.0f, 0.5f);
937   GPU_line_width(3.0f);
938
939   immBegin(GPU_PRIM_LINE_STRIP, 3);
940   immVertex2fv(pos, bez->vec[0]);
941   immVertex2fv(pos, bez->vec[1]);
942   immVertex2fv(pos, bez->vec[2]);
943   immEnd();
944
945   GPU_line_width(1.0f);
946
947   if (bez->f1 || bez->f2) {
948     immUniformColor4fv(sel_col);
949   }
950   else {
951     immUniformColor4f(1.0f, 1.0f, 1.0f, 0.5f);
952   }
953   immBegin(GPU_PRIM_LINES, 2);
954   immVertex2fv(pos, bez->vec[0]);
955   immVertex2fv(pos, bez->vec[1]);
956   immEnd();
957
958   if (bez->f3 || bez->f2) {
959     immUniformColor4fv(sel_col);
960   }
961   else {
962     immUniformColor4f(1.0f, 1.0f, 1.0f, 0.5f);
963   }
964   immBegin(GPU_PRIM_LINES, 2);
965   immVertex2fv(pos, bez->vec[1]);
966   immVertex2fv(pos, bez->vec[2]);
967   immEnd();
968 }
969
970 static void paint_draw_curve_cursor(Brush *brush, ViewContext *vc)
971 {
972   GPU_matrix_push();
973   GPU_matrix_translate_2f(vc->ar->winrct.xmin, vc->ar->winrct.ymin);
974
975   if (brush->paint_curve && brush->paint_curve->points) {
976     int i;
977     PaintCurve *pc = brush->paint_curve;
978     PaintCurvePoint *cp = pc->points;
979
980     GPU_line_smooth(true);
981     GPU_blend(true);
982
983     /* draw the bezier handles and the curve segment between the current and next point */
984     uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
985
986     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
987
988     float selec_col[4], handle_col[4], pivot_col[4];
989     UI_GetThemeColorType4fv(TH_VERTEX_SELECT, SPACE_VIEW3D, selec_col);
990     UI_GetThemeColorType4fv(TH_PAINT_CURVE_HANDLE, SPACE_VIEW3D, handle_col);
991     UI_GetThemeColorType4fv(TH_PAINT_CURVE_PIVOT, SPACE_VIEW3D, pivot_col);
992
993     for (i = 0; i < pc->tot_points - 1; i++, cp++) {
994       int j;
995       PaintCurvePoint *cp_next = cp + 1;
996       float data[(PAINT_CURVE_NUM_SEGMENTS + 1) * 2];
997       /* use color coding to distinguish handles vs curve segments  */
998       draw_bezier_handle_lines(pos, selec_col, &cp->bez);
999       draw_tri_point(pos, selec_col, pivot_col, &cp->bez.vec[1][0], 10.0f, cp->bez.f2);
1000       draw_rect_point(
1001           pos, selec_col, handle_col, &cp->bez.vec[0][0], 8.0f, cp->bez.f1 || cp->bez.f2);
1002       draw_rect_point(
1003           pos, selec_col, handle_col, &cp->bez.vec[2][0], 8.0f, cp->bez.f3 || cp->bez.f2);
1004
1005       for (j = 0; j < 2; j++) {
1006         BKE_curve_forward_diff_bezier(cp->bez.vec[1][j],
1007                                       cp->bez.vec[2][j],
1008                                       cp_next->bez.vec[0][j],
1009                                       cp_next->bez.vec[1][j],
1010                                       data + j,
1011                                       PAINT_CURVE_NUM_SEGMENTS,
1012                                       sizeof(float[2]));
1013       }
1014
1015       float(*v)[2] = (float(*)[2])data;
1016
1017       immUniformColor4f(0.0f, 0.0f, 0.0f, 0.5f);
1018       GPU_line_width(3.0f);
1019       immBegin(GPU_PRIM_LINE_STRIP, PAINT_CURVE_NUM_SEGMENTS + 1);
1020       for (j = 0; j <= PAINT_CURVE_NUM_SEGMENTS; j++) {
1021         immVertex2fv(pos, v[j]);
1022       }
1023       immEnd();
1024
1025       immUniformColor4f(0.9f, 0.9f, 1.0f, 0.5f);
1026       GPU_line_width(1.0f);
1027       immBegin(GPU_PRIM_LINE_STRIP, PAINT_CURVE_NUM_SEGMENTS + 1);
1028       for (j = 0; j <= PAINT_CURVE_NUM_SEGMENTS; j++) {
1029         immVertex2fv(pos, v[j]);
1030       }
1031       immEnd();
1032     }
1033
1034     /* draw last line segment */
1035     draw_bezier_handle_lines(pos, selec_col, &cp->bez);
1036     draw_tri_point(pos, selec_col, pivot_col, &cp->bez.vec[1][0], 10.0f, cp->bez.f2);
1037     draw_rect_point(
1038         pos, selec_col, handle_col, &cp->bez.vec[0][0], 8.0f, cp->bez.f1 || cp->bez.f2);
1039     draw_rect_point(
1040         pos, selec_col, handle_col, &cp->bez.vec[2][0], 8.0f, cp->bez.f3 || cp->bez.f2);
1041
1042     GPU_blend(false);
1043     GPU_line_smooth(false);
1044
1045     immUnbindProgram();
1046   }
1047   GPU_matrix_pop();
1048 }
1049
1050 /* Special actions taken when paint cursor goes over mesh */
1051 /* TODO: sculpt only for now */
1052 static void paint_cursor_on_hit(UnifiedPaintSettings *ups,
1053                                 Brush *brush,
1054                                 ViewContext *vc,
1055                                 const float location[3])
1056 {
1057   float unprojected_radius, projected_radius;
1058
1059   /* update the brush's cached 3D radius */
1060   if (!BKE_brush_use_locked_size(vc->scene, brush)) {
1061     /* get 2D brush radius */
1062     if (ups->draw_anchored) {
1063       projected_radius = ups->anchored_size;
1064     }
1065     else {
1066       if (brush->flag & BRUSH_ANCHORED) {
1067         projected_radius = 8;
1068       }
1069       else {
1070         projected_radius = BKE_brush_size_get(vc->scene, brush);
1071       }
1072     }
1073
1074     /* convert brush radius from 2D to 3D */
1075     unprojected_radius = paint_calc_object_space_radius(vc, location, projected_radius);
1076
1077     /* scale 3D brush radius by pressure */
1078     if (ups->stroke_active && BKE_brush_use_size_pressure(brush)) {
1079       unprojected_radius *= ups->size_pressure_value;
1080     }
1081
1082     /* set cached value in either Brush or UnifiedPaintSettings */
1083     BKE_brush_unprojected_radius_set(vc->scene, brush, unprojected_radius);
1084   }
1085 }
1086
1087 static bool ommit_cursor_drawing(Paint *paint, ePaintMode mode, Brush *brush)
1088 {
1089   if (paint->flags & PAINT_SHOW_BRUSH) {
1090     if (ELEM(mode, PAINT_MODE_TEXTURE_2D, PAINT_MODE_TEXTURE_3D) &&
1091         brush->imagepaint_tool == PAINT_TOOL_FILL) {
1092       return true;
1093     }
1094     return false;
1095   }
1096   return true;
1097 }
1098
1099 static void cursor_draw_point_screen_space(
1100     const uint gpuattr, const ARegion *ar, float true_location[3], float obmat[4][4], int size)
1101 {
1102   float translation_vertex_cursor[3], location[3];
1103   copy_v3_v3(location, true_location);
1104   mul_m4_v3(obmat, location);
1105   ED_view3d_project(ar, location, translation_vertex_cursor);
1106   imm_draw_circle_fill_3d(
1107       gpuattr, translation_vertex_cursor[0], translation_vertex_cursor[1], size, 10);
1108 }
1109
1110 static void cursor_draw_tiling_preview(const uint gpuattr,
1111                                        const ARegion *ar,
1112                                        const float true_location[3],
1113                                        Sculpt *sd,
1114                                        Object *ob,
1115                                        float radius)
1116 {
1117   BoundBox *bb = BKE_object_boundbox_get(ob);
1118   float orgLoc[3], location[3];
1119   int dim, tile_pass = 0;
1120   int start[3];
1121   int end[3];
1122   int cur[3];
1123   const float *bbMin = bb->vec[0];
1124   const float *bbMax = bb->vec[6];
1125   const float *step = sd->paint.tile_offset;
1126
1127   copy_v3_v3(orgLoc, true_location);
1128   for (dim = 0; dim < 3; dim++) {
1129     if ((sd->paint.symmetry_flags & (PAINT_TILE_X << dim)) && step[dim] > 0) {
1130       start[dim] = (bbMin[dim] - orgLoc[dim] - radius) / step[dim];
1131       end[dim] = (bbMax[dim] - orgLoc[dim] + radius) / step[dim];
1132     }
1133     else {
1134       start[dim] = end[dim] = 0;
1135     }
1136   }
1137   copy_v3_v3_int(cur, start);
1138   for (cur[0] = start[0]; cur[0] <= end[0]; cur[0]++) {
1139     for (cur[1] = start[1]; cur[1] <= end[1]; cur[1]++) {
1140       for (cur[2] = start[2]; cur[2] <= end[2]; cur[2]++) {
1141         if (!cur[0] && !cur[1] && !cur[2]) {
1142           /* skip tile at orgLoc, this was already handled before all others */
1143           continue;
1144         }
1145         tile_pass++;
1146         for (dim = 0; dim < 3; dim++) {
1147           location[dim] = cur[dim] * step[dim] + orgLoc[dim];
1148         }
1149         cursor_draw_point_screen_space(gpuattr, ar, location, ob->obmat, 3);
1150       }
1151     }
1152   }
1153 }
1154
1155 static void cursor_draw_point_with_symmetry(const uint gpuattr,
1156                                             const ARegion *ar,
1157                                             const float true_location[3],
1158                                             Sculpt *sd,
1159                                             Object *ob,
1160                                             float radius)
1161 {
1162   const char symm = sd->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
1163   float location[3], symm_rot_mat[4][4];
1164
1165   for (int i = 0; i <= symm; i++) {
1166     if (i == 0 || (symm & i && (symm != 5 || i != 3) && (symm != 6 || (i != 3 && i != 5)))) {
1167
1168       /* Axis Symmetry */
1169       flip_v3_v3(location, true_location, (char)i);
1170       cursor_draw_point_screen_space(gpuattr, ar, location, ob->obmat, 3);
1171
1172       /* Tiling */
1173       cursor_draw_tiling_preview(gpuattr, ar, location, sd, ob, radius);
1174
1175       /* Radial Symmetry */
1176       for (char raxis = 0; raxis < 3; raxis++) {
1177         for (int r = 1; r < sd->radial_symm[raxis]; r++) {
1178           float angle = 2 * M_PI * r / sd->radial_symm[(int)raxis];
1179           flip_v3_v3(location, true_location, (char)i);
1180           unit_m4(symm_rot_mat);
1181           rotate_m4(symm_rot_mat, raxis + 'X', angle);
1182           mul_m4_v3(symm_rot_mat, location);
1183
1184           cursor_draw_tiling_preview(gpuattr, ar, location, sd, ob, radius);
1185           cursor_draw_point_screen_space(gpuattr, ar, location, ob->obmat, 3);
1186         }
1187       }
1188     }
1189   }
1190 }
1191
1192 static void sculpt_geometry_preview_lines_draw(const uint gpuattr, SculptSession *ss)
1193 {
1194   immUniformColor4f(1.0f, 1.0f, 1.0f, 0.6f);
1195
1196   /* Cursor normally draws on top, but for this part we need depth tests. */
1197   const bool depth_test = GPU_depth_test_enabled();
1198   if (!depth_test) {
1199     GPU_depth_test(true);
1200   }
1201
1202   GPU_line_width(1.0f);
1203   if (ss->preview_vert_index_count > 0) {
1204     immBegin(GPU_PRIM_LINES, ss->preview_vert_index_count);
1205     for (int i = 0; i < ss->preview_vert_index_count; i++) {
1206       immVertex3fv(gpuattr, sculpt_vertex_co_get(ss, ss->preview_vert_index_list[i]));
1207     }
1208     immEnd();
1209   }
1210
1211   /* Restore depth test value. */
1212   if (!depth_test) {
1213     GPU_depth_test(false);
1214   }
1215 }
1216
1217 static void sculpt_multiplane_scrape_preview_draw(const uint gpuattr,
1218                                                   SculptSession *ss,
1219                                                   const float outline_col[3],
1220                                                   float outline_alpha)
1221 {
1222   float local_mat_inv[4][4];
1223   invert_m4_m4(local_mat_inv, ss->cache->stroke_local_mat);
1224   GPU_matrix_mul(local_mat_inv);
1225   float angle = ss->cache->multiplane_scrape_sampled_angle;
1226   if (ss->cache->pen_flip || ss->cache->invert) {
1227     angle = -angle;
1228   }
1229
1230   float offset = ss->cache->radius * 0.25f;
1231
1232   float p[3] = {0.0f, 0.0f, ss->cache->radius};
1233   float y_axis[3] = {0.0f, 1.0f, 0.0f};
1234   float p_l[3];
1235   float p_r[3];
1236   float area_center[3] = {0.0f, 0.0f, 0.0f};
1237   rotate_v3_v3v3fl(p_r, p, y_axis, DEG2RADF((angle + 180) * 0.5f));
1238   rotate_v3_v3v3fl(p_l, p, y_axis, DEG2RADF(-(angle + 180) * 0.5f));
1239
1240   immBegin(GPU_PRIM_LINES, 14);
1241   immVertex3f(gpuattr, area_center[0], area_center[1] + offset, area_center[2]);
1242   immVertex3f(gpuattr, p_r[0], p_r[1] + offset, p_r[2]);
1243   immVertex3f(gpuattr, area_center[0], area_center[1] + offset, area_center[2]);
1244   immVertex3f(gpuattr, p_l[0], p_l[1] + offset, p_l[2]);
1245
1246   immVertex3f(gpuattr, area_center[0], area_center[1] - offset, area_center[2]);
1247   immVertex3f(gpuattr, p_r[0], p_r[1] - offset, p_r[2]);
1248   immVertex3f(gpuattr, area_center[0], area_center[1] - offset, area_center[2]);
1249   immVertex3f(gpuattr, p_l[0], p_l[1] - offset, p_l[2]);
1250
1251   immVertex3f(gpuattr, area_center[0], area_center[1] - offset, area_center[2]);
1252   immVertex3f(gpuattr, area_center[0], area_center[1] + offset, area_center[2]);
1253
1254   immVertex3f(gpuattr, p_r[0], p_r[1] - offset, p_r[2]);
1255   immVertex3f(gpuattr, p_r[0], p_r[1] + offset, p_r[2]);
1256
1257   immVertex3f(gpuattr, p_l[0], p_l[1] - offset, p_l[2]);
1258   immVertex3f(gpuattr, p_l[0], p_l[1] + offset, p_l[2]);
1259
1260   immEnd();
1261
1262   immUniformColor3fvAlpha(outline_col, outline_alpha * 0.1f);
1263   immBegin(GPU_PRIM_TRIS, 12);
1264   immVertex3f(gpuattr, area_center[0], area_center[1] + offset, area_center[2]);
1265   immVertex3f(gpuattr, p_r[0], p_r[1] + offset, p_r[2]);
1266   immVertex3f(gpuattr, p_r[0], p_r[1] - offset, p_r[2]);
1267   immVertex3f(gpuattr, area_center[0], area_center[1] + offset, area_center[2]);
1268   immVertex3f(gpuattr, area_center[0], area_center[1] - offset, area_center[2]);
1269   immVertex3f(gpuattr, p_r[0], p_r[1] - offset, p_r[2]);
1270
1271   immVertex3f(gpuattr, area_center[0], area_center[1] + offset, area_center[2]);
1272   immVertex3f(gpuattr, p_l[0], p_l[1] + offset, p_l[2]);
1273   immVertex3f(gpuattr, p_l[0], p_l[1] - offset, p_l[2]);
1274   immVertex3f(gpuattr, area_center[0], area_center[1] + offset, area_center[2]);
1275   immVertex3f(gpuattr, area_center[0], area_center[1] - offset, area_center[2]);
1276   immVertex3f(gpuattr, p_l[0], p_l[1] - offset, p_l[2]);
1277
1278   immEnd();
1279 }
1280
1281 static bool paint_use_2d_cursor(ePaintMode mode)
1282 {
1283   if (mode >= PAINT_MODE_TEXTURE_3D) {
1284     return true;
1285   }
1286   return false;
1287 }
1288
1289 static void paint_draw_cursor(bContext *C, int x, int y, void *UNUSED(unused))
1290 {
1291   ARegion *ar = CTX_wm_region(C);
1292   if (ar && ar->regiontype != RGN_TYPE_WINDOW) {
1293     return;
1294   }
1295
1296   Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
1297   Scene *scene = CTX_data_scene(C);
1298   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
1299   Paint *paint = BKE_paint_get_active_from_context(C);
1300   Brush *brush = BKE_paint_brush(paint);
1301   ePaintMode mode = BKE_paintmode_get_active_from_context(C);
1302
1303   /* 2d or 3d painting? */
1304   const bool use_2d_cursor = paint_use_2d_cursor(mode);
1305
1306   /* check that brush drawing is enabled */
1307   if (ommit_cursor_drawing(paint, mode, brush)) {
1308     return;
1309   }
1310
1311   /* can't use stroke vc here because this will be called during
1312    * mouse over too, not just during a stroke */
1313   ViewContext vc;
1314   ED_view3d_viewcontext_init(C, &vc, depsgraph);
1315
1316   if (vc.rv3d && (vc.rv3d->rflag & RV3D_NAVIGATING)) {
1317     return;
1318   }
1319
1320   /* skip everything and draw brush here */
1321   if (brush->flag & BRUSH_CURVE) {
1322     paint_draw_curve_cursor(brush, &vc);
1323     return;
1324   }
1325
1326   float zoomx, zoomy;
1327   get_imapaint_zoom(C, &zoomx, &zoomy);
1328   zoomx = max_ff(zoomx, zoomy);
1329
1330   /* set various defaults */
1331   const float *outline_col = brush->add_col;
1332   const float outline_alpha = brush->add_col[3];
1333   float translation[2] = {x, y};
1334   float final_radius = (BKE_brush_size_get(scene, brush) * zoomx);
1335
1336   /* don't calculate rake angles while a stroke is active because the rake variables are global
1337    * and we may get interference with the stroke itself.
1338    * For line strokes, such interference is visible */
1339   if (!ups->stroke_active) {
1340     paint_calculate_rake_rotation(ups, brush, translation);
1341   }
1342
1343   /* draw overlay */
1344   bool alpha_overlay_active = paint_draw_alpha_overlay(ups, brush, &vc, x, y, zoomx, mode);
1345
1346   if (ups->draw_anchored) {
1347     final_radius = ups->anchored_size;
1348     copy_v2_fl2(translation,
1349                 ups->anchored_initial_mouse[0] + ar->winrct.xmin,
1350                 ups->anchored_initial_mouse[1] + ar->winrct.ymin);
1351   }
1352
1353   /* make lines pretty */
1354   GPU_line_width(2.0f);
1355   GPU_blend(true); /* TODO: also set blend mode? */
1356   GPU_line_smooth(true);
1357
1358   if (use_2d_cursor) {
1359     uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1360     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1361
1362     immUniformColor3fvAlpha(outline_col, outline_alpha);
1363
1364     /* draw brush outline */
1365     if (ups->stroke_active && BKE_brush_use_size_pressure(brush)) {
1366       imm_draw_circle_wire_2d(
1367           pos, translation[0], translation[1], final_radius * ups->size_pressure_value, 40);
1368       /* outer at half alpha */
1369       immUniformColor3fvAlpha(outline_col, outline_alpha * 0.5f);
1370     }
1371
1372     GPU_line_width(1.0f);
1373     imm_draw_circle_wire_2d(pos, translation[0], translation[1], final_radius, 40);
1374   }
1375   else { /* 3d painting */
1376     uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
1377     immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
1378
1379     /* TODO: as sculpt and other paint modes are unified, this
1380      * special mode of drawing will go away */
1381     Object *obact = vc.obact;
1382     SculptSession *ss = obact ? obact->sculpt : NULL;
1383     if ((mode == PAINT_MODE_SCULPT) && ss) {
1384       float location[3];
1385       int pixel_radius;
1386
1387       /* test if brush is over the mesh */
1388       bool hit = sculpt_get_brush_geometry(C, &vc, x, y, &pixel_radius, location, ups);
1389
1390       if (BKE_brush_use_locked_size(scene, brush)) {
1391         BKE_brush_size_set(scene, brush, pixel_radius);
1392       }
1393
1394       /* check if brush is subtracting, use different color then */
1395       /* TODO: no way currently to know state of pen flip or
1396        * invert key modifier without starting a stroke */
1397       if (((ups->draw_inverted == 0) ^ ((brush->flag & BRUSH_DIR_IN) == 0)) &&
1398           BKE_brush_sculpt_has_secondary_color(brush)) {
1399         outline_col = brush->sub_col;
1400       }
1401
1402       /* only do if brush is over the mesh */
1403       if (hit) {
1404         paint_cursor_on_hit(ups, brush, &vc, location);
1405       }
1406     }
1407
1408     immUniformColor3fvAlpha(outline_col, outline_alpha);
1409
1410     if (ups->stroke_active && BKE_brush_use_size_pressure(brush) && mode != PAINT_MODE_SCULPT) {
1411       imm_draw_circle_wire_3d(
1412           pos, translation[0], translation[1], final_radius * ups->size_pressure_value, 40);
1413       /* outer at half alpha */
1414       immUniformColor3fvAlpha(outline_col, outline_alpha * 0.5f);
1415     }
1416
1417     /* Only sculpt mode cursor for now */
1418     /* Disable for PBVH_GRIDS */
1419     bool is_multires = ss && ss->pbvh && BKE_pbvh_type(ss->pbvh) == PBVH_GRIDS;
1420
1421     SculptCursorGeometryInfo gi;
1422     float mouse[2] = {x - ar->winrct.xmin, y - ar->winrct.ymin};
1423     int prev_active_vertex_index = -1;
1424     bool is_cursor_over_mesh = false;
1425
1426     /* Update the active vertex */
1427     if ((mode == PAINT_MODE_SCULPT) && ss && !ups->stroke_active) {
1428       prev_active_vertex_index = ss->active_vertex_index;
1429       is_cursor_over_mesh = sculpt_cursor_geometry_info_update(
1430           C, &gi, mouse, (brush->falloff_shape == PAINT_FALLOFF_SHAPE_SPHERE));
1431     }
1432     /* Use special paint crosshair cursor in all paint modes*/
1433     wmWindow *win = CTX_wm_window(C);
1434     WM_cursor_set(win, WM_CURSOR_PAINT);
1435
1436     if ((mode == PAINT_MODE_SCULPT) && ss &&
1437         (brush->falloff_shape == PAINT_FALLOFF_SHAPE_SPHERE)) {
1438       Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
1439
1440       if (!ups->stroke_active) {
1441         bool update_previews = false;
1442         if (is_cursor_over_mesh && !alpha_overlay_active) {
1443
1444           if (prev_active_vertex_index != ss->active_vertex_index) {
1445             update_previews = true;
1446           }
1447
1448           float rds;
1449           if (!BKE_brush_use_locked_size(scene, brush)) {
1450             rds = paint_calc_object_space_radius(
1451                 &vc, gi.location, BKE_brush_size_get(scene, brush));
1452           }
1453           else {
1454             rds = BKE_brush_unprojected_radius_get(scene, brush);
1455           }
1456
1457           wmViewport(&ar->winrct);
1458
1459           /* Draw 3D active vertex preview with symmetry*/
1460           if (len_v3v3(gi.active_vertex_co, gi.location) < rds) {
1461             cursor_draw_point_with_symmetry(pos, ar, gi.active_vertex_co, sd, vc.obact, rds);
1462           }
1463
1464           /* Draw pose brush origins. */
1465           if (brush->sculpt_tool == SCULPT_TOOL_POSE) {
1466             immUniformColor4f(1.0f, 1.0f, 1.0f, 0.8f);
1467             if (update_previews) {
1468               BKE_sculpt_update_object_for_edit(depsgraph, vc.obact, true, false);
1469
1470               /* Free the previous pose brush preview. */
1471               if (ss->pose_ik_chain_preview) {
1472                 sculpt_pose_ik_chain_free(ss->pose_ik_chain_preview);
1473               }
1474
1475               /* Generate a new pose brush preview from the current cursor location. */
1476               ss->pose_ik_chain_preview = sculpt_pose_ik_chain_init(
1477                   sd, vc.obact, ss, brush, gi.location, rds);
1478             }
1479
1480             /* Draw the pose brush rotation origins. */
1481             for (int i = 0; i < ss->pose_ik_chain_preview->tot_segments; i++) {
1482               cursor_draw_point_screen_space(pos,
1483                                              ar,
1484                                              ss->pose_ik_chain_preview->segments[i].initial_orig,
1485                                              vc.obact->obmat,
1486                                              3);
1487             }
1488           }
1489
1490           /* Draw 3D brush cursor */
1491           GPU_matrix_push_projection();
1492           ED_view3d_draw_setup_view(CTX_wm_window(C),
1493                                     CTX_data_depsgraph_pointer(C),
1494                                     CTX_data_scene(C),
1495                                     ar,
1496                                     CTX_wm_view3d(C),
1497                                     NULL,
1498                                     NULL,
1499                                     NULL);
1500
1501           float cursor_trans[4][4], cursor_rot[4][4];
1502           float z_axis[4] = {0.0f, 0.0f, 1.0f, 0.0f};
1503           float quat[4];
1504
1505           copy_m4_m4(cursor_trans, vc.obact->obmat);
1506           translate_m4(cursor_trans, gi.location[0], gi.location[1], gi.location[2]);
1507           rotation_between_vecs_to_quat(quat, z_axis, gi.normal);
1508           quat_to_mat4(cursor_rot, quat);
1509
1510           GPU_matrix_push();
1511           GPU_matrix_mul(cursor_trans);
1512           GPU_matrix_mul(cursor_rot);
1513           immUniformColor3fvAlpha(outline_col, outline_alpha);
1514           GPU_line_width(2.0f);
1515           imm_draw_circle_wire_3d(pos, 0, 0, rds, 80);
1516           GPU_line_width(1.0f);
1517           immUniformColor3fvAlpha(outline_col, outline_alpha * 0.5f);
1518           imm_draw_circle_wire_3d(pos, 0, 0, rds * clamp_f(brush->alpha, 0.0f, 1.0f), 80);
1519           GPU_matrix_pop();
1520
1521           /* Update and draw dynamic mesh preview lines */
1522           GPU_matrix_push();
1523           GPU_matrix_mul(vc.obact->obmat);
1524           if (brush->sculpt_tool == SCULPT_TOOL_GRAB && (brush->flag & BRUSH_GRAB_ACTIVE_VERTEX) &&
1525               !is_multires) {
1526             if (BKE_pbvh_type(ss->pbvh) == PBVH_FACES && ss->deform_modifiers_active) {
1527               sculpt_geometry_preview_lines_update(C, ss, rds);
1528               sculpt_geometry_preview_lines_draw(pos, ss);
1529             }
1530           }
1531
1532           /* Draw pose brush line preview */
1533           if (brush->sculpt_tool == SCULPT_TOOL_POSE) {
1534             immUniformColor4f(1.0f, 1.0f, 1.0f, 0.8f);
1535             GPU_line_width(2.0f);
1536
1537             immBegin(GPU_PRIM_LINES, ss->pose_ik_chain_preview->tot_segments * 2);
1538             for (int i = 0; i < ss->pose_ik_chain_preview->tot_segments; i++) {
1539               immVertex3fv(pos, ss->pose_ik_chain_preview->segments[i].initial_orig);
1540               immVertex3fv(pos, ss->pose_ik_chain_preview->segments[i].initial_head);
1541             }
1542
1543             immEnd();
1544           }
1545
1546           GPU_matrix_pop();
1547
1548           GPU_matrix_pop_projection();
1549
1550           wmWindowViewport(win);
1551         }
1552         else {
1553           /* Draw default cursor when the mouse is not over the mesh or there are no supported
1554            * overlays active */
1555           GPU_line_width(1.0f);
1556           /* Reduce alpha to increase the contrast when the cursor is over the mesh */
1557           immUniformColor3fvAlpha(outline_col, outline_alpha * 0.8);
1558           imm_draw_circle_wire_3d(pos, translation[0], translation[1], final_radius, 80);
1559           immUniformColor3fvAlpha(outline_col, outline_alpha * 0.35f);
1560           imm_draw_circle_wire_3d(pos,
1561                                   translation[0],
1562                                   translation[1],
1563                                   final_radius * clamp_f(brush->alpha, 0.0f, 1.0f),
1564                                   80);
1565         }
1566       }
1567       else {
1568         if (vc.obact->sculpt->cache && !vc.obact->sculpt->cache->first_time) {
1569           wmViewport(&ar->winrct);
1570
1571           /* Draw cached dynamic mesh preview lines */
1572           if (brush->sculpt_tool == SCULPT_TOOL_GRAB && (brush->flag & BRUSH_GRAB_ACTIVE_VERTEX) &&
1573               !is_multires) {
1574             if (BKE_pbvh_type(ss->pbvh) == PBVH_FACES && ss->deform_modifiers_active) {
1575               GPU_matrix_push_projection();
1576               ED_view3d_draw_setup_view(CTX_wm_window(C),
1577                                         CTX_data_depsgraph_pointer(C),
1578                                         CTX_data_scene(C),
1579                                         ar,
1580                                         CTX_wm_view3d(C),
1581                                         NULL,
1582                                         NULL,
1583                                         NULL);
1584               GPU_matrix_push();
1585               GPU_matrix_mul(vc.obact->obmat);
1586               sculpt_geometry_preview_lines_draw(pos, ss);
1587               GPU_matrix_pop();
1588               GPU_matrix_pop_projection();
1589             }
1590           }
1591
1592           if (brush->sculpt_tool == SCULPT_TOOL_MULTIPLANE_SCRAPE &&
1593               brush->flag2 & BRUSH_MULTIPLANE_SCRAPE_PLANES_PREVIEW && !ss->cache->first_time) {
1594             GPU_matrix_push_projection();
1595             ED_view3d_draw_setup_view(CTX_wm_window(C),
1596                                       CTX_data_depsgraph_pointer(C),
1597                                       CTX_data_scene(C),
1598                                       ar,
1599                                       CTX_wm_view3d(C),
1600                                       NULL,
1601                                       NULL,
1602                                       NULL);
1603             GPU_matrix_push();
1604             GPU_matrix_mul(vc.obact->obmat);
1605             sculpt_multiplane_scrape_preview_draw(pos, ss, outline_col, outline_alpha);
1606             GPU_matrix_pop();
1607             GPU_matrix_pop_projection();
1608           }
1609
1610           wmWindowViewport(win);
1611         }
1612       }
1613     }
1614     else {
1615       /* Draw default cursor in unsupported modes */
1616       GPU_line_width(1.0f);
1617       imm_draw_circle_wire_3d(pos, translation[0], translation[1], final_radius, 40);
1618     }
1619   }
1620
1621   immUnbindProgram();
1622
1623   /* restore GL state */
1624   GPU_blend(false);
1625   GPU_line_smooth(false);
1626 }
1627
1628 /* Public API */
1629
1630 void paint_cursor_start(bContext *C, bool (*poll)(bContext *C))
1631 {
1632   Paint *p = BKE_paint_get_active_from_context(C);
1633
1634   if (p && !p->paint_cursor) {
1635     p->paint_cursor = WM_paint_cursor_activate(
1636         CTX_wm_manager(C), SPACE_TYPE_ANY, RGN_TYPE_ANY, poll, paint_draw_cursor, NULL);
1637   }
1638
1639   /* invalidate the paint cursors */
1640   BKE_paint_invalidate_overlay_all();
1641 }
1642
1643 void paint_cursor_start_explicit(Paint *p, wmWindowManager *wm, bool (*poll)(bContext *C))
1644 {
1645   if (p && !p->paint_cursor) {
1646     p->paint_cursor = WM_paint_cursor_activate(
1647         wm, SPACE_TYPE_ANY, RGN_TYPE_ANY, poll, paint_draw_cursor, NULL);
1648   }
1649 }