Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / gpencil / drawgpencil.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) 2008, Blender Foundation
17  * This is a new part of Blender
18  */
19
20 /** \file
21  * \ingroup edgpencil
22  */
23
24 #include <stdio.h>
25 #include <string.h>
26 #include <stdlib.h>
27 #include <stddef.h>
28 #include <math.h>
29 #include <float.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "BLI_sys_types.h"
34
35 #include "BLI_math.h"
36 #include "BLI_utildefines.h"
37 #include "BLI_polyfill_2d.h"
38
39 #include "BLF_api.h"
40 #include "BLT_translation.h"
41
42 #include "DNA_brush_types.h"
43 #include "DNA_gpencil_types.h"
44 #include "DNA_scene_types.h"
45 #include "DNA_screen_types.h"
46 #include "DNA_space_types.h"
47 #include "DNA_view3d_types.h"
48 #include "DNA_userdef_types.h"
49 #include "DNA_object_types.h"
50
51 #include "BKE_context.h"
52 #include "BKE_brush.h"
53 #include "BKE_global.h"
54 #include "BKE_paint.h"
55 #include "BKE_gpencil.h"
56 #include "BKE_image.h"
57
58 #include "DEG_depsgraph.h"
59
60 #include "WM_api.h"
61
62 #include "BIF_glutil.h"
63
64 #include "GPU_immediate.h"
65 #include "GPU_draw.h"
66 #include "GPU_state.h"
67
68 #include "ED_gpencil.h"
69 #include "ED_screen.h"
70 #include "ED_view3d.h"
71 #include "ED_space_api.h"
72
73 #include "UI_interface_icons.h"
74 #include "UI_resources.h"
75
76 #include "IMB_imbuf_types.h"
77
78 #include "gpencil_intern.h"
79
80 /* ************************************************** */
81 /* GREASE PENCIL DRAWING */
82
83 /* ----- General Defines ------ */
84 /* flags for sflag */
85 typedef enum eDrawStrokeFlags {
86   /** don't draw status info */
87   GP_DRAWDATA_NOSTATUS = (1 << 0),
88   /** only draw 3d-strokes */
89   GP_DRAWDATA_ONLY3D = (1 << 1),
90   /** only draw 'canvas' strokes */
91   GP_DRAWDATA_ONLYV2D = (1 << 2),
92   /** only draw 'image' strokes */
93   GP_DRAWDATA_ONLYI2D = (1 << 3),
94   /** special hack for drawing strokes in Image Editor (weird coordinates) */
95   GP_DRAWDATA_IEDITHACK = (1 << 4),
96   /** don't draw xray in 3D view (which is default) */
97   GP_DRAWDATA_NO_XRAY = (1 << 5),
98   /** no onionskins should be drawn (for animation playback) */
99   GP_DRAWDATA_NO_ONIONS = (1 << 6),
100   /** draw strokes as "volumetric" circular billboards */
101   GP_DRAWDATA_VOLUMETRIC = (1 << 7),
102   /** fill insides/bounded-regions of strokes */
103   GP_DRAWDATA_FILL = (1 << 8),
104 } eDrawStrokeFlags;
105
106 /* thickness above which we should use special drawing */
107 #if 0
108 #  define GP_DRAWTHICKNESS_SPECIAL 3
109 #endif
110
111 /* conversion utility (float --> normalized unsigned byte) */
112 #define F2UB(x) (uchar)(255.0f * x)
113
114 /* ----- Tool Buffer Drawing ------ */
115 /* helper functions to set color of buffer point */
116
117 static void gp_set_point_uniform_color(const bGPDspoint *pt, const float ink[4])
118 {
119   float alpha = ink[3] * pt->strength;
120   CLAMP(alpha, GPENCIL_STRENGTH_MIN, 1.0f);
121   immUniformColor3fvAlpha(ink, alpha);
122 }
123
124 static void gp_set_point_varying_color(const bGPDspoint *pt, const float ink[4], uint attr_id)
125 {
126   float alpha = ink[3] * pt->strength;
127   CLAMP(alpha, GPENCIL_STRENGTH_MIN, 1.0f);
128   immAttr4ub(attr_id, F2UB(ink[0]), F2UB(ink[1]), F2UB(ink[2]), F2UB(alpha));
129 }
130
131 /* --------- 2D Stroke Drawing Helpers --------- */
132 /* change in parameter list */
133 static void gp_calc_2d_stroke_fxy(
134     const float pt[3], short sflag, int offsx, int offsy, int winx, int winy, float r_co[2])
135 {
136   if (sflag & GP_STROKE_2DSPACE) {
137     r_co[0] = pt[0];
138     r_co[1] = pt[1];
139   }
140   else if (sflag & GP_STROKE_2DIMAGE) {
141     const float x = (float)((pt[0] * winx) + offsx);
142     const float y = (float)((pt[1] * winy) + offsy);
143
144     r_co[0] = x;
145     r_co[1] = y;
146   }
147   else {
148     const float x = (float)(pt[0] / 100 * winx) + offsx;
149     const float y = (float)(pt[1] / 100 * winy) + offsy;
150
151     r_co[0] = x;
152     r_co[1] = y;
153   }
154 }
155 /* ----------- Volumetric Strokes --------------- */
156
157 /* draw a 2D strokes in "volumetric" style */
158 static void gp_draw_stroke_volumetric_2d(const bGPDspoint *points,
159                                          int totpoints,
160                                          short thickness,
161                                          short UNUSED(dflag),
162                                          short sflag,
163                                          int offsx,
164                                          int offsy,
165                                          int winx,
166                                          int winy,
167                                          const float diff_mat[4][4],
168                                          const float ink[4])
169 {
170   GPUVertFormat *format = immVertexFormat();
171   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
172   uint size = GPU_vertformat_attr_add(format, "size", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
173   uint color = GPU_vertformat_attr_add(
174       format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
175
176   immBindBuiltinProgram(GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR);
177   GPU_enable_program_point_size();
178   immBegin(GPU_PRIM_POINTS, totpoints);
179
180   const bGPDspoint *pt = points;
181   for (int i = 0; i < totpoints; i++, pt++) {
182     /* transform position to 2D */
183     float co[2];
184     float fpt[3];
185
186     mul_v3_m4v3(fpt, diff_mat, &pt->x);
187     gp_calc_2d_stroke_fxy(fpt, sflag, offsx, offsy, winx, winy, co);
188
189     gp_set_point_varying_color(pt, ink, color);
190     immAttr1f(size, pt->pressure * thickness); /* TODO: scale based on view transform */
191     immVertex2f(pos, co[0], co[1]);
192   }
193
194   immEnd();
195   immUnbindProgram();
196   GPU_disable_program_point_size();
197 }
198
199 /* draw a 3D stroke in "volumetric" style */
200 static void gp_draw_stroke_volumetric_3d(const bGPDspoint *points,
201                                          int totpoints,
202                                          short thickness,
203                                          const float ink[4])
204 {
205   GPUVertFormat *format = immVertexFormat();
206   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
207   uint size = GPU_vertformat_attr_add(format, "size", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
208   uint color = GPU_vertformat_attr_add(
209       format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
210
211   immBindBuiltinProgram(GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR);
212   GPU_enable_program_point_size();
213   immBegin(GPU_PRIM_POINTS, totpoints);
214
215   const bGPDspoint *pt = points;
216   for (int i = 0; i < totpoints && pt; i++, pt++) {
217     gp_set_point_varying_color(pt, ink, color);
218     /* TODO: scale based on view transform */
219     immAttr1f(size, pt->pressure * thickness);
220     /* we can adjust size in vertex shader based on view/projection! */
221     immVertex3fv(pos, &pt->x);
222   }
223
224   immEnd();
225   immUnbindProgram();
226   GPU_disable_program_point_size();
227 }
228
229 /* --------------- Stroke Fills ----------------- */
230 /* calc bounding box in 2d using flat projection data */
231 static void gp_calc_2d_bounding_box(
232     const float (*points2d)[2], int totpoints, float minv[2], float maxv[2], bool expand)
233 {
234   copy_v2_v2(minv, points2d[0]);
235   copy_v2_v2(maxv, points2d[0]);
236
237   for (int i = 1; i < totpoints; i++) {
238     /* min */
239     if (points2d[i][0] < minv[0]) {
240       minv[0] = points2d[i][0];
241     }
242     if (points2d[i][1] < minv[1]) {
243       minv[1] = points2d[i][1];
244     }
245     /* max */
246     if (points2d[i][0] > maxv[0]) {
247       maxv[0] = points2d[i][0];
248     }
249     if (points2d[i][1] > maxv[1]) {
250       maxv[1] = points2d[i][1];
251     }
252   }
253   /* If not expanded, use a perfect square */
254   if (expand == false) {
255     if (maxv[0] > maxv[1]) {
256       maxv[1] = maxv[0];
257     }
258     else {
259       maxv[0] = maxv[1];
260     }
261   }
262 }
263
264 /* calc texture coordinates using flat projected points */
265 static void gp_calc_stroke_text_coordinates(
266     const float (*points2d)[2], int totpoints, float minv[2], float maxv[2], float (*r_uv)[2])
267 {
268   float d[2];
269   d[0] = maxv[0] - minv[0];
270   d[1] = maxv[1] - minv[1];
271   for (int i = 0; i < totpoints; i++) {
272     r_uv[i][0] = (points2d[i][0] - minv[0]) / d[0];
273     r_uv[i][1] = (points2d[i][1] - minv[1]) / d[1];
274   }
275 }
276
277 /* Triangulate stroke for high quality fill
278  * (this is done only if cache is null or stroke was modified). */
279 static void gp_triangulate_stroke_fill(bGPDstroke *gps)
280 {
281   BLI_assert(gps->totpoints >= 3);
282
283   /* allocate memory for temporary areas */
284   gps->tot_triangles = gps->totpoints - 2;
285   uint(*tmp_triangles)[3] = MEM_mallocN(sizeof(*tmp_triangles) * gps->tot_triangles,
286                                         "GP Stroke temp triangulation");
287   float(*points2d)[2] = MEM_mallocN(sizeof(*points2d) * gps->totpoints,
288                                     "GP Stroke temp 2d points");
289   float(*uv)[2] = MEM_mallocN(sizeof(*uv) * gps->totpoints, "GP Stroke temp 2d uv data");
290
291   int direction = 0;
292
293   /* convert to 2d and triangulate */
294   BKE_gpencil_stroke_2d_flat(gps->points, gps->totpoints, points2d, &direction);
295   BLI_polyfill_calc(points2d, (uint)gps->totpoints, direction, tmp_triangles);
296
297   /* calc texture coordinates automatically */
298   float minv[2];
299   float maxv[2];
300   /* first needs bounding box data */
301   gp_calc_2d_bounding_box((const float(*)[2])points2d, gps->totpoints, minv, maxv, false);
302   /* calc uv data */
303   gp_calc_stroke_text_coordinates((const float(*)[2])points2d, gps->totpoints, minv, maxv, uv);
304
305   /* Number of triangles */
306   gps->tot_triangles = gps->totpoints - 2;
307   /* save triangulation data in stroke cache */
308   if (gps->tot_triangles > 0) {
309     if (gps->triangles == NULL) {
310       gps->triangles = MEM_callocN(sizeof(*gps->triangles) * gps->tot_triangles,
311                                    "GP Stroke triangulation");
312     }
313     else {
314       gps->triangles = MEM_recallocN(gps->triangles, sizeof(*gps->triangles) * gps->tot_triangles);
315     }
316
317     for (int i = 0; i < gps->tot_triangles; i++) {
318       bGPDtriangle *stroke_triangle = &gps->triangles[i];
319       memcpy(stroke_triangle->verts, tmp_triangles[i], sizeof(uint[3]));
320       /* copy texture coordinates */
321       copy_v2_v2(stroke_triangle->uv[0], uv[tmp_triangles[i][0]]);
322       copy_v2_v2(stroke_triangle->uv[1], uv[tmp_triangles[i][1]]);
323       copy_v2_v2(stroke_triangle->uv[2], uv[tmp_triangles[i][2]]);
324     }
325   }
326   else {
327     /* No triangles needed - Free anything allocated previously */
328     if (gps->triangles) {
329       MEM_freeN(gps->triangles);
330     }
331
332     gps->triangles = NULL;
333   }
334
335   /* disable recalculation flag */
336   if (gps->flag & GP_STROKE_RECALC_GEOMETRY) {
337     gps->flag &= ~GP_STROKE_RECALC_GEOMETRY;
338   }
339
340   /* clear memory */
341   MEM_SAFE_FREE(tmp_triangles);
342   MEM_SAFE_FREE(points2d);
343   MEM_SAFE_FREE(uv);
344 }
345
346 /* add a new fill point and texture coordinates to vertex buffer */
347 static void gp_add_filldata_tobuffer(const bGPDspoint *pt,
348                                      const float uv[2],
349                                      uint pos,
350                                      uint texcoord,
351                                      short flag,
352                                      int offsx,
353                                      int offsy,
354                                      int winx,
355                                      int winy,
356                                      const float diff_mat[4][4])
357 {
358   float fpt[3];
359   float co[2];
360
361   mul_v3_m4v3(fpt, diff_mat, &pt->x);
362   /* if 2d, need conversion */
363   if (!(flag & GP_STROKE_3DSPACE)) {
364     gp_calc_2d_stroke_fxy(fpt, flag, offsx, offsy, winx, winy, co);
365     copy_v2_v2(fpt, co);
366     fpt[2] = 0.0f; /* 2d always is z=0.0f */
367   }
368
369   immAttr2f(texcoord, uv[0], uv[1]); /* texture coordinates */
370   immVertex3fv(pos, fpt);            /* position */
371 }
372
373 #if 0 /* GPXX disabled, not used in annotations */
374 /* assign image texture for filling stroke */
375 static int gp_set_filling_texture(Image *image, short flag)
376 {
377   ImBuf *ibuf;
378   uint *bind = &image->bindcode[TEXTARGET_TEXTURE_2D];
379   int error = GL_NO_ERROR;
380   ImageUser iuser = {NULL};
381   void *lock;
382
383   iuser.ok = true;
384
385   ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
386
387   if (ibuf == NULL || ibuf->rect == NULL) {
388     BKE_image_release_ibuf(image, ibuf, NULL);
389     return (int)GL_INVALID_OPERATION;
390   }
391
392   GPU_create_gl_tex(
393       bind, ibuf->rect, ibuf->rect_float, ibuf->x, ibuf->y, GL_TEXTURE_2D, false, false, image);
394
395   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
396   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
397   if (flag & GP_STYLE_COLOR_TEX_CLAMP) {
398     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
399     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
400   }
401   else {
402     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
403     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
404   }
405   BKE_image_release_ibuf(image, ibuf, NULL);
406
407   return error;
408 }
409 #endif
410
411 /* draw fills for shapes */
412 static void gp_draw_stroke_fill(bGPdata *gpd,
413                                 bGPDstroke *gps,
414                                 int offsx,
415                                 int offsy,
416                                 int winx,
417                                 int winy,
418                                 const float diff_mat[4][4],
419                                 const float color[4])
420 {
421   BLI_assert(gps->totpoints >= 3);
422   Material *ma = gpd->mat[gps->mat_nr];
423   MaterialGPencilStyle *gp_style = (ma) ? ma->gp_style : NULL;
424
425   /* Calculate triangles cache for filling area (must be done only after changes) */
426   if ((gps->flag & GP_STROKE_RECALC_GEOMETRY) || (gps->tot_triangles == 0) ||
427       (gps->triangles == NULL)) {
428     gp_triangulate_stroke_fill(gps);
429   }
430   BLI_assert(gps->tot_triangles >= 1);
431
432   GPUVertFormat *format = immVertexFormat();
433   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
434   uint texcoord = GPU_vertformat_attr_add(format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
435   immBindBuiltinProgram(GPU_SHADER_GPENCIL_FILL);
436
437   immUniformColor4fv(color);
438   immUniform4fv("color2", gp_style->mix_rgba);
439   immUniform1i("fill_type", gp_style->fill_style);
440   immUniform1f("mix_factor", gp_style->mix_factor);
441
442   immUniform1f("gradient_angle", gp_style->gradient_angle);
443   immUniform1f("gradient_radius", gp_style->gradient_radius);
444   immUniform1f("pattern_gridsize", gp_style->pattern_gridsize);
445   immUniform2fv("gradient_scale", gp_style->gradient_scale);
446   immUniform2fv("gradient_shift", gp_style->gradient_shift);
447
448   immUniform1f("texture_angle", gp_style->texture_angle);
449   immUniform2fv("texture_scale", gp_style->texture_scale);
450   immUniform2fv("texture_offset", gp_style->texture_offset);
451   immUniform1f("texture_opacity", gp_style->texture_opacity);
452   immUniform1i("t_mix", (gp_style->flag & GP_STYLE_FILL_TEX_MIX) != 0);
453   immUniform1i("t_flip", (gp_style->flag & GP_STYLE_COLOR_FLIP_FILL) != 0);
454 #if 0 /* GPXX disabled, not used in annotations */
455   /* image texture */
456   if ((gp_style->fill_style == GP_STYLE_FILL_STYLE_TEXTURE) ||
457       (gp_style->flag & GP_STYLE_COLOR_TEX_MIX)) {
458     gp_set_filling_texture(gp_style->ima, gp_style->flag);
459   }
460 #endif
461   /* Draw all triangles for filling the polygon (cache must be calculated before) */
462   immBegin(GPU_PRIM_TRIS, gps->tot_triangles * 3);
463   /* TODO: use batch instead of immediate mode, to share vertices */
464
465   const bGPDtriangle *stroke_triangle = gps->triangles;
466   for (int i = 0; i < gps->tot_triangles; i++, stroke_triangle++) {
467     for (int j = 0; j < 3; j++) {
468       gp_add_filldata_tobuffer(&gps->points[stroke_triangle->verts[j]],
469                                stroke_triangle->uv[j],
470                                pos,
471                                texcoord,
472                                gps->flag,
473                                offsx,
474                                offsy,
475                                winx,
476                                winy,
477                                diff_mat);
478     }
479   }
480
481   immEnd();
482   immUnbindProgram();
483 }
484
485 /* ----- Existing Strokes Drawing (3D and Point) ------ */
486
487 /* draw a given stroke - just a single dot (only one point) */
488 static void gp_draw_stroke_point(const bGPDspoint *points,
489                                  short thickness,
490                                  short UNUSED(dflag),
491                                  short sflag,
492                                  int offsx,
493                                  int offsy,
494                                  int winx,
495                                  int winy,
496                                  const float diff_mat[4][4],
497                                  const float ink[4])
498 {
499   const bGPDspoint *pt = points;
500
501   /* get final position using parent matrix */
502   float fpt[3];
503   mul_v3_m4v3(fpt, diff_mat, &pt->x);
504
505   GPUVertFormat *format = immVertexFormat();
506   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
507
508   if (sflag & GP_STROKE_3DSPACE) {
509     immBindBuiltinProgram(GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA);
510   }
511   else {
512     immBindBuiltinProgram(GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA);
513
514     /* get 2D coordinates of point */
515     float co[3] = {0.0f};
516     gp_calc_2d_stroke_fxy(fpt, sflag, offsx, offsy, winx, winy, co);
517     copy_v3_v3(fpt, co);
518   }
519
520   gp_set_point_uniform_color(pt, ink);
521   /* set point thickness (since there's only one of these) */
522   immUniform1f("size", (float)(thickness + 2) * pt->pressure);
523
524   immBegin(GPU_PRIM_POINTS, 1);
525   immVertex3fv(pos, fpt);
526   immEnd();
527
528   immUnbindProgram();
529 }
530
531 /* draw a given stroke in 3d (i.e. in 3d-space) */
532 static void gp_draw_stroke_3d(tGPDdraw *tgpw, short thickness, const float ink[4], bool cyclic)
533 {
534   bGPDspoint *points = tgpw->gps->points;
535   int totpoints = tgpw->gps->totpoints;
536
537   const float viewport[2] = {(float)tgpw->winx, (float)tgpw->winy};
538   float curpressure = points[0].pressure;
539   float fpt[3];
540
541   /* if cyclic needs more vertex */
542   int cyclic_add = (cyclic) ? 1 : 0;
543
544   GPUVertFormat *format = immVertexFormat();
545   const struct {
546     uint pos, color, thickness;
547   } attr_id = {
548       .pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT),
549       .color = GPU_vertformat_attr_add(
550           format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT),
551       .thickness = GPU_vertformat_attr_add(format, "thickness", GPU_COMP_F32, 1, GPU_FETCH_FLOAT),
552   };
553
554   immBindBuiltinProgram(GPU_SHADER_GPENCIL_STROKE);
555   immUniform2fv("Viewport", viewport);
556   immUniform1f("pixsize", tgpw->rv3d->pixsize);
557   float obj_scale = tgpw->ob ?
558                         (tgpw->ob->scale[0] + tgpw->ob->scale[1] + tgpw->ob->scale[2]) / 3.0f :
559                         1.0f;
560
561   immUniform1f("objscale", obj_scale);
562   int keep_size = (int)((tgpw->gpd) && (tgpw->gpd->flag & GP_DATA_STROKE_KEEPTHICKNESS));
563   immUniform1i("keep_size", keep_size);
564   immUniform1f("pixfactor", tgpw->gpd->pixfactor);
565   /* xray mode always to 3D space to avoid wrong zdepth calculation (T60051) */
566   immUniform1i("xraymode", GP_XRAY_3DSPACE);
567   immUniform1i("caps_start", (int)tgpw->gps->caps[0]);
568   immUniform1i("caps_end", (int)tgpw->gps->caps[1]);
569   immUniform1i("fill_stroke", (int)tgpw->is_fill_stroke);
570
571   /* draw stroke curve */
572   GPU_line_width(max_ff(curpressure * thickness, 1.0f));
573   immBeginAtMost(GPU_PRIM_LINE_STRIP_ADJ, totpoints + cyclic_add + 2);
574   const bGPDspoint *pt = points;
575
576   for (int i = 0; i < totpoints; i++, pt++) {
577     /* first point for adjacency (not drawn) */
578     if (i == 0) {
579       gp_set_point_varying_color(points, ink, attr_id.color);
580
581       if ((cyclic) && (totpoints > 2)) {
582         immAttr1f(attr_id.thickness, max_ff((points + totpoints - 1)->pressure * thickness, 1.0f));
583         mul_v3_m4v3(fpt, tgpw->diff_mat, &(points + totpoints - 1)->x);
584       }
585       else {
586         immAttr1f(attr_id.thickness, max_ff((points + 1)->pressure * thickness, 1.0f));
587         mul_v3_m4v3(fpt, tgpw->diff_mat, &(points + 1)->x);
588       }
589       immVertex3fv(attr_id.pos, fpt);
590     }
591     /* set point */
592     gp_set_point_varying_color(pt, ink, attr_id.color);
593     immAttr1f(attr_id.thickness, max_ff(pt->pressure * thickness, 1.0f));
594     mul_v3_m4v3(fpt, tgpw->diff_mat, &pt->x);
595     immVertex3fv(attr_id.pos, fpt);
596   }
597
598   if (cyclic && totpoints > 2) {
599     /* draw line to first point to complete the cycle */
600     immAttr1f(attr_id.thickness, max_ff(points->pressure * thickness, 1.0f));
601     mul_v3_m4v3(fpt, tgpw->diff_mat, &points->x);
602     immVertex3fv(attr_id.pos, fpt);
603
604     /* now add adjacency point (not drawn) */
605     immAttr1f(attr_id.thickness, max_ff((points + 1)->pressure * thickness, 1.0f));
606     mul_v3_m4v3(fpt, tgpw->diff_mat, &(points + 1)->x);
607     immVertex3fv(attr_id.pos, fpt);
608   }
609   /* last adjacency point (not drawn) */
610   else {
611     gp_set_point_varying_color(points + totpoints - 2, ink, attr_id.color);
612     immAttr1f(attr_id.thickness, max_ff((points + totpoints - 2)->pressure * thickness, 1.0f));
613     mul_v3_m4v3(fpt, tgpw->diff_mat, &(points + totpoints - 2)->x);
614     immVertex3fv(attr_id.pos, fpt);
615   }
616
617   immEnd();
618   immUnbindProgram();
619 }
620
621 /* ----- Fancy 2D-Stroke Drawing ------ */
622
623 /* draw a given stroke in 2d */
624 static void gp_draw_stroke_2d(const bGPDspoint *points,
625                               int totpoints,
626                               short thickness_s,
627                               short dflag,
628                               short sflag,
629                               bool UNUSED(debug),
630                               int offsx,
631                               int offsy,
632                               int winx,
633                               int winy,
634                               const float diff_mat[4][4],
635                               const float ink[4])
636 {
637   /* otherwise thickness is twice that of the 3D view */
638   float thickness = (float)thickness_s * 0.5f;
639
640   /* strokes in Image Editor need a scale factor, since units there are not pixels! */
641   float scalefac = 1.0f;
642   if ((dflag & GP_DRAWDATA_IEDITHACK) && (dflag & GP_DRAWDATA_ONLYV2D)) {
643     scalefac = 0.001f;
644   }
645
646   /* TODO: fancy++ with the magic of shaders */
647
648   /* tessellation code - draw stroke as series of connected quads (triangle strips in fact)
649    * with connection edges rotated to minimize shrinking artifacts, and rounded endcaps.
650    */
651   {
652     const bGPDspoint *pt1, *pt2;
653     float s0[2], s1[2]; /* segment 'center' points */
654     float pm[2];        /* normal from previous segment. */
655     int i;
656     float fpt[3];
657
658     GPUVertFormat *format = immVertexFormat();
659     const struct {
660       uint pos, color;
661     } attr_id = {
662         .pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT),
663         .color = GPU_vertformat_attr_add(
664             format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT),
665     };
666
667     immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
668     immBegin(GPU_PRIM_TRI_STRIP, totpoints * 2 + 4);
669
670     /* get x and y coordinates from first point */
671     mul_v3_m4v3(fpt, diff_mat, &points->x);
672     gp_calc_2d_stroke_fxy(fpt, sflag, offsx, offsy, winx, winy, s0);
673
674     for (i = 0, pt1 = points, pt2 = points + 1; i < (totpoints - 1); i++, pt1++, pt2++) {
675       float t0[2], t1[2]; /* tessellated coordinates */
676       float m1[2], m2[2]; /* gradient and normal */
677       float mt[2], sc[2]; /* gradient for thickness, point for end-cap */
678       float pthick;       /* thickness at segment point */
679
680       /* Get x and y coordinates from point2
681        * (point1 has already been computed in previous iteration). */
682       mul_v3_m4v3(fpt, diff_mat, &pt2->x);
683       gp_calc_2d_stroke_fxy(fpt, sflag, offsx, offsy, winx, winy, s1);
684
685       /* calculate gradient and normal - 'angle'=(ny/nx) */
686       m1[1] = s1[1] - s0[1];
687       m1[0] = s1[0] - s0[0];
688       normalize_v2(m1);
689       m2[1] = -m1[0];
690       m2[0] = m1[1];
691
692       /* always use pressure from first point here */
693       pthick = (pt1->pressure * thickness * scalefac);
694
695       /* color of point */
696       gp_set_point_varying_color(pt1, ink, attr_id.color);
697
698       /* if the first segment, start of segment is segment's normal */
699       if (i == 0) {
700         /* draw start cap first
701          * - make points slightly closer to center (about halfway across)
702          */
703         mt[0] = m2[0] * pthick * 0.5f;
704         mt[1] = m2[1] * pthick * 0.5f;
705         sc[0] = s0[0] - (m1[0] * pthick * 0.75f);
706         sc[1] = s0[1] - (m1[1] * pthick * 0.75f);
707
708         t0[0] = sc[0] - mt[0];
709         t0[1] = sc[1] - mt[1];
710         t1[0] = sc[0] + mt[0];
711         t1[1] = sc[1] + mt[1];
712
713         /* First two points of cap. */
714         immVertex2fv(attr_id.pos, t0);
715         immVertex2fv(attr_id.pos, t1);
716
717         /* calculate points for start of segment */
718         mt[0] = m2[0] * pthick;
719         mt[1] = m2[1] * pthick;
720
721         t0[0] = s0[0] - mt[0];
722         t0[1] = s0[1] - mt[1];
723         t1[0] = s0[0] + mt[0];
724         t1[1] = s0[1] + mt[1];
725
726         /* Last two points of start cap (and first two points of first segment). */
727         immVertex2fv(attr_id.pos, t0);
728         immVertex2fv(attr_id.pos, t1);
729       }
730       /* if not the first segment, use bisector of angle between segments */
731       else {
732         float mb[2];        /* bisector normal */
733         float athick, dfac; /* actual thickness, difference between thicknesses */
734
735         /* calculate gradient of bisector (as average of normals) */
736         mb[0] = (pm[0] + m2[0]) / 2;
737         mb[1] = (pm[1] + m2[1]) / 2;
738         normalize_v2(mb);
739
740         /* calculate gradient to apply
741          * - as basis, use just pthick * bisector gradient
742          * - if cross-section not as thick as it should be, add extra padding to fix it
743          */
744         mt[0] = mb[0] * pthick;
745         mt[1] = mb[1] * pthick;
746         athick = len_v2(mt);
747         dfac = pthick - (athick * 2);
748
749         if (((athick * 2.0f) < pthick) && (IS_EQF(athick, pthick) == 0)) {
750           mt[0] += (mb[0] * dfac);
751           mt[1] += (mb[1] * dfac);
752         }
753
754         /* calculate points for start of segment */
755         t0[0] = s0[0] - mt[0];
756         t0[1] = s0[1] - mt[1];
757         t1[0] = s0[0] + mt[0];
758         t1[1] = s0[1] + mt[1];
759
760         /* Last two points of previous segment, and first two points of current segment. */
761         immVertex2fv(attr_id.pos, t0);
762         immVertex2fv(attr_id.pos, t1);
763       }
764
765       /* if last segment, also draw end of segment (defined as segment's normal) */
766       if (i == totpoints - 2) {
767         /* for once, we use second point's pressure (otherwise it won't be drawn) */
768         pthick = (pt2->pressure * thickness * scalefac);
769
770         /* color of point */
771         gp_set_point_varying_color(pt2, ink, attr_id.color);
772
773         /* calculate points for end of segment */
774         mt[0] = m2[0] * pthick;
775         mt[1] = m2[1] * pthick;
776
777         t0[0] = s1[0] - mt[0];
778         t0[1] = s1[1] - mt[1];
779         t1[0] = s1[0] + mt[0];
780         t1[1] = s1[1] + mt[1];
781
782         /* Last two points of last segment (and first two points of end cap). */
783         immVertex2fv(attr_id.pos, t0);
784         immVertex2fv(attr_id.pos, t1);
785
786         /* draw end cap as last step
787          * - make points slightly closer to center (about halfway across)
788          */
789         mt[0] = m2[0] * pthick * 0.5f;
790         mt[1] = m2[1] * pthick * 0.5f;
791         sc[0] = s1[0] + (m1[0] * pthick * 0.75f);
792         sc[1] = s1[1] + (m1[1] * pthick * 0.75f);
793
794         t0[0] = sc[0] - mt[0];
795         t0[1] = sc[1] - mt[1];
796         t1[0] = sc[0] + mt[0];
797         t1[1] = sc[1] + mt[1];
798
799         /* Last two points of end cap. */
800         immVertex2fv(attr_id.pos, t0);
801         immVertex2fv(attr_id.pos, t1);
802       }
803
804       /* store computed point2 coordinates as point1 ones of next segment. */
805       copy_v2_v2(s0, s1);
806       /* store stroke's 'natural' normal for next stroke to use */
807       copy_v2_v2(pm, m2);
808     }
809
810     immEnd();
811     immUnbindProgram();
812   }
813 }
814
815 /* ----- Strokes Drawing ------ */
816
817 /* Helper for doing all the checks on whether a stroke can be drawn */
818 static bool gp_can_draw_stroke(const bGPDstroke *gps, const int dflag)
819 {
820   /* skip stroke if it isn't in the right display space for this drawing context */
821   /* 1) 3D Strokes */
822   if ((dflag & GP_DRAWDATA_ONLY3D) && !(gps->flag & GP_STROKE_3DSPACE)) {
823     return false;
824   }
825   if (!(dflag & GP_DRAWDATA_ONLY3D) && (gps->flag & GP_STROKE_3DSPACE)) {
826     return false;
827   }
828
829   /* 2) Screen Space 2D Strokes */
830   if ((dflag & GP_DRAWDATA_ONLYV2D) && !(gps->flag & GP_STROKE_2DSPACE)) {
831     return false;
832   }
833   if (!(dflag & GP_DRAWDATA_ONLYV2D) && (gps->flag & GP_STROKE_2DSPACE)) {
834     return false;
835   }
836
837   /* 3) Image Space (2D) */
838   if ((dflag & GP_DRAWDATA_ONLYI2D) && !(gps->flag & GP_STROKE_2DIMAGE)) {
839     return false;
840   }
841   if (!(dflag & GP_DRAWDATA_ONLYI2D) && (gps->flag & GP_STROKE_2DIMAGE)) {
842     return false;
843   }
844
845   /* skip stroke if it doesn't have any valid data */
846   if ((gps->points == NULL) || (gps->totpoints < 1)) {
847     return false;
848   }
849
850   /* stroke can be drawn */
851   return true;
852 }
853
854 /* draw a set of strokes */
855 static void gp_draw_strokes(tGPDdraw *tgpw)
856 {
857   float tcolor[4];
858   float tfill[4];
859   short sthickness;
860   float ink[4];
861
862   GPU_enable_program_point_size();
863
864   for (bGPDstroke *gps = tgpw->t_gpf->strokes.first; gps; gps = gps->next) {
865     /* check if stroke can be drawn */
866     if (gp_can_draw_stroke(gps, tgpw->dflag) == false) {
867       continue;
868     }
869     /* check if the color is visible */
870     Material *ma = tgpw->gpd->mat[gps->mat_nr];
871     MaterialGPencilStyle *gp_style = (ma) ? ma->gp_style : NULL;
872
873     if ((gp_style == NULL) || (gp_style->flag & GP_STYLE_COLOR_HIDE) ||
874         /* if onion and ghost flag do not draw*/
875         (tgpw->onion && (gp_style->flag & GP_STYLE_COLOR_ONIONSKIN))) {
876       continue;
877     }
878
879     /* if disable fill, the colors with fill must be omitted too except fill boundary strokes */
880     if ((tgpw->disable_fill == 1) && (gp_style->fill_rgba[3] > 0.0f) &&
881         ((gps->flag & GP_STROKE_NOFILL) == 0)) {
882       continue;
883     }
884
885     /* calculate thickness */
886     sthickness = gps->thickness + tgpw->lthick;
887
888     if (tgpw->is_fill_stroke) {
889       sthickness = (short)max_ii(1, sthickness / 2);
890     }
891
892     if (sthickness <= 0) {
893       continue;
894     }
895
896     /* check which stroke-drawer to use */
897     if (tgpw->dflag & GP_DRAWDATA_ONLY3D) {
898       const int no_xray = (tgpw->dflag & GP_DRAWDATA_NO_XRAY);
899       int mask_orig = 0;
900
901       if (no_xray) {
902         glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig);
903         glDepthMask(0);
904         GPU_depth_test(true);
905
906         /* first arg is normally rv3d->dist, but this isn't
907          * available here and seems to work quite well without */
908         bglPolygonOffset(1.0f, 1.0f);
909       }
910
911       /* 3D Fill */
912       //if ((dflag & GP_DRAWDATA_FILL) && (gps->totpoints >= 3)) {
913       if ((gps->totpoints >= 3) && (tgpw->disable_fill != 1)) {
914         /* set color using material, tint color and opacity */
915         interp_v3_v3v3(tfill, gp_style->fill_rgba, tgpw->tintcolor, tgpw->tintcolor[3]);
916         tfill[3] = gp_style->fill_rgba[3] * tgpw->opacity;
917         if ((tfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) || (gp_style->fill_style > 0)) {
918           const float *color;
919           if (!tgpw->onion) {
920             color = tfill;
921           }
922           else {
923             if (tgpw->custonion) {
924               color = tgpw->tintcolor;
925             }
926             else {
927               ARRAY_SET_ITEMS(tfill, UNPACK3(gp_style->fill_rgba), tgpw->tintcolor[3]);
928               color = tfill;
929             }
930           }
931           gp_draw_stroke_fill(tgpw->gpd,
932                               gps,
933                               tgpw->offsx,
934                               tgpw->offsy,
935                               tgpw->winx,
936                               tgpw->winy,
937                               tgpw->diff_mat,
938                               color);
939         }
940       }
941
942       /* 3D Stroke */
943       /* set color using material tint color and opacity */
944       if (!tgpw->onion) {
945         interp_v3_v3v3(tcolor, gp_style->stroke_rgba, tgpw->tintcolor, tgpw->tintcolor[3]);
946         tcolor[3] = gp_style->stroke_rgba[3] * tgpw->opacity;
947         copy_v4_v4(ink, tcolor);
948       }
949       else {
950         if (tgpw->custonion) {
951           copy_v4_v4(ink, tgpw->tintcolor);
952         }
953         else {
954           ARRAY_SET_ITEMS(tcolor, UNPACK3(gp_style->stroke_rgba), tgpw->opacity);
955           copy_v4_v4(ink, tcolor);
956         }
957       }
958       if (gp_style->mode == GP_STYLE_MODE_DOTS) {
959         /* volumetric stroke drawing */
960         if (tgpw->disable_fill != 1) {
961           gp_draw_stroke_volumetric_3d(gps->points, gps->totpoints, sthickness, ink);
962         }
963       }
964       else {
965         /* 3D Lines - OpenGL primitives-based */
966         if (gps->totpoints == 1) {
967           if (tgpw->disable_fill != 1) {
968             gp_draw_stroke_point(gps->points,
969                                  sthickness,
970                                  tgpw->dflag,
971                                  gps->flag,
972                                  tgpw->offsx,
973                                  tgpw->offsy,
974                                  tgpw->winx,
975                                  tgpw->winy,
976                                  tgpw->diff_mat,
977                                  ink);
978           }
979         }
980         else {
981           tgpw->gps = gps;
982           gp_draw_stroke_3d(tgpw, sthickness, ink, gps->flag & GP_STROKE_CYCLIC);
983         }
984       }
985       if (no_xray) {
986         glDepthMask(mask_orig);
987         GPU_depth_test(false);
988
989         bglPolygonOffset(0.0, 0.0);
990       }
991     }
992     else {
993       /* 2D - Fill */
994       if (gps->totpoints >= 3) {
995         /* set color using material, tint color and opacity */
996         interp_v3_v3v3(tfill, gp_style->fill_rgba, tgpw->tintcolor, tgpw->tintcolor[3]);
997         tfill[3] = gp_style->fill_rgba[3] * tgpw->opacity;
998         if ((tfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) || (gp_style->fill_style > 0)) {
999           const float *color;
1000           if (!tgpw->onion) {
1001             color = tfill;
1002           }
1003           else {
1004             if (tgpw->custonion) {
1005               color = tgpw->tintcolor;
1006             }
1007             else {
1008               ARRAY_SET_ITEMS(tfill, UNPACK3(gp_style->fill_rgba), tgpw->tintcolor[3]);
1009               color = tfill;
1010             }
1011           }
1012           gp_draw_stroke_fill(tgpw->gpd,
1013                               gps,
1014                               tgpw->offsx,
1015                               tgpw->offsy,
1016                               tgpw->winx,
1017                               tgpw->winy,
1018                               tgpw->diff_mat,
1019                               color);
1020         }
1021       }
1022
1023       /* 2D Strokes... */
1024       /* set color using material, tint color and opacity */
1025       if (!tgpw->onion) {
1026         interp_v3_v3v3(tcolor, gp_style->stroke_rgba, tgpw->tintcolor, tgpw->tintcolor[3]);
1027         tcolor[3] = gp_style->stroke_rgba[3] * tgpw->opacity;
1028         copy_v4_v4(ink, tcolor);
1029       }
1030       else {
1031         if (tgpw->custonion) {
1032           copy_v4_v4(ink, tgpw->tintcolor);
1033         }
1034         else {
1035           ARRAY_SET_ITEMS(tcolor, UNPACK3(gp_style->stroke_rgba), tgpw->opacity);
1036           copy_v4_v4(ink, tcolor);
1037         }
1038       }
1039       if (gp_style->mode == GP_STYLE_MODE_DOTS) {
1040         /* blob/disk-based "volumetric" drawing */
1041         gp_draw_stroke_volumetric_2d(gps->points,
1042                                      gps->totpoints,
1043                                      sthickness,
1044                                      tgpw->dflag,
1045                                      gps->flag,
1046                                      tgpw->offsx,
1047                                      tgpw->offsy,
1048                                      tgpw->winx,
1049                                      tgpw->winy,
1050                                      tgpw->diff_mat,
1051                                      ink);
1052       }
1053       else {
1054         /* normal 2D strokes */
1055         if (gps->totpoints == 1) {
1056           gp_draw_stroke_point(gps->points,
1057                                sthickness,
1058                                tgpw->dflag,
1059                                gps->flag,
1060                                tgpw->offsx,
1061                                tgpw->offsy,
1062                                tgpw->winx,
1063                                tgpw->winy,
1064                                tgpw->diff_mat,
1065                                ink);
1066         }
1067         else {
1068           gp_draw_stroke_2d(gps->points,
1069                             gps->totpoints,
1070                             sthickness,
1071                             tgpw->dflag,
1072                             gps->flag,
1073                             false,
1074                             tgpw->offsx,
1075                             tgpw->offsy,
1076                             tgpw->winx,
1077                             tgpw->winy,
1078                             tgpw->diff_mat,
1079                             ink);
1080         }
1081       }
1082     }
1083   }
1084
1085   GPU_disable_program_point_size();
1086 }
1087
1088 /* ----- General Drawing ------ */
1089
1090 /* draw interpolate strokes (used only while operator is running) */
1091 void ED_gp_draw_interpolation(const bContext *C, tGPDinterpolate *tgpi, const int type)
1092 {
1093   tGPDdraw tgpw;
1094   ARegion *ar = CTX_wm_region(C);
1095   RegionView3D *rv3d = ar->regiondata;
1096   tGPDinterpolate_layer *tgpil;
1097   Object *obact = CTX_data_active_object(C);
1098   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1099
1100   float color[4];
1101
1102   UI_GetThemeColor3fv(TH_GP_VERTEX_SELECT, color);
1103   color[3] = 0.6f;
1104   int dflag = 0;
1105   /* if 3d stuff, enable flags */
1106   if (type == REGION_DRAW_POST_VIEW) {
1107     dflag |= (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_NOSTATUS);
1108   }
1109
1110   tgpw.rv3d = rv3d;
1111   tgpw.depsgraph = depsgraph;
1112   tgpw.ob = obact;
1113   tgpw.gpd = tgpi->gpd;
1114   tgpw.offsx = 0;
1115   tgpw.offsy = 0;
1116   tgpw.winx = tgpi->ar->winx;
1117   tgpw.winy = tgpi->ar->winy;
1118   tgpw.dflag = dflag;
1119
1120   /* turn on alpha-blending */
1121   GPU_blend(true);
1122   for (tgpil = tgpi->ilayers.first; tgpil; tgpil = tgpil->next) {
1123     /* calculate parent position */
1124     ED_gpencil_parent_location(depsgraph, obact, tgpi->gpd, tgpil->gpl, tgpw.diff_mat);
1125     if (tgpil->interFrame) {
1126       tgpw.gpl = tgpil->gpl;
1127       tgpw.gpf = tgpil->interFrame;
1128       tgpw.t_gpf = tgpil->interFrame;
1129
1130       tgpw.lthick = tgpil->gpl->line_change;
1131       tgpw.opacity = 1.0;
1132       copy_v4_v4(tgpw.tintcolor, color);
1133       tgpw.onion = true;
1134       tgpw.custonion = true;
1135
1136       gp_draw_strokes(&tgpw);
1137     }
1138   }
1139   GPU_blend(false);
1140 }
1141
1142 /* wrapper to draw strokes for filling operator */
1143 void ED_gp_draw_fill(tGPDdraw *tgpw)
1144 {
1145   gp_draw_strokes(tgpw);
1146 }
1147
1148 /* draw a short status message in the top-right corner */
1149 static void UNUSED_FUNCTION(gp_draw_status_text)(const bGPdata *gpd, ARegion *ar)
1150 {
1151   rcti rect;
1152
1153   /* Cannot draw any status text when drawing OpenGL Renders */
1154   if (G.f & G_FLAG_RENDER_VIEWPORT) {
1155     return;
1156   }
1157
1158   /* Get bounds of region - Necessary to avoid problems with region overlap */
1159   ED_region_visible_rect(ar, &rect);
1160
1161   /* for now, this should only be used to indicate when we are in stroke editmode */
1162   if (gpd->flag & GP_DATA_STROKE_EDITMODE) {
1163     const char *printable = IFACE_("GPencil Stroke Editing");
1164     float printable_size[2];
1165
1166     int font_id = BLF_default();
1167
1168     BLF_width_and_height(
1169         font_id, printable, BLF_DRAW_STR_DUMMY_MAX, &printable_size[0], &printable_size[1]);
1170
1171     int xco = (rect.xmax - U.widget_unit) - (int)printable_size[0];
1172     int yco = (rect.ymax - U.widget_unit);
1173
1174     /* text label */
1175     UI_FontThemeColor(font_id, TH_TEXT_HI);
1176 #ifdef WITH_INTERNATIONAL
1177     BLF_draw_default(xco, yco, 0.0f, printable, BLF_DRAW_STR_DUMMY_MAX);
1178 #else
1179     BLF_draw_default_ascii(xco, yco, 0.0f, printable, BLF_DRAW_STR_DUMMY_MAX);
1180 #endif
1181
1182     /* grease pencil icon... */
1183     // XXX: is this too intrusive?
1184     GPU_blend_set_func_separate(
1185         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
1186     GPU_blend(true);
1187
1188     xco -= U.widget_unit;
1189     yco -= (int)printable_size[1] / 2;
1190
1191     UI_icon_draw(xco, yco, ICON_GREASEPENCIL);
1192
1193     GPU_blend(false);
1194   }
1195 }