Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / gpencil / annotate_draw.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
38 #include "BLF_api.h"
39 #include "BLT_translation.h"
40
41 #include "DNA_gpencil_types.h"
42 #include "DNA_scene_types.h"
43 #include "DNA_screen_types.h"
44 #include "DNA_space_types.h"
45 #include "DNA_view3d_types.h"
46 #include "DNA_userdef_types.h"
47 #include "DNA_object_types.h"
48
49 #include "BKE_context.h"
50 #include "BKE_global.h"
51 #include "BKE_gpencil.h"
52
53 #include "WM_api.h"
54
55 #include "BIF_glutil.h"
56
57 #include "GPU_immediate.h"
58 #include "GPU_draw.h"
59 #include "GPU_state.h"
60
61 #include "ED_gpencil.h"
62 #include "ED_screen.h"
63 #include "ED_view3d.h"
64 #include "ED_space_api.h"
65
66 #include "UI_interface_icons.h"
67 #include "UI_resources.h"
68
69 /* ************************************************** */
70 /* GREASE PENCIL DRAWING */
71
72 /* ----- General Defines ------ */
73 /* flags for sflag */
74 typedef enum eDrawStrokeFlags {
75   /** don't draw status info */
76   GP_DRAWDATA_NOSTATUS = (1 << 0),
77   /** only draw 3d-strokes */
78   GP_DRAWDATA_ONLY3D = (1 << 1),
79   /** only draw 'canvas' strokes */
80   GP_DRAWDATA_ONLYV2D = (1 << 2),
81   /** only draw 'image' strokes */
82   GP_DRAWDATA_ONLYI2D = (1 << 3),
83   /** special hack for drawing strokes in Image Editor (weird coordinates) */
84   GP_DRAWDATA_IEDITHACK = (1 << 4),
85   /** don't draw xray in 3D view (which is default) */
86   GP_DRAWDATA_NO_XRAY = (1 << 5),
87   /** no onionskins should be drawn (for animation playback) */
88   GP_DRAWDATA_NO_ONIONS = (1 << 6),
89 } eDrawStrokeFlags;
90
91 /* ----- Tool Buffer Drawing ------ */
92
93 /* draw stroke defined in buffer (simple ogl lines/points for now, as dotted lines) */
94 static void gp_draw_stroke_buffer(const tGPspoint *points,
95                                   int totpoints,
96                                   short thickness,
97                                   short dflag,
98                                   short sflag,
99                                   float ink[4])
100 {
101   int draw_points = 0;
102
103   /* error checking */
104   if ((points == NULL) || (totpoints <= 0)) {
105     return;
106   }
107
108   /* check if buffer can be drawn */
109   if (dflag & (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_ONLYV2D)) {
110     return;
111   }
112
113   if (sflag & GP_STROKE_ERASER) {
114     /* don't draw stroke at all! */
115     return;
116   }
117
118   GPUVertFormat *format = immVertexFormat();
119   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
120
121   const tGPspoint *pt = points;
122
123   if (totpoints == 1) {
124     /* if drawing a single point, draw it larger */
125     GPU_point_size((float)(thickness + 2) * points->pressure);
126     immBindBuiltinProgram(GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA);
127     immUniformColor3fvAlpha(ink, ink[3]);
128     immBegin(GPU_PRIM_POINTS, 1);
129     immVertex2fv(pos, &pt->x);
130   }
131   else {
132     float oldpressure = points[0].pressure;
133
134     /* draw stroke curve */
135     GPU_line_width(max_ff(oldpressure * thickness, 1.0));
136
137     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
138     immUniformColor3fvAlpha(ink, ink[3]);
139
140     immBeginAtMost(GPU_PRIM_LINE_STRIP, totpoints);
141
142     for (int i = 0; i < totpoints; i++, pt++) {
143       /* If there was a significant pressure change,
144        * stop the curve, change the thickness of the stroke,
145        * and continue drawing again (since line-width cannot change in middle of GL_LINE_STRIP).
146        */
147       if (fabsf(pt->pressure - oldpressure) > 0.2f) {
148         /* need to have 2 points to avoid immEnd assert error */
149         if (draw_points < 2) {
150           immVertex2fv(pos, &(pt - 1)->x);
151         }
152
153         immEnd();
154         draw_points = 0;
155
156         GPU_line_width(max_ff(pt->pressure * thickness, 1.0f));
157         immBeginAtMost(GPU_PRIM_LINE_STRIP, totpoints - i + 1);
158
159         /* need to roll-back one point to ensure that there are no gaps in the stroke */
160         if (i != 0) {
161           immVertex2fv(pos, &(pt - 1)->x);
162           draw_points++;
163         }
164
165         oldpressure = pt->pressure; /* reset our threshold */
166       }
167
168       /* now the point we want */
169       immVertex2fv(pos, &pt->x);
170       draw_points++;
171     }
172     /* need to have 2 points to avoid immEnd assert error */
173     if (draw_points < 2) {
174       immVertex2fv(pos, &(pt - 1)->x);
175     }
176   }
177
178   immEnd();
179   immUnbindProgram();
180 }
181
182 /* --------- 2D Stroke Drawing Helpers --------- */
183 /* change in parameter list */
184 static void gp_calc_2d_stroke_fxy(
185     const float pt[3], short sflag, int offsx, int offsy, int winx, int winy, float r_co[2])
186 {
187   if (sflag & GP_STROKE_2DSPACE) {
188     r_co[0] = pt[0];
189     r_co[1] = pt[1];
190   }
191   else if (sflag & GP_STROKE_2DIMAGE) {
192     const float x = (float)((pt[0] * winx) + offsx);
193     const float y = (float)((pt[1] * winy) + offsy);
194
195     r_co[0] = x;
196     r_co[1] = y;
197   }
198   else {
199     const float x = (float)(pt[0] / 100 * winx) + offsx;
200     const float y = (float)(pt[1] / 100 * winy) + offsy;
201
202     r_co[0] = x;
203     r_co[1] = y;
204   }
205 }
206
207 /* ----- Existing Strokes Drawing (3D and Point) ------ */
208
209 /* draw a given stroke - just a single dot (only one point) */
210 static void gp_draw_stroke_point(const bGPDspoint *points,
211                                  short thickness,
212                                  short UNUSED(dflag),
213                                  short sflag,
214                                  int offsx,
215                                  int offsy,
216                                  int winx,
217                                  int winy,
218                                  const float ink[4])
219 {
220   const bGPDspoint *pt = points;
221
222   /* get final position using parent matrix */
223   float fpt[3];
224   copy_v3_v3(fpt, &pt->x);
225
226   GPUVertFormat *format = immVertexFormat();
227   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
228
229   if (sflag & GP_STROKE_3DSPACE) {
230     immBindBuiltinProgram(GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA);
231   }
232   else {
233     immBindBuiltinProgram(GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA);
234
235     /* get 2D coordinates of point */
236     float co[3] = {0.0f};
237     gp_calc_2d_stroke_fxy(fpt, sflag, offsx, offsy, winx, winy, co);
238     copy_v3_v3(fpt, co);
239   }
240
241   /* set color */
242   immUniformColor3fvAlpha(ink, ink[3]);
243
244   /* set point thickness (since there's only one of these) */
245   immUniform1f("size", (float)(thickness + 2) * pt->pressure);
246
247   immBegin(GPU_PRIM_POINTS, 1);
248   immVertex3fv(pos, fpt);
249   immEnd();
250
251   immUnbindProgram();
252 }
253
254 /* draw a given stroke in 3d (i.e. in 3d-space), using simple ogl lines */
255 static void gp_draw_stroke_3d(const bGPDspoint *points,
256                               int totpoints,
257                               short thickness,
258                               short UNUSED(sflag),
259                               const float ink[4],
260                               bool cyclic)
261 {
262   float curpressure = points[0].pressure;
263   float cyclic_fpt[3];
264   int draw_points = 0;
265
266   /* if cyclic needs one vertex more */
267   int cyclic_add = 0;
268   if (cyclic) {
269     cyclic_add++;
270   }
271
272   GPUVertFormat *format = immVertexFormat();
273   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
274
275   immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
276   immUniformColor3fvAlpha(ink, ink[3]);
277
278   /* draw stroke curve */
279   GPU_line_width(max_ff(curpressure * thickness, 1.0f));
280   immBeginAtMost(GPU_PRIM_LINE_STRIP, totpoints + cyclic_add);
281   const bGPDspoint *pt = points;
282   for (int i = 0; i < totpoints; i++, pt++) {
283     /* If there was a significant pressure change, stop the curve,
284      * change the thickness of the stroke, and continue drawing again
285      * (since line-width cannot change in middle of GL_LINE_STRIP)
286      * Note: we want more visible levels of pressures when thickness is bigger.
287      */
288     if (fabsf(pt->pressure - curpressure) > 0.2f / (float)thickness) {
289       /* if the pressure changes before get at least 2 vertices,
290        * need to repeat last point to avoid assert in immEnd() */
291       if (draw_points < 2) {
292         const bGPDspoint *pt2 = pt - 1;
293         immVertex3fv(pos, &pt2->x);
294       }
295       immEnd();
296       draw_points = 0;
297
298       curpressure = pt->pressure;
299       GPU_line_width(max_ff(curpressure * thickness, 1.0f));
300       immBeginAtMost(GPU_PRIM_LINE_STRIP, totpoints - i + 1 + cyclic_add);
301
302       /* need to roll-back one point to ensure that there are no gaps in the stroke */
303       if (i != 0) {
304         const bGPDspoint *pt2 = pt - 1;
305         immVertex3fv(pos, &pt2->x);
306         draw_points++;
307       }
308     }
309
310     /* now the point we want */
311     immVertex3fv(pos, &pt->x);
312     draw_points++;
313
314     if (cyclic && i == 0) {
315       /* save first point to use in cyclic */
316       copy_v3_v3(cyclic_fpt, &pt->x);
317     }
318   }
319
320   if (cyclic) {
321     /* draw line to first point to complete the cycle */
322     immVertex3fv(pos, cyclic_fpt);
323     draw_points++;
324   }
325
326   /* if less of two points, need to repeat last point to avoid assert in immEnd() */
327   if (draw_points < 2) {
328     const bGPDspoint *pt2 = pt - 1;
329     immVertex3fv(pos, &pt2->x);
330   }
331
332   immEnd();
333   immUnbindProgram();
334 }
335
336 /* ----- Fancy 2D-Stroke Drawing ------ */
337
338 /* draw a given stroke in 2d */
339 static void gp_draw_stroke_2d(const bGPDspoint *points,
340                               int totpoints,
341                               short thickness_s,
342                               short dflag,
343                               short sflag,
344                               int offsx,
345                               int offsy,
346                               int winx,
347                               int winy,
348                               const float ink[4])
349 {
350   /* otherwise thickness is twice that of the 3D view */
351   float thickness = (float)thickness_s * 0.5f;
352
353   /* strokes in Image Editor need a scale factor, since units there are not pixels! */
354   float scalefac = 1.0f;
355   if ((dflag & GP_DRAWDATA_IEDITHACK) && (dflag & GP_DRAWDATA_ONLYV2D)) {
356     scalefac = 0.001f;
357   }
358
359   /* Tessellation code - draw stroke as series of connected quads
360    * (triangle strips in fact) with connection edges rotated to minimize shrinking artifacts,
361    * and rounded endcaps.
362    */
363   {
364     const bGPDspoint *pt1, *pt2;
365     float s0[2], s1[2]; /* segment 'center' points */
366     float pm[2];        /* normal from previous segment. */
367     int i;
368
369     GPUVertFormat *format = immVertexFormat();
370     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
371
372     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
373     immUniformColor3fvAlpha(ink, ink[3]);
374     immBegin(GPU_PRIM_TRI_STRIP, totpoints * 2 + 4);
375
376     /* get x and y coordinates from first point */
377     gp_calc_2d_stroke_fxy(&points->x, sflag, offsx, offsy, winx, winy, s0);
378
379     for (i = 0, pt1 = points, pt2 = points + 1; i < (totpoints - 1); i++, pt1++, pt2++) {
380       float t0[2], t1[2]; /* tessellated coordinates */
381       float m1[2], m2[2]; /* gradient and normal */
382       float mt[2], sc[2]; /* gradient for thickness, point for end-cap */
383       float pthick;       /* thickness at segment point */
384
385       /* Get x and y coordinates from point2
386        * (point1 has already been computed in previous iteration). */
387       gp_calc_2d_stroke_fxy(&pt2->x, sflag, offsx, offsy, winx, winy, s1);
388
389       /* calculate gradient and normal - 'angle'=(ny/nx) */
390       m1[1] = s1[1] - s0[1];
391       m1[0] = s1[0] - s0[0];
392       normalize_v2(m1);
393       m2[1] = -m1[0];
394       m2[0] = m1[1];
395
396       /* always use pressure from first point here */
397       pthick = (pt1->pressure * thickness * scalefac);
398
399       /* if the first segment, start of segment is segment's normal */
400       if (i == 0) {
401         /* draw start cap first
402          * - make points slightly closer to center (about halfway across)
403          */
404         mt[0] = m2[0] * pthick * 0.5f;
405         mt[1] = m2[1] * pthick * 0.5f;
406         sc[0] = s0[0] - (m1[0] * pthick * 0.75f);
407         sc[1] = s0[1] - (m1[1] * pthick * 0.75f);
408
409         t0[0] = sc[0] - mt[0];
410         t0[1] = sc[1] - mt[1];
411         t1[0] = sc[0] + mt[0];
412         t1[1] = sc[1] + mt[1];
413
414         /* First two points of cap. */
415         immVertex2fv(pos, t0);
416         immVertex2fv(pos, t1);
417
418         /* calculate points for start of segment */
419         mt[0] = m2[0] * pthick;
420         mt[1] = m2[1] * pthick;
421
422         t0[0] = s0[0] - mt[0];
423         t0[1] = s0[1] - mt[1];
424         t1[0] = s0[0] + mt[0];
425         t1[1] = s0[1] + mt[1];
426
427         /* Last two points of start cap (and first two points of first segment). */
428         immVertex2fv(pos, t0);
429         immVertex2fv(pos, t1);
430       }
431       /* if not the first segment, use bisector of angle between segments */
432       else {
433         float mb[2];        /* bisector normal */
434         float athick, dfac; /* actual thickness, difference between thicknesses */
435
436         /* calculate gradient of bisector (as average of normals) */
437         mb[0] = (pm[0] + m2[0]) / 2;
438         mb[1] = (pm[1] + m2[1]) / 2;
439         normalize_v2(mb);
440
441         /* calculate gradient to apply
442          *  - as basis, use just pthick * bisector gradient
443          * - if cross-section not as thick as it should be, add extra padding to fix it
444          */
445         mt[0] = mb[0] * pthick;
446         mt[1] = mb[1] * pthick;
447         athick = len_v2(mt);
448         dfac = pthick - (athick * 2);
449
450         if (((athick * 2.0f) < pthick) && (IS_EQF(athick, pthick) == 0)) {
451           mt[0] += (mb[0] * dfac);
452           mt[1] += (mb[1] * dfac);
453         }
454
455         /* calculate points for start of segment */
456         t0[0] = s0[0] - mt[0];
457         t0[1] = s0[1] - mt[1];
458         t1[0] = s0[0] + mt[0];
459         t1[1] = s0[1] + mt[1];
460
461         /* Last two points of previous segment, and first two points of current segment. */
462         immVertex2fv(pos, t0);
463         immVertex2fv(pos, t1);
464       }
465
466       /* if last segment, also draw end of segment (defined as segment's normal) */
467       if (i == totpoints - 2) {
468         /* for once, we use second point's pressure (otherwise it won't be drawn) */
469         pthick = (pt2->pressure * thickness * scalefac);
470
471         /* calculate points for end of segment */
472         mt[0] = m2[0] * pthick;
473         mt[1] = m2[1] * pthick;
474
475         t0[0] = s1[0] - mt[0];
476         t0[1] = s1[1] - mt[1];
477         t1[0] = s1[0] + mt[0];
478         t1[1] = s1[1] + mt[1];
479
480         /* Last two points of last segment (and first two points of end cap). */
481         immVertex2fv(pos, t0);
482         immVertex2fv(pos, t1);
483
484         /* draw end cap as last step
485          * - make points slightly closer to center (about halfway across)
486          */
487         mt[0] = m2[0] * pthick * 0.5f;
488         mt[1] = m2[1] * pthick * 0.5f;
489         sc[0] = s1[0] + (m1[0] * pthick * 0.75f);
490         sc[1] = s1[1] + (m1[1] * pthick * 0.75f);
491
492         t0[0] = sc[0] - mt[0];
493         t0[1] = sc[1] - mt[1];
494         t1[0] = sc[0] + mt[0];
495         t1[1] = sc[1] + mt[1];
496
497         /* Last two points of end cap. */
498         immVertex2fv(pos, t0);
499         immVertex2fv(pos, t1);
500       }
501
502       /* store computed point2 coordinates as point1 ones of next segment. */
503       copy_v2_v2(s0, s1);
504       /* store stroke's 'natural' normal for next stroke to use */
505       copy_v2_v2(pm, m2);
506     }
507
508     immEnd();
509     immUnbindProgram();
510   }
511 }
512
513 /* ----- Strokes Drawing ------ */
514
515 /* Helper for doing all the checks on whether a stroke can be drawn */
516 static bool gp_can_draw_stroke(const bGPDstroke *gps, const int dflag)
517 {
518   /* skip stroke if it isn't in the right display space for this drawing context */
519   /* 1) 3D Strokes */
520   if ((dflag & GP_DRAWDATA_ONLY3D) && !(gps->flag & GP_STROKE_3DSPACE)) {
521     return false;
522   }
523   if (!(dflag & GP_DRAWDATA_ONLY3D) && (gps->flag & GP_STROKE_3DSPACE)) {
524     return false;
525   }
526
527   /* 2) Screen Space 2D Strokes */
528   if ((dflag & GP_DRAWDATA_ONLYV2D) && !(gps->flag & GP_STROKE_2DSPACE)) {
529     return false;
530   }
531   if (!(dflag & GP_DRAWDATA_ONLYV2D) && (gps->flag & GP_STROKE_2DSPACE)) {
532     return false;
533   }
534
535   /* 3) Image Space (2D) */
536   if ((dflag & GP_DRAWDATA_ONLYI2D) && !(gps->flag & GP_STROKE_2DIMAGE)) {
537     return false;
538   }
539   if (!(dflag & GP_DRAWDATA_ONLYI2D) && (gps->flag & GP_STROKE_2DIMAGE)) {
540     return false;
541   }
542
543   /* skip stroke if it doesn't have any valid data */
544   if ((gps->points == NULL) || (gps->totpoints < 1)) {
545     return false;
546   }
547
548   /* stroke can be drawn */
549   return true;
550 }
551
552 /* draw a set of strokes */
553 static void gp_draw_strokes(bGPdata *UNUSED(gpd),
554                             bGPDlayer *UNUSED(gpl),
555                             const bGPDframe *gpf,
556                             int offsx,
557                             int offsy,
558                             int winx,
559                             int winy,
560                             int dflag,
561                             short lthick,
562                             const float color[4])
563 {
564   GPU_enable_program_point_size();
565
566   for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
567     /* check if stroke can be drawn */
568     if (gp_can_draw_stroke(gps, dflag) == false) {
569       continue;
570     }
571
572     /* check which stroke-drawer to use */
573     if (dflag & GP_DRAWDATA_ONLY3D) {
574       const int no_xray = (dflag & GP_DRAWDATA_NO_XRAY);
575       int mask_orig = 0;
576
577       if (no_xray) {
578         glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig);
579         glDepthMask(0);
580         GPU_depth_test(true);
581
582         /* first arg is normally rv3d->dist, but this isn't
583          * available here and seems to work quite well without */
584         bglPolygonOffset(1.0f, 1.0f);
585       }
586
587       /* 3D Lines - OpenGL primitives-based */
588       if (gps->totpoints == 1) {
589         gp_draw_stroke_point(
590             gps->points, lthick, dflag, gps->flag, offsx, offsy, winx, winy, color);
591       }
592       else {
593         gp_draw_stroke_3d(
594             gps->points, gps->totpoints, lthick, gps->flag, color, gps->flag & GP_STROKE_CYCLIC);
595       }
596
597       if (no_xray) {
598         glDepthMask(mask_orig);
599         GPU_depth_test(false);
600
601         bglPolygonOffset(0.0, 0.0);
602       }
603     }
604     else {
605       /* 2D Strokes... */
606       if (gps->totpoints == 1) {
607         gp_draw_stroke_point(
608             gps->points, lthick, dflag, gps->flag, offsx, offsy, winx, winy, color);
609       }
610       else {
611         gp_draw_stroke_2d(gps->points,
612                           gps->totpoints,
613                           lthick,
614                           dflag,
615                           gps->flag,
616                           offsx,
617                           offsy,
618                           winx,
619                           winy,
620                           color);
621       }
622     }
623   }
624
625   GPU_disable_program_point_size();
626 }
627
628 /* Draw selected verts for strokes being edited */
629 static void gp_draw_strokes_edit(bGPdata *gpd,
630                                  bGPDlayer *gpl,
631                                  const bGPDframe *gpf,
632                                  int offsx,
633                                  int offsy,
634                                  int winx,
635                                  int winy,
636                                  short dflag,
637                                  short UNUSED(lflag),
638                                  float alpha)
639 {
640   /* if alpha 0 do not draw */
641   if (alpha == 0.0f) {
642     return;
643   }
644
645   const bool no_xray = (dflag & GP_DRAWDATA_NO_XRAY) != 0;
646   int mask_orig = 0;
647
648   /* set up depth masks... */
649   if (dflag & GP_DRAWDATA_ONLY3D) {
650     if (no_xray) {
651       glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig);
652       glDepthMask(0);
653       GPU_depth_test(true);
654
655       /* first arg is normally rv3d->dist, but this isn't
656        * available here and seems to work quite well without */
657       bglPolygonOffset(1.0f, 1.0f);
658     }
659   }
660
661   GPU_enable_program_point_size();
662
663   /* draw stroke verts */
664   for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
665     /* check if stroke can be drawn */
666     if (gp_can_draw_stroke(gps, dflag) == false) {
667       continue;
668     }
669
670     /* Optimisation: only draw points for selected strokes
671      * We assume that selected points can only occur in
672      * strokes that are selected too.
673      */
674     if ((gps->flag & GP_STROKE_SELECT) == 0) {
675       continue;
676     }
677
678     /* Get size of verts:
679      * - The selected state needs to be larger than the unselected state so that
680      *   they stand out more.
681      * - We use the theme setting for size of the unselected verts
682      */
683     float bsize = UI_GetThemeValuef(TH_GP_VERTEX_SIZE);
684     float vsize;
685     if ((int)bsize > 8) {
686       vsize = 10.0f;
687       bsize = 8.0f;
688     }
689     else {
690       vsize = bsize + 2;
691     }
692
693     float selectColor[4];
694     UI_GetThemeColor3fv(TH_GP_VERTEX_SELECT, selectColor);
695     selectColor[3] = alpha;
696
697     GPUVertFormat *format = immVertexFormat();
698     uint pos; /* specified later */
699     uint size = GPU_vertformat_attr_add(format, "size", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
700     uint color = GPU_vertformat_attr_add(format, "color", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
701
702     if (gps->flag & GP_STROKE_3DSPACE) {
703       pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
704       immBindBuiltinProgram(GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR);
705     }
706     else {
707       pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
708       immBindBuiltinProgram(GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR);
709     }
710
711     immBegin(GPU_PRIM_POINTS, gps->totpoints);
712
713     /* Draw start and end point differently if enabled stroke direction hint */
714     bool show_direction_hint = (gpd->flag & GP_DATA_SHOW_DIRECTION) && (gps->totpoints > 1);
715
716     /* Draw all the stroke points (selected or not) */
717     bGPDspoint *pt = gps->points;
718     for (int i = 0; i < gps->totpoints; i++, pt++) {
719       /* size and color first */
720       if (show_direction_hint && i == 0) {
721         /* start point in green bigger */
722         immAttr3f(color, 0.0f, 1.0f, 0.0f);
723         immAttr1f(size, vsize + 4);
724       }
725       else if (show_direction_hint && (i == gps->totpoints - 1)) {
726         /* end point in red smaller */
727         immAttr3f(color, 1.0f, 0.0f, 0.0f);
728         immAttr1f(size, vsize + 1);
729       }
730       else if (pt->flag & GP_SPOINT_SELECT) {
731         immAttr3fv(color, selectColor);
732         immAttr1f(size, vsize);
733       }
734       else {
735         immAttr3fv(color, gpl->color);
736         immAttr1f(size, bsize);
737       }
738
739       /* then position */
740       if (gps->flag & GP_STROKE_3DSPACE) {
741         immVertex3fv(pos, &pt->x);
742       }
743       else {
744         float co[2];
745         gp_calc_2d_stroke_fxy(&pt->x, gps->flag, offsx, offsy, winx, winy, co);
746         immVertex2fv(pos, co);
747       }
748     }
749
750     immEnd();
751     immUnbindProgram();
752   }
753
754   GPU_disable_program_point_size();
755
756   /* clear depth mask */
757   if (dflag & GP_DRAWDATA_ONLY3D) {
758     if (no_xray) {
759       glDepthMask(mask_orig);
760       GPU_depth_test(false);
761
762       bglPolygonOffset(0.0, 0.0);
763 #if 0
764       glDisable(GL_POLYGON_OFFSET_LINE);
765       glPolygonOffset(0, 0);
766 #endif
767     }
768   }
769 }
770
771 /* ----- General Drawing ------ */
772 /* draw onion-skinning for a layer */
773 static void gp_draw_onionskins(bGPdata *gpd,
774                                bGPDlayer *gpl,
775                                bGPDframe *gpf,
776                                int offsx,
777                                int offsy,
778                                int winx,
779                                int winy,
780                                int UNUSED(cfra),
781                                int dflag)
782 {
783   const float alpha = 1.0f;
784   float color[4];
785
786   /* 1) Draw Previous Frames First */
787   copy_v3_v3(color, gpl->gcolor_prev);
788
789   if (gpl->gstep > 0) {
790     bGPDframe *gf;
791     float fac;
792
793     /* draw previous frames first */
794     for (gf = gpf->prev; gf; gf = gf->prev) {
795       /* check if frame is drawable */
796       if ((gpf->framenum - gf->framenum) <= gpl->gstep) {
797         /* alpha decreases with distance from curframe index */
798         fac = 1.0f - ((float)(gpf->framenum - gf->framenum) / (float)(gpl->gstep + 1));
799         color[3] = alpha * fac * 0.66f;
800         gp_draw_strokes(gpd, gpl, gf, offsx, offsy, winx, winy, dflag, gpl->thickness, color);
801       }
802       else {
803         break;
804       }
805     }
806   }
807   else if (gpl->gstep == 0) {
808     /* draw the strokes for the ghost frames (at half of the alpha set by user) */
809     if (gpf->prev) {
810       color[3] = (alpha / 7);
811       gp_draw_strokes(gpd, gpl, gpf->prev, offsx, offsy, winx, winy, dflag, gpl->thickness, color);
812     }
813   }
814   else {
815     /* don't draw - disabled */
816   }
817
818   /* 2) Now draw next frames */
819   copy_v3_v3(color, gpl->gcolor_next);
820
821   if (gpl->gstep_next > 0) {
822     bGPDframe *gf;
823     float fac;
824
825     /* now draw next frames */
826     for (gf = gpf->next; gf; gf = gf->next) {
827       /* check if frame is drawable */
828       if ((gf->framenum - gpf->framenum) <= gpl->gstep_next) {
829         /* alpha decreases with distance from curframe index */
830         fac = 1.0f - ((float)(gf->framenum - gpf->framenum) / (float)(gpl->gstep_next + 1));
831         color[3] = alpha * fac * 0.66f;
832         gp_draw_strokes(gpd, gpl, gf, offsx, offsy, winx, winy, dflag, gpl->thickness, color);
833       }
834       else {
835         break;
836       }
837     }
838   }
839   else if (gpl->gstep_next == 0) {
840     /* draw the strokes for the ghost frames (at half of the alpha set by user) */
841     if (gpf->next) {
842       color[3] = (alpha / 4);
843       gp_draw_strokes(gpd, gpl, gpf->next, offsx, offsy, winx, winy, dflag, gpl->thickness, color);
844     }
845   }
846   else {
847     /* don't draw - disabled */
848   }
849 }
850
851 /* loop over gpencil data layers, drawing them */
852 static void gp_draw_data_layers(
853     bGPdata *gpd, int offsx, int offsy, int winx, int winy, int cfra, int dflag, float alpha)
854 {
855   float ink[4];
856
857   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
858     /* verify never thickness is less than 1 */
859     CLAMP_MIN(gpl->thickness, 1.0f);
860     short lthick = gpl->thickness;
861
862     /* apply layer opacity */
863     copy_v3_v3(ink, gpl->color);
864     ink[3] = gpl->opacity;
865
866     /* don't draw layer if hidden */
867     if (gpl->flag & GP_LAYER_HIDE) {
868       continue;
869     }
870
871     /* get frame to draw */
872     bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, cfra, GP_GETFRAME_USE_PREV);
873     if (gpf == NULL) {
874       continue;
875     }
876
877     /* set basic stroke thickness */
878     GPU_line_width(lthick);
879
880     /* Add layer drawing settings to the set of "draw flags"
881      * NOTE: If the setting doesn't apply, it *must* be cleared,
882      *       as dflag's carry over from the previous layer
883      */
884
885     /* xray... */
886     SET_FLAG_FROM_TEST(dflag, gpl->flag & GP_LAYER_NO_XRAY, GP_DRAWDATA_NO_XRAY);
887
888     /* Draw 'onionskins' (frame left + right) */
889     if (gpl->onion_flag & GP_LAYER_ONIONSKIN) {
890       gp_draw_onionskins(gpd, gpl, gpf, offsx, offsy, winx, winy, cfra, dflag);
891     }
892
893     /* draw the strokes already in active frame */
894     gp_draw_strokes(gpd, gpl, gpf, offsx, offsy, winx, winy, dflag, lthick, ink);
895
896     /* Draw verts of selected strokes
897      *  - when doing OpenGL renders, we don't want to be showing these, as that ends up flickering
898      *  - locked layers can't be edited, so there's no point showing these verts
899      *    as they will have no bearings on what gets edited
900      *  - only show when in editmode, since operators shouldn't work otherwise
901      *    (NOTE: doing it this way means that the toggling editmode shows visible change immediately)
902      */
903     /* XXX: perhaps we don't want to show these when users are drawing... */
904     if ((G.f & G_FLAG_RENDER_VIEWPORT) == 0 && (gpl->flag & GP_LAYER_LOCKED) == 0 &&
905         (gpd->flag & GP_DATA_STROKE_EDITMODE)) {
906       gp_draw_strokes_edit(gpd, gpl, gpf, offsx, offsy, winx, winy, dflag, gpl->flag, alpha);
907     }
908
909     /* Check if may need to draw the active stroke cache, only if this layer is the active layer
910      * that is being edited. (Stroke buffer is currently stored in gp-data)
911      */
912     if (ED_gpencil_session_active() && (gpl->flag & GP_LAYER_ACTIVE) &&
913         (gpf->flag & GP_FRAME_PAINT)) {
914       /* Buffer stroke needs to be drawn with a different linestyle
915        * to help differentiate them from normal strokes.
916        *
917        * It should also be noted that sbuffer contains temporary point types
918        * i.e. tGPspoints NOT bGPDspoints
919        */
920       gp_draw_stroke_buffer(gpd->runtime.sbuffer,
921                             gpd->runtime.sbuffer_size,
922                             lthick,
923                             dflag,
924                             gpd->runtime.sbuffer_sflag,
925                             ink);
926     }
927   }
928 }
929
930 /* draw a short status message in the top-right corner */
931 static void gp_draw_status_text(const bGPdata *gpd, ARegion *ar)
932 {
933   rcti rect;
934
935   /* Cannot draw any status text when drawing OpenGL Renders */
936   if (G.f & G_FLAG_RENDER_VIEWPORT) {
937     return;
938   }
939
940   /* Get bounds of region - Necessary to avoid problems with region overlap */
941   ED_region_visible_rect(ar, &rect);
942
943   /* for now, this should only be used to indicate when we are in stroke editmode */
944   if (gpd->flag & GP_DATA_STROKE_EDITMODE) {
945     const char *printable = IFACE_("GPencil Stroke Editing");
946     float printable_size[2];
947
948     int font_id = BLF_default();
949
950     BLF_width_and_height(
951         font_id, printable, BLF_DRAW_STR_DUMMY_MAX, &printable_size[0], &printable_size[1]);
952
953     int xco = (rect.xmax - U.widget_unit) - (int)printable_size[0];
954     int yco = (rect.ymax - U.widget_unit);
955
956     /* text label */
957     UI_FontThemeColor(font_id, TH_TEXT_HI);
958 #ifdef WITH_INTERNATIONAL
959     BLF_draw_default(xco, yco, 0.0f, printable, BLF_DRAW_STR_DUMMY_MAX);
960 #else
961     BLF_draw_default_ascii(xco, yco, 0.0f, printable, BLF_DRAW_STR_DUMMY_MAX);
962 #endif
963
964     /* grease pencil icon... */
965     // XXX: is this too intrusive?
966     GPU_blend_set_func_separate(
967         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
968     GPU_blend(true);
969
970     xco -= U.widget_unit;
971     yco -= (int)printable_size[1] / 2;
972
973     UI_icon_draw(xco, yco, ICON_GREASEPENCIL);
974
975     GPU_blend(false);
976   }
977 }
978
979 /* draw grease-pencil datablock */
980 static void gp_draw_data(
981     bGPdata *gpd, int offsx, int offsy, int winx, int winy, int cfra, int dflag, float alpha)
982 {
983   /* turn on smooth lines (i.e. anti-aliasing) */
984   GPU_line_smooth(true);
985
986   /* turn on alpha-blending */
987   GPU_blend_set_func_separate(
988       GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
989   GPU_blend(true);
990
991   /* draw! */
992   gp_draw_data_layers(gpd, offsx, offsy, winx, winy, cfra, dflag, alpha);
993
994   /* turn off alpha blending, then smooth lines */
995   GPU_blend(false);        // alpha blending
996   GPU_line_smooth(false);  // smooth lines
997 }
998
999 /* if we have strokes for scenes (3d view)/clips (movie clip editor)
1000  * and objects/tracks, multiple data blocks have to be drawn */
1001 static void gp_draw_data_all(Scene *scene,
1002                              bGPdata *gpd,
1003                              int offsx,
1004                              int offsy,
1005                              int winx,
1006                              int winy,
1007                              int cfra,
1008                              int dflag,
1009                              const char spacetype)
1010 {
1011   bGPdata *gpd_source = NULL;
1012   float alpha = 1.0f;
1013
1014   if (scene) {
1015     if (spacetype == SPACE_VIEW3D) {
1016       gpd_source = (scene->gpd ? scene->gpd : NULL);
1017     }
1018     else if (spacetype == SPACE_CLIP && scene->clip) {
1019       /* currently drawing only gpencil data from either clip or track,
1020        * but not both - XXX fix logic behind */
1021       gpd_source = (scene->clip->gpd ? scene->clip->gpd : NULL);
1022     }
1023
1024     if (gpd_source) {
1025       gp_draw_data(gpd_source, offsx, offsy, winx, winy, cfra, dflag, alpha);
1026     }
1027   }
1028
1029   /* scene/clip data has already been drawn, only object/track data is drawn here
1030    * if gpd_source == gpd, we don't have any object/track data and we can skip */
1031   if (gpd_source == NULL || (gpd_source && gpd_source != gpd)) {
1032     gp_draw_data(gpd, offsx, offsy, winx, winy, cfra, dflag, alpha);
1033   }
1034 }
1035
1036 /* ----- Grease Pencil Sketches Drawing API ------ */
1037
1038 /* ............................
1039  * XXX
1040  * We need to review the calls below, since they may be/are not that suitable for
1041  * the new ways that we intend to be drawing data...
1042  * ............................ */
1043
1044 /* draw grease-pencil sketches to specified 2d-view that uses ibuf corrections */
1045 void ED_annotation_draw_2dimage(const bContext *C)
1046 {
1047   wmWindowManager *wm = CTX_wm_manager(C);
1048   ScrArea *sa = CTX_wm_area(C);
1049   ARegion *ar = CTX_wm_region(C);
1050   Scene *scene = CTX_data_scene(C);
1051
1052   int offsx, offsy, sizex, sizey;
1053   int dflag = GP_DRAWDATA_NOSTATUS;
1054
1055   bGPdata *gpd = ED_gpencil_data_get_active(C);  // XXX
1056   if (gpd == NULL) {
1057     return;
1058   }
1059
1060   /* calculate rect */
1061   switch (sa->spacetype) {
1062     case SPACE_IMAGE: /* image */
1063     case SPACE_CLIP:  /* clip */
1064     {
1065       /* just draw using standard scaling (settings here are currently ignored anyways) */
1066       /* FIXME: the opengl poly-strokes don't draw at right thickness when done this way,
1067        * so disabled. */
1068       offsx = 0;
1069       offsy = 0;
1070       sizex = ar->winx;
1071       sizey = ar->winy;
1072
1073       wmOrtho2(ar->v2d.cur.xmin, ar->v2d.cur.xmax, ar->v2d.cur.ymin, ar->v2d.cur.ymax);
1074
1075       dflag |= GP_DRAWDATA_ONLYV2D | GP_DRAWDATA_IEDITHACK;
1076       break;
1077     }
1078     case SPACE_SEQ: /* sequence */
1079     {
1080       /* just draw using standard scaling (settings here are currently ignored anyways) */
1081       offsx = 0;
1082       offsy = 0;
1083       sizex = ar->winx;
1084       sizey = ar->winy;
1085
1086       /* NOTE: I2D was used in 2.4x, but the old settings for that have been deprecated
1087        * and everything moved to standard View2d
1088        */
1089       dflag |= GP_DRAWDATA_ONLYV2D;
1090       break;
1091     }
1092     default: /* for spacetype not yet handled */
1093       offsx = 0;
1094       offsy = 0;
1095       sizex = ar->winx;
1096       sizey = ar->winy;
1097
1098       dflag |= GP_DRAWDATA_ONLYI2D;
1099       break;
1100   }
1101
1102   if (ED_screen_animation_playing(wm)) {
1103     /* Don't show onion-skins during animation playback/scrub (i.e. it obscures the poses)
1104      * OpenGL Renders (i.e. final output), or depth buffer (i.e. not real strokes). */
1105     dflag |= GP_DRAWDATA_NO_ONIONS;
1106   }
1107
1108   /* draw it! */
1109   gp_draw_data_all(scene, gpd, offsx, offsy, sizex, sizey, CFRA, dflag, sa->spacetype);
1110 }
1111
1112 /* draw grease-pencil sketches to specified 2d-view assuming that matrices are already set correctly
1113  * Note: this gets called twice - first time with onlyv2d=true to draw 'canvas' strokes,
1114  * second time with onlyv2d=false for screen-aligned strokes */
1115 void ED_annotation_draw_view2d(const bContext *C, bool onlyv2d)
1116 {
1117   wmWindowManager *wm = CTX_wm_manager(C);
1118   ScrArea *sa = CTX_wm_area(C);
1119   ARegion *ar = CTX_wm_region(C);
1120   Scene *scene = CTX_data_scene(C);
1121   int dflag = 0;
1122
1123   /* check that we have grease-pencil stuff to draw */
1124   if (sa == NULL) {
1125     return;
1126   }
1127   bGPdata *gpd = ED_gpencil_data_get_active(C);  // XXX
1128   if (gpd == NULL) {
1129     return;
1130   }
1131
1132   /* special hack for Image Editor */
1133   /* FIXME: the opengl poly-strokes don't draw at right thickness when done this way, so disabled */
1134   if (ELEM(sa->spacetype, SPACE_IMAGE, SPACE_CLIP)) {
1135     dflag |= GP_DRAWDATA_IEDITHACK;
1136   }
1137
1138   /* draw it! */
1139   if (onlyv2d) {
1140     dflag |= (GP_DRAWDATA_ONLYV2D | GP_DRAWDATA_NOSTATUS);
1141   }
1142   if (ED_screen_animation_playing(wm)) {
1143     dflag |= GP_DRAWDATA_NO_ONIONS;
1144   }
1145
1146   gp_draw_data_all(scene, gpd, 0, 0, ar->winx, ar->winy, CFRA, dflag, sa->spacetype);
1147
1148   /* draw status text (if in screen/pixel-space) */
1149   if (!onlyv2d) {
1150     gp_draw_status_text(gpd, ar);
1151   }
1152 }
1153
1154 /* draw annotations sketches to specified 3d-view assuming that matrices are already set correctly
1155  * Note: this gets called twice - first time with only3d=true to draw 3d-strokes,
1156  * second time with only3d=false for screen-aligned strokes */
1157 void ED_annotation_draw_view3d(
1158     Scene *scene, struct Depsgraph *depsgraph, View3D *v3d, ARegion *ar, bool only3d)
1159 {
1160   int dflag = 0;
1161   RegionView3D *rv3d = ar->regiondata;
1162   int offsx, offsy, winx, winy;
1163
1164   /* check that we have grease-pencil stuff to draw */
1165   /* XXX: Hardcoded reference here may get out of sync if we change how we fetch annotation data */
1166   bGPdata *gpd = scene->gpd;
1167   if (gpd == NULL) {
1168     return;
1169   }
1170
1171   /* when rendering to the offscreen buffer we don't want to
1172    * deal with the camera border, otherwise map the coords to the camera border. */
1173   if ((rv3d->persp == RV3D_CAMOB) && !(G.f & G_FLAG_RENDER_VIEWPORT)) {
1174     rctf rectf;
1175     ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &rectf, true); /* no shift */
1176
1177     offsx = round_fl_to_int(rectf.xmin);
1178     offsy = round_fl_to_int(rectf.ymin);
1179     winx = round_fl_to_int(rectf.xmax - rectf.xmin);
1180     winy = round_fl_to_int(rectf.ymax - rectf.ymin);
1181   }
1182   else {
1183     offsx = 0;
1184     offsy = 0;
1185     winx = ar->winx;
1186     winy = ar->winy;
1187   }
1188
1189   /* set flags */
1190   if (only3d) {
1191     /* 3D strokes/3D space:
1192      * - only 3D space points
1193      * - don't status text either (as it's the wrong space)
1194      */
1195     dflag |= (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_NOSTATUS);
1196   }
1197
1198   if (v3d->flag2 & V3D_HIDE_OVERLAYS) {
1199     /* don't draw status text when "only render" flag is set */
1200     dflag |= GP_DRAWDATA_NOSTATUS;
1201   }
1202
1203   /* draw it! */
1204   gp_draw_data_all(scene, gpd, offsx, offsy, winx, winy, CFRA, dflag, v3d->spacetype);
1205 }
1206
1207 void ED_annotation_draw_ex(
1208     Scene *scene, bGPdata *gpd, int winx, int winy, const int cfra, const char spacetype)
1209 {
1210   int dflag = GP_DRAWDATA_NOSTATUS | GP_DRAWDATA_ONLYV2D;
1211
1212   gp_draw_data_all(scene, gpd, 0, 0, winx, winy, cfra, dflag, spacetype);
1213 }
1214
1215 /* ************************************************** */