GPencil: Rename property Follow Drawing Path to Alignment
[blender.git] / source / blender / draw / engines / gpencil / gpencil_draw_utils.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  * Copyright 2017, Blender Foundation.
17  */
18
19 /** \file
20  * \ingroup draw
21  */
22
23 #include "BLI_polyfill_2d.h"
24
25 #include "DRW_render.h"
26
27 #include "BKE_gpencil.h"
28 #include "BKE_gpencil_modifier.h"
29 #include "BKE_image.h"
30 #include "BKE_material.h"
31 #include "BKE_paint.h"
32
33 #include "BLI_hash.h"
34
35 #include "ED_gpencil.h"
36
37 #include "DNA_gpencil_types.h"
38 #include "DNA_material_types.h"
39 #include "DNA_view3d_types.h"
40 #include "DNA_gpencil_modifier_types.h"
41
42 /* If builtin shaders are needed */
43 #include "GPU_shader.h"
44 #include "GPU_texture.h"
45
46 /* For EvaluationContext... */
47 #include "DEG_depsgraph.h"
48 #include "DEG_depsgraph_query.h"
49
50 #include "IMB_imbuf_types.h"
51
52 #include "gpencil_engine.h"
53
54 #include "UI_resources.h"
55
56 /* fill type to communicate to shader */
57 #define SOLID 0
58 #define GRADIENT 1
59 #define RADIAL 2
60 #define CHESS 3
61 #define TEXTURE 4
62 #define PATTERN 5
63
64 #define GP_SET_SRC_GPS(src_gps) \
65   if (src_gps) \
66   src_gps = src_gps->next
67
68 /* Get number of vertex for using in GPU VBOs */
69 static void gpencil_calc_vertex(GPENCIL_StorageList *stl,
70                                 tGPencilObjectCache *cache_ob,
71                                 GpencilBatchCache *cache,
72                                 bGPdata *gpd,
73                                 int cfra_eval)
74 {
75   if (!cache->is_dirty) {
76     return;
77   }
78
79   Object *ob = cache_ob->ob;
80   const DRWContextState *draw_ctx = DRW_context_state_get();
81   const bool main_onion = draw_ctx->v3d != NULL ?
82                               (draw_ctx->v3d->gp_flag & V3D_GP_SHOW_ONION_SKIN) :
83                               true;
84   const bool playing = stl->storage->is_playing;
85   const bool overlay = draw_ctx->v3d != NULL ?
86                            (bool)((draw_ctx->v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) :
87                            true;
88   const bool do_onion = (bool)((gpd->flag & GP_DATA_STROKE_WEIGHTMODE) == 0) && overlay &&
89                         main_onion && DRW_gpencil_onion_active(gpd) && !playing;
90
91   const bool time_remap = BKE_gpencil_has_time_modifiers(ob);
92   const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
93
94   cache_ob->tot_vertex = 0;
95   cache_ob->tot_triangles = 0;
96
97   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
98     bGPDframe *init_gpf = NULL;
99     const bool is_onion = ((do_onion) && (gpl->onion_flag & GP_LAYER_ONIONSKIN));
100     if (gpl->flag & GP_LAYER_HIDE) {
101       continue;
102     }
103
104     /* if multiedit or onion skin need to count all frames of the layer */
105     if ((is_multiedit) || (is_onion)) {
106       init_gpf = gpl->frames.first;
107     }
108     else {
109       /* verify time modifiers */
110       if ((time_remap) && (!stl->storage->simplify_modif)) {
111         int remap_cfra = BKE_gpencil_time_modifier(
112             draw_ctx->depsgraph, draw_ctx->scene, ob, gpl, cfra_eval, stl->storage->is_render);
113         init_gpf = BKE_gpencil_layer_getframe(gpl, remap_cfra, GP_GETFRAME_USE_PREV);
114       }
115       else {
116         init_gpf = gpl->actframe;
117       }
118     }
119
120     if (init_gpf == NULL) {
121       continue;
122     }
123
124     for (bGPDframe *gpf = init_gpf; gpf; gpf = gpf->next) {
125       for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
126         cache_ob->tot_vertex += gps->totpoints + 3;
127         cache_ob->tot_triangles += gps->totpoints - 1;
128       }
129       if ((!is_multiedit) && (!is_onion)) {
130         break;
131       }
132     }
133   }
134
135   cache->b_fill.tot_vertex = cache_ob->tot_triangles * 3;
136   cache->b_stroke.tot_vertex = cache_ob->tot_vertex;
137   cache->b_point.tot_vertex = cache_ob->tot_vertex;
138   cache->b_edit.tot_vertex = cache_ob->tot_vertex;
139   cache->b_edlin.tot_vertex = cache_ob->tot_vertex;
140
141   /* some modifiers can change the number of points */
142   int factor = 0;
143   GpencilModifierData *md;
144   for (md = ob->greasepencil_modifiers.first; md; md = md->next) {
145     const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
146     /* only modifiers that change size */
147     if (mti && mti->getDuplicationFactor) {
148       factor = mti->getDuplicationFactor(md);
149
150       cache->b_fill.tot_vertex *= factor;
151       cache->b_stroke.tot_vertex *= factor;
152       cache->b_point.tot_vertex *= factor;
153       cache->b_edit.tot_vertex *= factor;
154       cache->b_edlin.tot_vertex *= factor;
155     }
156   }
157 }
158
159 /* Helper for doing all the checks on whether a stroke can be drawn */
160 static bool gpencil_can_draw_stroke(struct MaterialGPencilStyle *gp_style,
161                                     const bGPDstroke *gps,
162                                     const bool onion,
163                                     const bool is_mat_preview)
164 {
165   /* skip stroke if it doesn't have any valid data */
166   if ((gps->points == NULL) || (gps->totpoints < 1) || (gp_style == NULL)) {
167     return false;
168   }
169
170   /* if mat preview render always visible */
171   if (is_mat_preview) {
172     return true;
173   }
174
175   /* check if the color is visible */
176   if ((gp_style == NULL) || (gp_style->flag & GP_STYLE_COLOR_HIDE) ||
177       (onion && (gp_style->flag & GP_STYLE_COLOR_ONIONSKIN))) {
178     return false;
179   }
180
181   /* stroke can be drawn */
182   return true;
183 }
184
185 /* calc bounding box in 2d using flat projection data */
186 static void gpencil_calc_2d_bounding_box(const float (*points2d)[2],
187                                          int totpoints,
188                                          float minv[2],
189                                          float maxv[2])
190 {
191   minv[0] = points2d[0][0];
192   minv[1] = points2d[0][1];
193   maxv[0] = points2d[0][0];
194   maxv[1] = points2d[0][1];
195
196   for (int i = 1; i < totpoints; i++) {
197     /* min */
198     if (points2d[i][0] < minv[0]) {
199       minv[0] = points2d[i][0];
200     }
201     if (points2d[i][1] < minv[1]) {
202       minv[1] = points2d[i][1];
203     }
204     /* max */
205     if (points2d[i][0] > maxv[0]) {
206       maxv[0] = points2d[i][0];
207     }
208     if (points2d[i][1] > maxv[1]) {
209       maxv[1] = points2d[i][1];
210     }
211   }
212   /* use a perfect square */
213   if (maxv[0] > maxv[1]) {
214     maxv[1] = maxv[0];
215   }
216   else {
217     maxv[0] = maxv[1];
218   }
219 }
220
221 /* calc texture coordinates using flat projected points */
222 static void gpencil_calc_stroke_fill_uv(
223     const float (*points2d)[2], int totpoints, float minv[2], float maxv[2], float (*r_uv)[2])
224 {
225   float d[2];
226   d[0] = maxv[0] - minv[0];
227   d[1] = maxv[1] - minv[1];
228   for (int i = 0; i < totpoints; i++) {
229     r_uv[i][0] = (points2d[i][0] - minv[0]) / d[0];
230     r_uv[i][1] = (points2d[i][1] - minv[1]) / d[1];
231   }
232 }
233
234 /* recalc the internal geometry caches for fill and uvs */
235 static void DRW_gpencil_recalc_geometry_caches(Object *ob,
236                                                bGPDlayer *gpl,
237                                                MaterialGPencilStyle *gp_style,
238                                                bGPDstroke *gps)
239 {
240   if (gps->flag & GP_STROKE_RECALC_GEOMETRY) {
241     /* Calculate triangles cache for filling area (must be done only after changes) */
242     if ((gps->tot_triangles == 0) || (gps->triangles == NULL)) {
243       if ((gps->totpoints > 2) &&
244           ((gp_style->fill_rgba[3] > GPENCIL_ALPHA_OPACITY_THRESH) || (gp_style->fill_style > 0) ||
245            (gpl->blend_mode != eGplBlendMode_Normal))) {
246         DRW_gpencil_triangulate_stroke_fill(ob, gps);
247       }
248     }
249
250     /* calc uv data along the stroke */
251     ED_gpencil_calc_stroke_uv(ob, gps);
252
253     /* clear flag */
254     gps->flag &= ~GP_STROKE_RECALC_GEOMETRY;
255   }
256 }
257
258 static void set_wireframe_color(Object *ob,
259                                 bGPDlayer *gpl,
260                                 View3D *v3d,
261                                 GPENCIL_StorageList *stl,
262                                 MaterialGPencilStyle *gp_style,
263                                 int id,
264                                 const bool is_fill)
265 {
266   const DRWContextState *draw_ctx = DRW_context_state_get();
267   World *world = draw_ctx->scene->world;
268
269   float color[4];
270   if (((gp_style->stroke_rgba[3] < GPENCIL_ALPHA_OPACITY_THRESH) ||
271        (((gp_style->flag & GP_STYLE_STROKE_SHOW) == 0))) &&
272       (gp_style->fill_rgba[3] >= GPENCIL_ALPHA_OPACITY_THRESH)) {
273     copy_v4_v4(color, gp_style->fill_rgba);
274   }
275   else {
276     copy_v4_v4(color, gp_style->stroke_rgba);
277   }
278   float alpha = color[3];
279
280   /* wire color */
281   if ((v3d) && (id > -1)) {
282     const char type = ((stl->shgroups[id].shading_type[0] == OB_WIRE) ?
283                            v3d->shading.wire_color_type :
284                            v3d->shading.color_type);
285     /* if fill and wire, use background color */
286     if ((is_fill) && (stl->shgroups[id].shading_type[0] == OB_WIRE)) {
287       if (v3d->shading.background_type == V3D_SHADING_BACKGROUND_THEME) {
288         UI_GetThemeColor4fv(TH_BACK, stl->shgroups[id].wire_color);
289         stl->shgroups[id].wire_color[3] = 1.0f;
290       }
291       else if (v3d->shading.background_type == V3D_SHADING_BACKGROUND_WORLD) {
292         color[0] = world->horr;
293         color[1] = world->horg;
294         color[2] = world->horb;
295         color[3] = 1.0f;
296         linearrgb_to_srgb_v4(stl->shgroups[id].wire_color, color);
297       }
298       else {
299         copy_v3_v3(color, v3d->shading.background_color);
300         color[3] = 1.0f;
301         linearrgb_to_srgb_v4(stl->shgroups[id].wire_color, color);
302       }
303       return;
304     }
305
306     /* strokes */
307     switch (type) {
308       case V3D_SHADING_SINGLE_COLOR: {
309         if (stl->shgroups[id].shading_type[0] == OB_WIRE) {
310           UI_GetThemeColor4fv(TH_WIRE, color);
311         }
312         else {
313           copy_v3_v3(color, v3d->shading.single_color);
314         }
315         color[3] = alpha;
316         linearrgb_to_srgb_v4(stl->shgroups[id].wire_color, color);
317         break;
318       }
319       case V3D_SHADING_OBJECT_COLOR: {
320         copy_v4_v4(color, ob->color);
321         color[3] = alpha;
322         linearrgb_to_srgb_v4(stl->shgroups[id].wire_color, color);
323         break;
324       }
325       case V3D_SHADING_RANDOM_COLOR: {
326         uint gpl_hash = 1;
327         uint ob_hash = BLI_ghashutil_strhash_p_murmur(ob->id.name);
328         if (gpl) {
329           gpl_hash = BLI_ghashutil_strhash_p_murmur(gpl->info);
330         }
331
332         float hue = BLI_hash_int_01(ob_hash * gpl_hash);
333         float hsv[3] = {hue, 0.40f, 0.8f};
334         float wire_col[3];
335         hsv_to_rgb_v(hsv, &wire_col[0]);
336
337         stl->shgroups[id].wire_color[0] = wire_col[0];
338         stl->shgroups[id].wire_color[1] = wire_col[1];
339         stl->shgroups[id].wire_color[2] = wire_col[2];
340         stl->shgroups[id].wire_color[3] = alpha;
341         break;
342       }
343       default: {
344         copy_v4_v4(stl->shgroups[id].wire_color, color);
345         break;
346       }
347     }
348   }
349   else {
350     copy_v4_v4(stl->shgroups[id].wire_color, color);
351   }
352
353   /* if solid, the alpha must be set to 1.0 */
354   if (stl->shgroups[id].shading_type[0] == OB_SOLID) {
355     stl->shgroups[id].wire_color[3] = 1.0f;
356   }
357 }
358
359 /* create shading group for filling */
360 static DRWShadingGroup *DRW_gpencil_shgroup_fill_create(GPENCIL_e_data *e_data,
361                                                         GPENCIL_Data *vedata,
362                                                         DRWPass *pass,
363                                                         GPUShader *shader,
364                                                         Object *ob,
365                                                         bGPdata *gpd,
366                                                         bGPDlayer *gpl,
367                                                         MaterialGPencilStyle *gp_style,
368                                                         int id,
369                                                         int shading_type[2])
370 {
371   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
372   const DRWContextState *draw_ctx = DRW_context_state_get();
373   View3D *v3d = draw_ctx->v3d;
374
375   /* e_data.gpencil_fill_sh */
376   DRWShadingGroup *grp = DRW_shgroup_create(shader, pass);
377
378   DRW_shgroup_uniform_vec4(grp, "color2", gp_style->mix_rgba, 1);
379
380   /* set style type */
381   switch (gp_style->fill_style) {
382     case GP_STYLE_FILL_STYLE_SOLID:
383       stl->shgroups[id].fill_style = SOLID;
384       break;
385     case GP_STYLE_FILL_STYLE_GRADIENT:
386       if (gp_style->gradient_type == GP_STYLE_GRADIENT_LINEAR) {
387         stl->shgroups[id].fill_style = GRADIENT;
388       }
389       else {
390         stl->shgroups[id].fill_style = RADIAL;
391       }
392       break;
393     case GP_STYLE_FILL_STYLE_CHESSBOARD:
394       stl->shgroups[id].fill_style = CHESS;
395       break;
396     case GP_STYLE_FILL_STYLE_TEXTURE:
397       if (gp_style->flag & GP_STYLE_FILL_PATTERN) {
398         stl->shgroups[id].fill_style = PATTERN;
399       }
400       else {
401         stl->shgroups[id].fill_style = TEXTURE;
402       }
403       break;
404     default:
405       stl->shgroups[id].fill_style = GP_STYLE_FILL_STYLE_SOLID;
406       break;
407   }
408   DRW_shgroup_uniform_int(grp, "fill_type", &stl->shgroups[id].fill_style, 1);
409
410   DRW_shgroup_uniform_float(grp, "mix_factor", &gp_style->mix_factor, 1);
411
412   DRW_shgroup_uniform_float(grp, "gradient_angle", &gp_style->gradient_angle, 1);
413   DRW_shgroup_uniform_float(grp, "gradient_radius", &gp_style->gradient_radius, 1);
414   DRW_shgroup_uniform_float(grp, "pattern_gridsize", &gp_style->pattern_gridsize, 1);
415   DRW_shgroup_uniform_vec2(grp, "gradient_scale", gp_style->gradient_scale, 1);
416   DRW_shgroup_uniform_vec2(grp, "gradient_shift", gp_style->gradient_shift, 1);
417
418   DRW_shgroup_uniform_float(grp, "texture_angle", &gp_style->texture_angle, 1);
419   DRW_shgroup_uniform_vec2(grp, "texture_scale", gp_style->texture_scale, 1);
420   DRW_shgroup_uniform_vec2(grp, "texture_offset", gp_style->texture_offset, 1);
421   DRW_shgroup_uniform_float(grp, "texture_opacity", &gp_style->texture_opacity, 1);
422   DRW_shgroup_uniform_float(grp, "layer_opacity", &gpl->opacity, 1);
423
424   stl->shgroups[id].texture_mix = gp_style->flag & GP_STYLE_FILL_TEX_MIX ? 1 : 0;
425   DRW_shgroup_uniform_int(grp, "texture_mix", &stl->shgroups[id].texture_mix, 1);
426
427   stl->shgroups[id].texture_flip = gp_style->flag & GP_STYLE_COLOR_FLIP_FILL ? 1 : 0;
428   DRW_shgroup_uniform_int(grp, "texture_flip", &stl->shgroups[id].texture_flip, 1);
429
430   stl->shgroups[id].xray_mode = (ob->dtx & OB_DRAWXRAY) ? GP_XRAY_FRONT : GP_XRAY_3DSPACE;
431   DRW_shgroup_uniform_int(grp, "xraymode", &stl->shgroups[id].xray_mode, 1);
432   DRW_shgroup_uniform_int(grp, "drawmode", (const int *)&gpd->draw_mode, 1);
433
434   /* viewport x-ray */
435   stl->shgroups[id].is_xray = (ob->dt == OB_WIRE) ? 1 : stl->storage->is_xray;
436   DRW_shgroup_uniform_int(grp, "viewport_xray", (const int *)&stl->shgroups[id].is_xray, 1);
437
438   /* shading type */
439   stl->shgroups[id].shading_type[0] = GPENCIL_USE_SOLID(stl) ? (int)OB_RENDER : shading_type[0];
440   if (v3d) {
441     stl->shgroups[id].shading_type[1] = ((stl->shgroups[id].shading_type[0] == OB_WIRE) ?
442                                              v3d->shading.wire_color_type :
443                                              v3d->shading.color_type);
444   }
445
446   DRW_shgroup_uniform_int(grp, "shading_type", &stl->shgroups[id].shading_type[0], 2);
447
448   /* wire color */
449   set_wireframe_color(ob, gpl, v3d, stl, gp_style, id, true);
450   DRW_shgroup_uniform_vec4(grp, "wire_color", stl->shgroups[id].wire_color, 1);
451
452   /* image texture */
453   if ((gp_style->flag & GP_STYLE_FILL_TEX_MIX) ||
454       (gp_style->fill_style & GP_STYLE_FILL_STYLE_TEXTURE)) {
455     ImBuf *ibuf;
456     Image *image = gp_style->ima;
457     ImageUser iuser = {NULL};
458     void *lock;
459
460     iuser.ok = true;
461
462     ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
463
464     if (ibuf == NULL || ibuf->rect == NULL) {
465       BKE_image_release_ibuf(image, ibuf, NULL);
466     }
467     else {
468       GPUTexture *texture = GPU_texture_from_blender(gp_style->ima, &iuser, GL_TEXTURE_2D);
469       DRW_shgroup_uniform_texture(grp, "myTexture", texture);
470
471       stl->shgroups[id].texture_clamp = gp_style->flag & GP_STYLE_COLOR_TEX_CLAMP ? 1 : 0;
472       DRW_shgroup_uniform_int(grp, "texture_clamp", &stl->shgroups[id].texture_clamp, 1);
473
474       BKE_image_release_ibuf(image, ibuf, NULL);
475     }
476   }
477   else {
478     /* if no texture defined, need a blank texture to avoid errors in draw manager */
479     DRW_shgroup_uniform_texture(grp, "myTexture", e_data->gpencil_blank_texture);
480     stl->shgroups[id].texture_clamp = 0;
481     DRW_shgroup_uniform_int(grp, "texture_clamp", &stl->shgroups[id].texture_clamp, 1);
482   }
483
484   return grp;
485 }
486
487 /* check if some onion is enabled */
488 bool DRW_gpencil_onion_active(bGPdata *gpd)
489 {
490   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
491     if (gpl->onion_flag & GP_LAYER_ONIONSKIN) {
492       return true;
493     }
494   }
495   return false;
496 }
497
498 /* create shading group for strokes */
499 DRWShadingGroup *DRW_gpencil_shgroup_stroke_create(GPENCIL_e_data *e_data,
500                                                    GPENCIL_Data *vedata,
501                                                    DRWPass *pass,
502                                                    GPUShader *shader,
503                                                    Object *ob,
504                                                    bGPdata *gpd,
505                                                    bGPDlayer *gpl,
506                                                    bGPDstroke *gps,
507                                                    MaterialGPencilStyle *gp_style,
508                                                    int id,
509                                                    bool onion,
510                                                    const float scale,
511                                                    const int shading_type[2])
512 {
513   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
514   const float *viewport_size = DRW_viewport_size_get();
515   const DRWContextState *draw_ctx = DRW_context_state_get();
516   View3D *v3d = draw_ctx->v3d;
517
518   /* e_data.gpencil_stroke_sh */
519   DRWShadingGroup *grp = DRW_shgroup_create(shader, pass);
520
521   DRW_shgroup_uniform_vec2(grp, "Viewport", viewport_size, 1);
522
523   DRW_shgroup_uniform_float(grp, "pixsize", stl->storage->pixsize, 1);
524
525   /* avoid wrong values */
526   if ((gpd) && (gpd->pixfactor == 0.0f)) {
527     gpd->pixfactor = GP_DEFAULT_PIX_FACTOR;
528   }
529
530   /* object scale and depth */
531   if ((ob) && (id > -1)) {
532     stl->shgroups[id].obj_scale = scale;
533     DRW_shgroup_uniform_float(grp, "objscale", &stl->shgroups[id].obj_scale, 1);
534     stl->shgroups[id].keep_size = (int)((gpd) && (gpd->flag & GP_DATA_STROKE_KEEPTHICKNESS));
535     DRW_shgroup_uniform_int(grp, "keep_size", &stl->shgroups[id].keep_size, 1);
536
537     stl->shgroups[id].stroke_style = gp_style->stroke_style;
538     stl->shgroups[id].color_type = GPENCIL_COLOR_SOLID;
539     if ((gp_style->stroke_style == GP_STYLE_STROKE_STYLE_TEXTURE) && (!onion)) {
540       stl->shgroups[id].color_type = GPENCIL_COLOR_TEXTURE;
541       if (gp_style->flag & GP_STYLE_STROKE_PATTERN) {
542         stl->shgroups[id].color_type = GPENCIL_COLOR_PATTERN;
543       }
544     }
545     DRW_shgroup_uniform_int(grp, "color_type", &stl->shgroups[id].color_type, 1);
546     DRW_shgroup_uniform_float(grp, "pixfactor", &gpd->pixfactor, 1);
547
548     stl->shgroups[id].caps_mode[0] = gps->caps[0];
549     stl->shgroups[id].caps_mode[1] = gps->caps[1];
550     DRW_shgroup_uniform_int(grp, "caps_mode", &stl->shgroups[id].caps_mode[0], 2);
551
552     stl->shgroups[id].gradient_f = gps->gradient_f;
553     copy_v2_v2(stl->shgroups[id].gradient_s, gps->gradient_s);
554     DRW_shgroup_uniform_float(grp, "gradient_f", &stl->shgroups[id].gradient_f, 1);
555
556     /* viewport x-ray */
557     stl->shgroups[id].is_xray = (ob->dt == OB_WIRE) ? 1 : stl->storage->is_xray;
558     DRW_shgroup_uniform_int(grp, "viewport_xray", (const int *)&stl->shgroups[id].is_xray, 1);
559
560     stl->shgroups[id].shading_type[0] = (GPENCIL_USE_SOLID(stl) || onion) ? (int)OB_RENDER :
561                                                                             shading_type[0];
562     if (v3d) {
563       stl->shgroups[id].shading_type[1] = ((stl->shgroups[id].shading_type[0] == OB_WIRE) ?
564                                                v3d->shading.wire_color_type :
565                                                v3d->shading.color_type);
566     }
567     DRW_shgroup_uniform_int(grp, "shading_type", &stl->shgroups[id].shading_type[0], 2);
568
569     /* wire color */
570     set_wireframe_color(ob, gpl, v3d, stl, gp_style, id, false);
571     DRW_shgroup_uniform_vec4(grp, "wire_color", stl->shgroups[id].wire_color, 1);
572
573     /* mix stroke factor */
574     stl->shgroups[id].mix_stroke_factor = (gp_style->flag & GP_STYLE_STROKE_TEX_MIX) ?
575                                               gp_style->mix_stroke_factor :
576                                               0.0f;
577     DRW_shgroup_uniform_float(grp, "mix_stroke_factor", &stl->shgroups[id].mix_stroke_factor, 1);
578   }
579   else {
580     stl->storage->obj_scale = 1.0f;
581     stl->storage->keep_size = 0;
582     stl->storage->pixfactor = GP_DEFAULT_PIX_FACTOR;
583     DRW_shgroup_uniform_float(grp, "objscale", &stl->storage->obj_scale, 1);
584     DRW_shgroup_uniform_int(grp, "keep_size", &stl->storage->keep_size, 1);
585     DRW_shgroup_uniform_int(grp, "color_type", &stl->storage->color_type, 1);
586     if (gpd) {
587       DRW_shgroup_uniform_float(grp, "pixfactor", &gpd->pixfactor, 1);
588     }
589     else {
590       DRW_shgroup_uniform_float(grp, "pixfactor", &stl->storage->pixfactor, 1);
591     }
592     const int zero[2] = {0, 0};
593     DRW_shgroup_uniform_int(grp, "caps_mode", &zero[0], 2);
594
595     DRW_shgroup_uniform_float(grp, "gradient_f", &stl->storage->gradient_f, 1);
596
597     /* viewport x-ray */
598     DRW_shgroup_uniform_int(grp, "viewport_xray", &stl->storage->is_xray, 1);
599     DRW_shgroup_uniform_int(grp, "shading_type", (const int *)&stl->storage->shade_render, 2);
600
601     /* mix stroke factor */
602     stl->storage->mix_stroke_factor = (gp_style->flag & GP_STYLE_STROKE_TEX_MIX) ?
603                                           gp_style->mix_stroke_factor :
604                                           0.0f;
605     DRW_shgroup_uniform_float(grp, "mix_stroke_factor", &stl->storage->mix_stroke_factor, 1);
606   }
607
608   DRW_shgroup_uniform_vec4(grp, "colormix", gp_style->stroke_rgba, 1);
609
610   if ((gpd) && (id > -1)) {
611     stl->shgroups[id].xray_mode = (ob->dtx & OB_DRAWXRAY) ? GP_XRAY_FRONT : GP_XRAY_3DSPACE;
612     DRW_shgroup_uniform_int(grp, "xraymode", &stl->shgroups[id].xray_mode, 1);
613   }
614   else {
615     /* for drawing always on predefined z-depth */
616     DRW_shgroup_uniform_int(grp, "xraymode", &stl->storage->xray, 1);
617   }
618
619   /* image texture for pattern */
620   if ((gp_style) && (gp_style->stroke_style == GP_STYLE_STROKE_STYLE_TEXTURE) && (!onion)) {
621     ImBuf *ibuf;
622     Image *image = gp_style->sima;
623     ImageUser iuser = {NULL};
624     void *lock;
625
626     iuser.ok = true;
627
628     ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
629
630     if (ibuf == NULL || ibuf->rect == NULL) {
631       BKE_image_release_ibuf(image, ibuf, NULL);
632     }
633     else {
634       GPUTexture *texture = GPU_texture_from_blender(gp_style->sima, &iuser, GL_TEXTURE_2D);
635       DRW_shgroup_uniform_texture(grp, "myTexture", texture);
636
637       BKE_image_release_ibuf(image, ibuf, NULL);
638     }
639   }
640   else {
641     /* if no texture defined, need a blank texture to avoid errors in draw manager */
642     DRW_shgroup_uniform_texture(grp, "myTexture", e_data->gpencil_blank_texture);
643   }
644
645   return grp;
646 }
647
648 /* create shading group for points */
649 static DRWShadingGroup *DRW_gpencil_shgroup_point_create(GPENCIL_e_data *e_data,
650                                                          GPENCIL_Data *vedata,
651                                                          DRWPass *pass,
652                                                          GPUShader *shader,
653                                                          Object *ob,
654                                                          bGPdata *gpd,
655                                                          bGPDlayer *gpl,
656                                                          bGPDstroke *gps,
657                                                          MaterialGPencilStyle *gp_style,
658                                                          int id,
659                                                          bool onion,
660                                                          const float scale,
661                                                          const int shading_type[2])
662 {
663   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
664   const float *viewport_size = DRW_viewport_size_get();
665   const DRWContextState *draw_ctx = DRW_context_state_get();
666   View3D *v3d = draw_ctx->v3d;
667
668   /* e_data.gpencil_stroke_sh */
669   DRWShadingGroup *grp = DRW_shgroup_create(shader, pass);
670
671   DRW_shgroup_uniform_vec2(grp, "Viewport", viewport_size, 1);
672   DRW_shgroup_uniform_float(grp, "pixsize", stl->storage->pixsize, 1);
673
674   /* avoid wrong values */
675   if ((gpd) && (gpd->pixfactor == 0.0f)) {
676     gpd->pixfactor = GP_DEFAULT_PIX_FACTOR;
677   }
678
679   /* object scale and depth */
680   if ((ob) && (id > -1)) {
681     stl->shgroups[id].obj_scale = scale;
682     DRW_shgroup_uniform_float(grp, "objscale", &stl->shgroups[id].obj_scale, 1);
683     stl->shgroups[id].keep_size = (int)((gpd) && (gpd->flag & GP_DATA_STROKE_KEEPTHICKNESS));
684     DRW_shgroup_uniform_int(grp, "keep_size", &stl->shgroups[id].keep_size, 1);
685
686     stl->shgroups[id].mode = gp_style->mode;
687     stl->shgroups[id].stroke_style = gp_style->stroke_style;
688     stl->shgroups[id].color_type = GPENCIL_COLOR_SOLID;
689     if ((gp_style->stroke_style == GP_STYLE_STROKE_STYLE_TEXTURE) && (!onion)) {
690       stl->shgroups[id].color_type = GPENCIL_COLOR_TEXTURE;
691       if (gp_style->flag & GP_STYLE_STROKE_PATTERN) {
692         stl->shgroups[id].color_type = GPENCIL_COLOR_PATTERN;
693       }
694     }
695     DRW_shgroup_uniform_int(grp, "color_type", &stl->shgroups[id].color_type, 1);
696     DRW_shgroup_uniform_int(grp, "mode", &stl->shgroups[id].mode, 1);
697     DRW_shgroup_uniform_float(grp, "pixfactor", &gpd->pixfactor, 1);
698
699     stl->shgroups[id].gradient_f = gps->gradient_f;
700     copy_v2_v2(stl->shgroups[id].gradient_s, gps->gradient_s);
701     DRW_shgroup_uniform_float(grp, "gradient_f", &stl->shgroups[id].gradient_f, 1);
702     DRW_shgroup_uniform_vec2(grp, "gradient_s", stl->shgroups[id].gradient_s, 1);
703
704     /* viewport x-ray */
705     stl->shgroups[id].is_xray = (ob->dt == OB_WIRE) ? 1 : stl->storage->is_xray;
706     DRW_shgroup_uniform_int(grp, "viewport_xray", (const int *)&stl->shgroups[id].is_xray, 1);
707
708     stl->shgroups[id].shading_type[0] = (GPENCIL_USE_SOLID(stl) || onion) ? (int)OB_RENDER :
709                                                                             shading_type[0];
710     if (v3d) {
711       stl->shgroups[id].shading_type[1] = ((stl->shgroups[id].shading_type[0] == OB_WIRE) ?
712                                                v3d->shading.wire_color_type :
713                                                v3d->shading.color_type);
714     }
715     DRW_shgroup_uniform_int(grp, "shading_type", &stl->shgroups[id].shading_type[0], 2);
716
717     /* wire color */
718     set_wireframe_color(ob, gpl, v3d, stl, gp_style, id, false);
719     DRW_shgroup_uniform_vec4(grp, "wire_color", stl->shgroups[id].wire_color, 1);
720
721     /* mix stroke factor */
722     stl->shgroups[id].mix_stroke_factor = (gp_style->flag & GP_STYLE_STROKE_TEX_MIX) ?
723                                               gp_style->mix_stroke_factor :
724                                               0.0f;
725     DRW_shgroup_uniform_float(grp, "mix_stroke_factor", &stl->shgroups[id].mix_stroke_factor, 1);
726
727     /* lock rotation of dots and boxes */
728     stl->shgroups[id].alignment_mode = gp_style->alignment_mode;
729     DRW_shgroup_uniform_int(grp, "alignment_mode", &stl->shgroups[id].alignment_mode, 1);
730   }
731   else {
732     stl->storage->obj_scale = 1.0f;
733     stl->storage->keep_size = 0;
734     stl->storage->pixfactor = GP_DEFAULT_PIX_FACTOR;
735     stl->storage->mode = gp_style->mode;
736     DRW_shgroup_uniform_float(grp, "objscale", &stl->storage->obj_scale, 1);
737     DRW_shgroup_uniform_int(grp, "keep_size", &stl->storage->keep_size, 1);
738     DRW_shgroup_uniform_int(grp, "color_type", &stl->storage->color_type, 1);
739     DRW_shgroup_uniform_int(grp, "mode", &stl->storage->mode, 1);
740     if (gpd) {
741       DRW_shgroup_uniform_float(grp, "pixfactor", &gpd->pixfactor, 1);
742     }
743     else {
744       DRW_shgroup_uniform_float(grp, "pixfactor", &stl->storage->pixfactor, 1);
745     }
746
747     DRW_shgroup_uniform_float(grp, "gradient_f", &stl->storage->gradient_f, 1);
748     DRW_shgroup_uniform_vec2(grp, "gradient_s", stl->storage->gradient_s, 1);
749
750     /* viewport x-ray */
751     DRW_shgroup_uniform_int(grp, "viewport_xray", &stl->storage->is_xray, 1);
752     DRW_shgroup_uniform_int(grp, "shading_type", (const int *)&stl->storage->shade_render, 2);
753
754     /* mix stroke factor */
755     stl->storage->mix_stroke_factor = (gp_style->flag & GP_STYLE_STROKE_TEX_MIX) ?
756                                           gp_style->mix_stroke_factor :
757                                           0.0f;
758     DRW_shgroup_uniform_float(grp, "mix_stroke_factor", &stl->storage->mix_stroke_factor, 1);
759
760     /* lock rotation of dots and boxes */
761     DRW_shgroup_uniform_int(grp, "alignment_mode", &stl->storage->alignment_mode, 1);
762   }
763
764   DRW_shgroup_uniform_vec4(grp, "colormix", gp_style->stroke_rgba, 1);
765
766   if ((gpd) && (id > -1)) {
767     stl->shgroups[id].xray_mode = (ob->dtx & OB_DRAWXRAY) ? GP_XRAY_FRONT : GP_XRAY_3DSPACE;
768     DRW_shgroup_uniform_int(grp, "xraymode", (const int *)&stl->shgroups[id].xray_mode, 1);
769   }
770   else {
771     /* for drawing always on predefined z-depth */
772     DRW_shgroup_uniform_int(grp, "xraymode", &stl->storage->xray, 1);
773   }
774
775   /* image texture */
776   if ((gp_style) && (gp_style->stroke_style == GP_STYLE_STROKE_STYLE_TEXTURE) && (!onion)) {
777     ImBuf *ibuf;
778     Image *image = gp_style->sima;
779     ImageUser iuser = {NULL};
780     void *lock;
781
782     iuser.ok = true;
783
784     ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
785
786     if (ibuf == NULL || ibuf->rect == NULL) {
787       BKE_image_release_ibuf(image, ibuf, NULL);
788     }
789     else {
790       GPUTexture *texture = GPU_texture_from_blender(gp_style->sima, &iuser, GL_TEXTURE_2D);
791       DRW_shgroup_uniform_texture(grp, "myTexture", texture);
792
793       BKE_image_release_ibuf(image, ibuf, NULL);
794     }
795   }
796   else {
797     /* if no texture defined, need a blank texture to avoid errors in draw manager */
798     DRW_shgroup_uniform_texture(grp, "myTexture", e_data->gpencil_blank_texture);
799   }
800
801   return grp;
802 }
803
804 /* add fill vertex info  */
805 static void gpencil_add_fill_vertexdata(GpencilBatchCache *cache,
806                                         Object *ob,
807                                         bGPDlayer *gpl,
808                                         bGPDframe *gpf,
809                                         bGPDstroke *gps,
810                                         float opacity,
811                                         const float tintcolor[4],
812                                         const bool onion,
813                                         const bool custonion)
814 {
815   MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
816   if (gps->totpoints >= 3) {
817     float tfill[4];
818     /* set color using material, tint color and opacity */
819     interp_v3_v3v3(tfill, gps->runtime.tmp_fill_rgba, tintcolor, tintcolor[3]);
820     tfill[3] = gps->runtime.tmp_fill_rgba[3] * opacity;
821     if ((tfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) || (gp_style->fill_style > 0) ||
822         (gpl->blend_mode != eGplBlendMode_Normal)) {
823       if (cache->is_dirty) {
824         const float *color;
825         if (!onion) {
826           color = tfill;
827         }
828         else {
829           if (custonion) {
830             color = tintcolor;
831           }
832           else {
833             ARRAY_SET_ITEMS(tfill, UNPACK3(gps->runtime.tmp_fill_rgba), tintcolor[3]);
834             color = tfill;
835           }
836         }
837         /* create vertex data */
838         const int old_len = cache->b_fill.vbo_len;
839         DRW_gpencil_get_fill_geom(&cache->b_fill, ob, gps, color);
840
841         /* add to list of groups */
842         if (old_len < cache->b_fill.vbo_len) {
843           cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
844                                                      gpl,
845                                                      gpf,
846                                                      gps,
847                                                      eGpencilBatchGroupType_Fill,
848                                                      onion,
849                                                      cache->b_fill.vbo_len,
850                                                      &cache->grp_size,
851                                                      &cache->grp_used);
852         }
853       }
854     }
855   }
856 }
857
858 /* add stroke vertex info */
859 static void gpencil_add_stroke_vertexdata(GpencilBatchCache *cache,
860                                           Object *ob,
861                                           bGPDlayer *gpl,
862                                           bGPDframe *gpf,
863                                           bGPDstroke *gps,
864                                           const float opacity,
865                                           const float tintcolor[4],
866                                           const bool onion,
867                                           const bool custonion)
868 {
869   float tcolor[4];
870   float ink[4];
871   short sthickness;
872   MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
873   const int alignment_mode = (gp_style) ? gp_style->alignment_mode : GP_STYLE_FOLLOW_PATH;
874
875   /* set color using base color, tint color and opacity */
876   if (cache->is_dirty) {
877     if (!onion) {
878       /* if special stroke, use fill color as stroke color */
879       if (gps->flag & GP_STROKE_NOFILL) {
880         interp_v3_v3v3(tcolor, gps->runtime.tmp_fill_rgba, tintcolor, tintcolor[3]);
881         tcolor[3] = gps->runtime.tmp_fill_rgba[3] * opacity;
882       }
883       else {
884         interp_v3_v3v3(tcolor, gps->runtime.tmp_stroke_rgba, tintcolor, tintcolor[3]);
885         tcolor[3] = gps->runtime.tmp_stroke_rgba[3] * opacity;
886       }
887       copy_v4_v4(ink, tcolor);
888     }
889     else {
890       if (custonion) {
891         copy_v4_v4(ink, tintcolor);
892       }
893       else {
894         ARRAY_SET_ITEMS(tcolor, UNPACK3(gps->runtime.tmp_stroke_rgba), opacity);
895         copy_v4_v4(ink, tcolor);
896       }
897     }
898
899     sthickness = gps->thickness + gpl->line_change;
900     CLAMP_MIN(sthickness, 1);
901
902     if ((gps->totpoints > 1) && (gp_style->mode == GP_STYLE_MODE_LINE)) {
903       /* create vertex data */
904       const int old_len = cache->b_stroke.vbo_len;
905       DRW_gpencil_get_stroke_geom(&cache->b_stroke, gps, sthickness, ink);
906
907       /* add to list of groups */
908       if (old_len < cache->b_stroke.vbo_len) {
909         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
910                                                    gpl,
911                                                    gpf,
912                                                    gps,
913                                                    eGpencilBatchGroupType_Stroke,
914                                                    onion,
915                                                    cache->b_stroke.vbo_len,
916                                                    &cache->grp_size,
917                                                    &cache->grp_used);
918       }
919     }
920     else {
921       /* create vertex data */
922       const int old_len = cache->b_point.vbo_len;
923       DRW_gpencil_get_point_geom(&cache->b_point, gps, sthickness, ink, alignment_mode);
924
925       /* add to list of groups */
926       if (old_len < cache->b_point.vbo_len) {
927         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
928                                                    gpl,
929                                                    gpf,
930                                                    gps,
931                                                    eGpencilBatchGroupType_Point,
932                                                    onion,
933                                                    cache->b_point.vbo_len,
934                                                    &cache->grp_size,
935                                                    &cache->grp_used);
936       }
937     }
938   }
939 }
940
941 /* add edit points vertex info */
942 static void gpencil_add_editpoints_vertexdata(GpencilBatchCache *cache,
943                                               Object *ob,
944                                               bGPdata *gpd,
945                                               bGPDlayer *gpl,
946                                               bGPDframe *gpf,
947                                               bGPDstroke *gps)
948 {
949   const DRWContextState *draw_ctx = DRW_context_state_get();
950   View3D *v3d = draw_ctx->v3d;
951   MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
952
953   /* alpha factor for edit points/line to make them more subtle */
954   float edit_alpha = v3d->vertex_opacity;
955
956   if (GPENCIL_ANY_EDIT_MODE(gpd)) {
957     Object *obact = DRW_context_state_get()->obact;
958     if ((!obact) || (obact->type != OB_GPENCIL)) {
959       return;
960     }
961     const bool is_weight_paint = (gpd) && (gpd->flag & GP_DATA_STROKE_WEIGHTMODE);
962
963     if (cache->is_dirty) {
964       if ((obact == ob) && ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) &&
965           (v3d->gp_flag & V3D_GP_SHOW_EDIT_LINES)) {
966         /* line of the original stroke */
967         DRW_gpencil_get_edlin_geom(&cache->b_edlin, gps, edit_alpha, gpd->flag);
968
969         /* add to list of groups */
970         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
971                                                    gpl,
972                                                    gpf,
973                                                    gps,
974                                                    eGpencilBatchGroupType_Edlin,
975                                                    false,
976                                                    cache->b_edlin.vbo_len,
977                                                    &cache->grp_size,
978                                                    &cache->grp_used);
979       }
980       /* edit points */
981       if ((gps->flag & GP_STROKE_SELECT) || (is_weight_paint)) {
982         if ((gpl->flag & GP_LAYER_UNLOCK_COLOR) ||
983             ((gp_style->flag & GP_STYLE_COLOR_LOCKED) == 0)) {
984           if (obact == ob) {
985             DRW_gpencil_get_edit_geom(&cache->b_edit, gps, edit_alpha, gpd->flag);
986
987             /* add to list of groups */
988             cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
989                                                        gpl,
990                                                        gpf,
991                                                        gps,
992                                                        eGpencilBatchGroupType_Edit,
993                                                        false,
994                                                        cache->b_edit.vbo_len,
995                                                        &cache->grp_size,
996                                                        &cache->grp_used);
997           }
998         }
999       }
1000     }
1001   }
1002 }
1003
1004 /* main function to draw strokes */
1005 static void gpencil_draw_strokes(GpencilBatchCache *cache,
1006                                  GPENCIL_e_data *e_data,
1007                                  void *vedata,
1008                                  Object *ob,
1009                                  bGPdata *gpd,
1010                                  bGPDlayer *gpl,
1011                                  bGPDframe *src_gpf,
1012                                  bGPDframe *derived_gpf,
1013                                  const float opacity,
1014                                  const float tintcolor[4],
1015                                  const bool custonion,
1016                                  tGPencilObjectCache *cache_ob)
1017 {
1018   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1019   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1020   const DRWContextState *draw_ctx = DRW_context_state_get();
1021   Scene *scene = draw_ctx->scene;
1022   View3D *v3d = draw_ctx->v3d;
1023   bGPDstroke *gps, *src_gps;
1024   float viewmatrix[4][4];
1025   const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
1026   const bool playing = stl->storage->is_playing;
1027   const bool is_render = (bool)stl->storage->is_render;
1028   const bool is_mat_preview = (bool)stl->storage->is_mat_preview;
1029   const bool overlay_multiedit = v3d != NULL ? (v3d->gp_flag & V3D_GP_SHOW_MULTIEDIT_LINES) : true;
1030
1031   /* Get evaluation context */
1032   /* NOTE: We must check if C is valid, otherwise we get crashes when trying to save files
1033    * (i.e. the thumbnail offscreen rendering fails)
1034    */
1035   Depsgraph *depsgraph = DRW_context_state_get()->depsgraph;
1036
1037   /* get parent matrix and save as static data */
1038   ED_gpencil_parent_location(depsgraph, ob, gpd, gpl, viewmatrix);
1039   copy_m4_m4(derived_gpf->runtime.viewmatrix, viewmatrix);
1040
1041   if ((cache_ob != NULL) && (cache_ob->is_dup_ob)) {
1042     copy_m4_m4(derived_gpf->runtime.viewmatrix, cache_ob->obmat);
1043   }
1044
1045   /* apply geometry modifiers */
1046   if ((cache->is_dirty) && (ob->greasepencil_modifiers.first) && (!is_multiedit)) {
1047     if (!stl->storage->simplify_modif) {
1048       if (BKE_gpencil_has_geometry_modifiers(ob)) {
1049         BKE_gpencil_geometry_modifiers(depsgraph, ob, gpl, derived_gpf, stl->storage->is_render);
1050       }
1051     }
1052   }
1053
1054   if (src_gpf) {
1055     src_gps = src_gpf->strokes.first;
1056   }
1057   else {
1058     src_gps = NULL;
1059   }
1060
1061   for (gps = derived_gpf->strokes.first; gps; gps = gps->next) {
1062     MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1063
1064     /* check if stroke can be drawn */
1065     if (gpencil_can_draw_stroke(gp_style, gps, false, is_mat_preview) == false) {
1066       GP_SET_SRC_GPS(src_gps);
1067       continue;
1068     }
1069
1070     /* be sure recalc all cache in source stroke to avoid recalculation when frame change
1071      * and improve fps */
1072     if (src_gps) {
1073       DRW_gpencil_recalc_geometry_caches(ob, gpl, gp_style, src_gps);
1074     }
1075
1076     /* if the fill has any value, it's considered a fill and is not drawn if simplify fill is
1077      * enabled */
1078     if ((stl->storage->simplify_fill) &&
1079         (scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_REMOVE_FILL_LINE)) {
1080       if ((gp_style->fill_rgba[3] > GPENCIL_ALPHA_OPACITY_THRESH) ||
1081           (gp_style->fill_style > GP_STYLE_FILL_STYLE_SOLID) ||
1082           (gpl->blend_mode != eGplBlendMode_Normal)) {
1083         GP_SET_SRC_GPS(src_gps);
1084         continue;
1085       }
1086     }
1087
1088     if ((gpl->actframe->framenum == derived_gpf->framenum) || (!is_multiedit) ||
1089         (overlay_multiedit)) {
1090       /* copy color to temp fields to apply temporal changes in the stroke */
1091       copy_v4_v4(gps->runtime.tmp_stroke_rgba, gp_style->stroke_rgba);
1092       copy_v4_v4(gps->runtime.tmp_fill_rgba, gp_style->fill_rgba);
1093
1094       /* apply modifiers (only modify geometry, but not create ) */
1095       if ((cache->is_dirty) && (ob->greasepencil_modifiers.first) && (!is_multiedit)) {
1096         if (!stl->storage->simplify_modif) {
1097           BKE_gpencil_stroke_modifiers(
1098               depsgraph, ob, gpl, derived_gpf, gps, stl->storage->is_render);
1099         }
1100       }
1101
1102       /* hide any blend layer */
1103       if ((!stl->storage->simplify_blend) || (gpl->blend_mode == eGplBlendMode_Normal)) {
1104         /* fill */
1105         if ((gp_style->flag & GP_STYLE_FILL_SHOW) && (!stl->storage->simplify_fill) &&
1106             ((gps->flag & GP_STROKE_NOFILL) == 0)) {
1107           gpencil_add_fill_vertexdata(
1108               cache, ob, gpl, derived_gpf, gps, opacity, tintcolor, false, custonion);
1109         }
1110         /* stroke */
1111         /* No fill strokes, must show stroke always */
1112         if (((gp_style->flag & GP_STYLE_STROKE_SHOW) || (gps->flag & GP_STROKE_NOFILL)) &&
1113             ((gp_style->stroke_rgba[3] > GPENCIL_ALPHA_OPACITY_THRESH) ||
1114              (gpl->blend_mode == eGplBlendMode_Normal))) {
1115           /* recalc strokes uv (geometry can be changed by modifiers) */
1116           if (gps->flag & GP_STROKE_RECALC_GEOMETRY) {
1117             ED_gpencil_calc_stroke_uv(ob, gps);
1118           }
1119
1120           gpencil_add_stroke_vertexdata(
1121               cache, ob, gpl, derived_gpf, gps, opacity, tintcolor, false, custonion);
1122         }
1123       }
1124     }
1125
1126     /* edit points (only in edit mode and not play animation not render) */
1127     if ((draw_ctx->obact == ob) && (src_gps) && (!playing) && (!is_render) &&
1128         (!cache_ob->is_dup_ob)) {
1129       if ((gpl->flag & GP_LAYER_LOCKED) == 0) {
1130         if (!stl->g_data->shgrps_edit_line) {
1131           stl->g_data->shgrps_edit_line = DRW_shgroup_create(e_data->gpencil_line_sh,
1132                                                              psl->edit_pass);
1133         }
1134         if (!stl->g_data->shgrps_edit_point) {
1135           stl->g_data->shgrps_edit_point = DRW_shgroup_create(e_data->gpencil_edit_point_sh,
1136                                                               psl->edit_pass);
1137           const float *viewport_size = DRW_viewport_size_get();
1138           DRW_shgroup_uniform_vec2(stl->g_data->shgrps_edit_point, "Viewport", viewport_size, 1);
1139         }
1140
1141         gpencil_add_editpoints_vertexdata(cache, ob, gpd, gpl, derived_gpf, src_gps);
1142       }
1143     }
1144
1145     GP_SET_SRC_GPS(src_gps);
1146   }
1147 }
1148
1149 /* get alpha factor for onion strokes */
1150 static void gpencil_get_onion_alpha(float color[4], bGPdata *gpd)
1151 {
1152 #define MIN_ALPHA_VALUE 0.01f
1153
1154   /* if fade is disabled, opacity is equal in all frames */
1155   if ((gpd->onion_flag & GP_ONION_FADE) == 0) {
1156     color[3] = gpd->onion_factor;
1157   }
1158   else {
1159     /* add override opacity factor */
1160     color[3] += gpd->onion_factor - 0.5f;
1161   }
1162
1163   CLAMP(color[3], MIN_ALPHA_VALUE, 1.0f);
1164 }
1165
1166 /* function to draw strokes for onion only */
1167 static void gpencil_draw_onion_strokes(GpencilBatchCache *cache,
1168                                        void *vedata,
1169                                        Object *ob,
1170                                        bGPdata *gpd,
1171                                        bGPDlayer *gpl,
1172                                        bGPDframe *gpf,
1173                                        const float opacity,
1174                                        const float tintcolor[4],
1175                                        const bool custonion)
1176 {
1177   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1178   Depsgraph *depsgraph = DRW_context_state_get()->depsgraph;
1179
1180   float viewmatrix[4][4];
1181
1182   /* get parent matrix and save as static data */
1183   ED_gpencil_parent_location(depsgraph, ob, gpd, gpl, viewmatrix);
1184   copy_m4_m4(gpf->runtime.viewmatrix, viewmatrix);
1185
1186   for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1187     MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1188     if (gp_style == NULL) {
1189       continue;
1190     }
1191     copy_v4_v4(gps->runtime.tmp_stroke_rgba, gp_style->stroke_rgba);
1192     copy_v4_v4(gps->runtime.tmp_fill_rgba, gp_style->fill_rgba);
1193
1194     int id = stl->storage->shgroup_id;
1195     /* check if stroke can be drawn */
1196     if (gpencil_can_draw_stroke(gp_style, gps, true, false) == false) {
1197       continue;
1198     }
1199     /* limit the number of shading groups */
1200     if (id >= GPENCIL_MAX_SHGROUPS) {
1201       continue;
1202     }
1203
1204     /* stroke */
1205     gpencil_add_stroke_vertexdata(cache, ob, gpl, gpf, gps, opacity, tintcolor, true, custonion);
1206
1207     stl->storage->shgroup_id++;
1208   }
1209 }
1210
1211 /* draw onion-skinning for a layer */
1212 static void gpencil_draw_onionskins(GpencilBatchCache *cache,
1213                                     void *vedata,
1214                                     Object *ob,
1215                                     bGPdata *gpd,
1216                                     bGPDlayer *gpl,
1217                                     bGPDframe *gpf)
1218 {
1219
1220   const float default_color[3] = {UNPACK3(U.gpencil_new_layer_col)};
1221   const float alpha = 1.0f;
1222   float color[4];
1223   int idx;
1224   float fac = 1.0f;
1225   int step = 0;
1226   int mode = 0;
1227   bool colflag = false;
1228   bGPDframe *gpf_loop = NULL;
1229   int last = gpf->framenum;
1230
1231   colflag = (bool)gpd->onion_flag & GP_ONION_GHOST_PREVCOL;
1232
1233   /* -------------------------------
1234    * 1) Draw Previous Frames First
1235    * ------------------------------- */
1236   step = gpd->gstep;
1237   mode = gpd->onion_mode;
1238
1239   if (gpd->onion_flag & GP_ONION_GHOST_PREVCOL) {
1240     copy_v3_v3(color, gpd->gcolor_prev);
1241   }
1242   else {
1243     copy_v3_v3(color, default_color);
1244   }
1245
1246   idx = 0;
1247   for (bGPDframe *gf = gpf->prev; gf; gf = gf->prev) {
1248     /* only selected frames */
1249     if ((mode == GP_ONION_MODE_SELECTED) && ((gf->flag & GP_FRAME_SELECT) == 0)) {
1250       continue;
1251     }
1252     /* absolute range */
1253     if (mode == GP_ONION_MODE_ABSOLUTE) {
1254       if ((gpf->framenum - gf->framenum) > step) {
1255         break;
1256       }
1257     }
1258     /* relative range */
1259     if (mode == GP_ONION_MODE_RELATIVE) {
1260       idx++;
1261       if (idx > step) {
1262         break;
1263       }
1264     }
1265     /* alpha decreases with distance from curframe index */
1266     if (mode != GP_ONION_MODE_SELECTED) {
1267       if (mode == GP_ONION_MODE_ABSOLUTE) {
1268         fac = 1.0f - ((float)(gpf->framenum - gf->framenum) / (float)(step + 1));
1269       }
1270       else {
1271         fac = 1.0f - ((float)idx / (float)(step + 1));
1272       }
1273       color[3] = alpha * fac * 0.66f;
1274     }
1275     else {
1276       idx++;
1277       fac = alpha - ((1.1f - (1.0f / (float)idx)) * 0.66f);
1278       color[3] = fac;
1279     }
1280
1281     /* if loop option, save the frame to use later */
1282     if ((mode != GP_ONION_MODE_ABSOLUTE) && (gpd->onion_flag & GP_ONION_LOOP)) {
1283       gpf_loop = gf;
1284     }
1285
1286     gpencil_get_onion_alpha(color, gpd);
1287     gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gf, color[3], color, colflag);
1288   }
1289   /* -------------------------------
1290    * 2) Now draw next frames
1291    * ------------------------------- */
1292   step = gpd->gstep_next;
1293   mode = gpd->onion_mode;
1294
1295   if (gpd->onion_flag & GP_ONION_GHOST_NEXTCOL) {
1296     copy_v3_v3(color, gpd->gcolor_next);
1297   }
1298   else {
1299     copy_v3_v3(color, default_color);
1300   }
1301
1302   idx = 0;
1303   for (bGPDframe *gf = gpf->next; gf; gf = gf->next) {
1304     /* only selected frames */
1305     if ((mode == GP_ONION_MODE_SELECTED) && ((gf->flag & GP_FRAME_SELECT) == 0)) {
1306       continue;
1307     }
1308     /* absolute range */
1309     if (mode == GP_ONION_MODE_ABSOLUTE) {
1310       if ((gf->framenum - gpf->framenum) > step) {
1311         break;
1312       }
1313     }
1314     /* relative range */
1315     if (mode == GP_ONION_MODE_RELATIVE) {
1316       idx++;
1317       if (idx > step) {
1318         break;
1319       }
1320     }
1321     /* alpha decreases with distance from curframe index */
1322     if (mode != GP_ONION_MODE_SELECTED) {
1323       if (mode == GP_ONION_MODE_ABSOLUTE) {
1324         fac = 1.0f - ((float)(gf->framenum - gpf->framenum) / (float)(step + 1));
1325       }
1326       else {
1327         fac = 1.0f - ((float)idx / (float)(step + 1));
1328       }
1329       color[3] = alpha * fac * 0.66f;
1330     }
1331     else {
1332       idx++;
1333       fac = alpha - ((1.1f - (1.0f / (float)idx)) * 0.66f);
1334       color[3] = fac;
1335     }
1336
1337     gpencil_get_onion_alpha(color, gpd);
1338     gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gf, color[3], color, colflag);
1339     if (last < gf->framenum) {
1340       last = gf->framenum;
1341     }
1342   }
1343
1344   /* Draw first frame in blue for loop mode */
1345   if ((gpd->onion_flag & GP_ONION_LOOP) && (gpf_loop != NULL)) {
1346     if ((last == gpf->framenum) || (gpf->next == NULL)) {
1347       gpencil_get_onion_alpha(color, gpd);
1348       gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gpf_loop, color[3], color, colflag);
1349     }
1350   }
1351 }
1352
1353 static void gpencil_copy_frame(bGPDframe *gpf, bGPDframe *derived_gpf)
1354 {
1355   derived_gpf->prev = gpf->prev;
1356   derived_gpf->next = gpf->next;
1357   derived_gpf->framenum = gpf->framenum;
1358   derived_gpf->flag = gpf->flag;
1359   derived_gpf->key_type = gpf->key_type;
1360   derived_gpf->runtime = gpf->runtime;
1361   copy_m4_m4(derived_gpf->runtime.viewmatrix, gpf->runtime.viewmatrix);
1362
1363   /* copy strokes */
1364   BLI_listbase_clear(&derived_gpf->strokes);
1365   for (bGPDstroke *gps_src = gpf->strokes.first; gps_src; gps_src = gps_src->next) {
1366     /* make copy of source stroke */
1367     bGPDstroke *gps_dst = BKE_gpencil_stroke_duplicate(gps_src);
1368     BLI_addtail(&derived_gpf->strokes, gps_dst);
1369   }
1370 }
1371
1372 /* Triangulate stroke for high quality fill (this is done only if cache is null or stroke was
1373  * modified) */
1374 void DRW_gpencil_triangulate_stroke_fill(Object *ob, bGPDstroke *gps)
1375 {
1376   BLI_assert(gps->totpoints >= 3);
1377
1378   bGPdata *gpd = (bGPdata *)ob->data;
1379
1380   /* allocate memory for temporary areas */
1381   gps->tot_triangles = gps->totpoints - 2;
1382   uint(*tmp_triangles)[3] = MEM_mallocN(sizeof(*tmp_triangles) * gps->tot_triangles,
1383                                         "GP Stroke temp triangulation");
1384   float(*points2d)[2] = MEM_mallocN(sizeof(*points2d) * gps->totpoints,
1385                                     "GP Stroke temp 2d points");
1386   float(*uv)[2] = MEM_mallocN(sizeof(*uv) * gps->totpoints, "GP Stroke temp 2d uv data");
1387
1388   int direction = 0;
1389
1390   /* convert to 2d and triangulate */
1391   BKE_gpencil_stroke_2d_flat(gps->points, gps->totpoints, points2d, &direction);
1392   BLI_polyfill_calc(points2d, (uint)gps->totpoints, direction, tmp_triangles);
1393
1394   /* calc texture coordinates automatically */
1395   float minv[2];
1396   float maxv[2];
1397   /* first needs bounding box data */
1398   if (gpd->flag & GP_DATA_UV_ADAPTIVE) {
1399     gpencil_calc_2d_bounding_box(points2d, gps->totpoints, minv, maxv);
1400   }
1401   else {
1402     ARRAY_SET_ITEMS(minv, -1.0f, -1.0f);
1403     ARRAY_SET_ITEMS(maxv, 1.0f, 1.0f);
1404   }
1405
1406   /* calc uv data */
1407   gpencil_calc_stroke_fill_uv(points2d, gps->totpoints, minv, maxv, uv);
1408
1409   /* Number of triangles */
1410   gps->tot_triangles = gps->totpoints - 2;
1411   /* save triangulation data in stroke cache */
1412   if (gps->tot_triangles > 0) {
1413     if (gps->triangles == NULL) {
1414       gps->triangles = MEM_callocN(sizeof(*gps->triangles) * gps->tot_triangles,
1415                                    "GP Stroke triangulation");
1416     }
1417     else {
1418       gps->triangles = MEM_recallocN(gps->triangles, sizeof(*gps->triangles) * gps->tot_triangles);
1419     }
1420
1421     for (int i = 0; i < gps->tot_triangles; i++) {
1422       bGPDtriangle *stroke_triangle = &gps->triangles[i];
1423       memcpy(gps->triangles[i].verts, tmp_triangles[i], sizeof(uint[3]));
1424       /* copy texture coordinates */
1425       copy_v2_v2(stroke_triangle->uv[0], uv[tmp_triangles[i][0]]);
1426       copy_v2_v2(stroke_triangle->uv[1], uv[tmp_triangles[i][1]]);
1427       copy_v2_v2(stroke_triangle->uv[2], uv[tmp_triangles[i][2]]);
1428     }
1429   }
1430   else {
1431     /* No triangles needed - Free anything allocated previously */
1432     if (gps->triangles) {
1433       MEM_freeN(gps->triangles);
1434     }
1435
1436     gps->triangles = NULL;
1437   }
1438
1439   /* disable recalculation flag */
1440   if (gps->flag & GP_STROKE_RECALC_GEOMETRY) {
1441     gps->flag &= ~GP_STROKE_RECALC_GEOMETRY;
1442   }
1443
1444   /* clear memory */
1445   MEM_SAFE_FREE(tmp_triangles);
1446   MEM_SAFE_FREE(points2d);
1447   MEM_SAFE_FREE(uv);
1448 }
1449
1450 /* draw stroke in drawing buffer */
1451 void DRW_gpencil_populate_buffer_strokes(GPENCIL_e_data *e_data,
1452                                          void *vedata,
1453                                          ToolSettings *ts,
1454                                          Object *ob)
1455 {
1456   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1457   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1458   const DRWContextState *draw_ctx = DRW_context_state_get();
1459   View3D *v3d = draw_ctx->v3d;
1460   const bool overlay = v3d != NULL ? (bool)((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) : true;
1461   Brush *brush = BKE_paint_brush(&ts->gp_paint->paint);
1462   const bool is_paint_tool = (bool)((brush) && (brush->gpencil_tool == GPAINT_TOOL_DRAW));
1463   bGPdata *gpd_eval = ob->data;
1464   /* need the original to avoid cow overhead while drawing */
1465   bGPdata *gpd = (bGPdata *)DEG_get_original_id(&gpd_eval->id);
1466
1467   MaterialGPencilStyle *gp_style = NULL;
1468   float obscale = mat4_to_scale(ob->obmat);
1469
1470   /* use the brush material */
1471   Material *ma = BKE_gpencil_object_material_get_from_brush(ob, brush);
1472   if (ma != NULL) {
1473     gp_style = ma->gp_style;
1474   }
1475   /* this is not common, but avoid any special situations when brush could be without material */
1476   if (gp_style == NULL) {
1477     gp_style = BKE_material_gpencil_settings_get(ob, ob->actcol);
1478   }
1479
1480   /* drawing strokes */
1481   /* Check if may need to draw the active stroke cache, only if this layer is the active layer
1482    * that is being edited. (Stroke buffer is currently stored in gp-data)
1483    */
1484   if (gpd->runtime.sbuffer_size > 0) {
1485     if ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0) {
1486       /* It should also be noted that sbuffer contains temporary point types
1487        * i.e. tGPspoints NOT bGPDspoints
1488        */
1489       short lthick = brush->size * obscale;
1490
1491       /* save gradient info */
1492       stl->storage->gradient_f = brush->gpencil_settings->gradient_f;
1493       copy_v2_v2(stl->storage->gradient_s, brush->gpencil_settings->gradient_s);
1494       stl->storage->alignment_mode = (gp_style) ? gp_style->alignment_mode : GP_STYLE_FOLLOW_PATH;
1495
1496       /* if only one point, don't need to draw buffer because the user has no time to see it */
1497       if (gpd->runtime.sbuffer_size > 1) {
1498         if ((gp_style) && (gp_style->mode == GP_STYLE_MODE_LINE)) {
1499           stl->g_data->shgrps_drawing_stroke = DRW_gpencil_shgroup_stroke_create(
1500               e_data,
1501               vedata,
1502               psl->drawing_pass,
1503               e_data->gpencil_stroke_sh,
1504               NULL,
1505               gpd,
1506               NULL,
1507               NULL,
1508               gp_style,
1509               -1,
1510               false,
1511               1.0f,
1512               (const int *)stl->storage->shade_render);
1513         }
1514         else {
1515           stl->g_data->shgrps_drawing_stroke = DRW_gpencil_shgroup_point_create(
1516               e_data,
1517               vedata,
1518               psl->drawing_pass,
1519               e_data->gpencil_point_sh,
1520               NULL,
1521               gpd,
1522               NULL,
1523               NULL,
1524               gp_style,
1525               -1,
1526               false,
1527               1.0f,
1528               (const int *)stl->storage->shade_render);
1529         }
1530
1531         /* clean previous version of the batch */
1532         if (stl->storage->buffer_stroke) {
1533           GPU_BATCH_DISCARD_SAFE(e_data->batch_buffer_stroke);
1534           MEM_SAFE_FREE(e_data->batch_buffer_stroke);
1535           stl->storage->buffer_stroke = false;
1536         }
1537
1538         /* use unit matrix because the buffer is in screen space and does not need conversion */
1539         if (gpd->runtime.mode == GP_STYLE_MODE_LINE) {
1540           e_data->batch_buffer_stroke = DRW_gpencil_get_buffer_stroke_geom(gpd, lthick);
1541         }
1542         else {
1543           e_data->batch_buffer_stroke = DRW_gpencil_get_buffer_point_geom(gpd, lthick);
1544         }
1545
1546         /* buffer strokes, must show stroke always */
1547         DRW_shgroup_call(stl->g_data->shgrps_drawing_stroke,
1548                          e_data->batch_buffer_stroke,
1549                          stl->storage->unit_matrix);
1550
1551         if ((gpd->runtime.sbuffer_size >= 3) &&
1552             (gpd->runtime.sfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) &&
1553             ((gpd->runtime.sbuffer_sflag & GP_STROKE_NOFILL) == 0) &&
1554             ((brush->gpencil_settings->flag & GP_BRUSH_DISSABLE_LASSO) == 0) &&
1555             (gp_style->flag & GP_STYLE_FILL_SHOW)) {
1556           /* if not solid, fill is simulated with solid color */
1557           if (gpd->runtime.bfill_style > 0) {
1558             gpd->runtime.sfill[3] = 0.5f;
1559           }
1560           stl->g_data->shgrps_drawing_fill = DRW_shgroup_create(e_data->gpencil_drawing_fill_sh,
1561                                                                 psl->drawing_pass);
1562
1563           /* clean previous version of the batch */
1564           if (stl->storage->buffer_fill) {
1565             GPU_BATCH_DISCARD_SAFE(e_data->batch_buffer_fill);
1566             MEM_SAFE_FREE(e_data->batch_buffer_fill);
1567             stl->storage->buffer_fill = false;
1568           }
1569
1570           e_data->batch_buffer_fill = DRW_gpencil_get_buffer_fill_geom(gpd);
1571           DRW_shgroup_call(stl->g_data->shgrps_drawing_fill,
1572                            e_data->batch_buffer_fill,
1573                            stl->storage->unit_matrix);
1574           stl->storage->buffer_fill = true;
1575         }
1576         stl->storage->buffer_stroke = true;
1577       }
1578     }
1579   }
1580
1581   /* control points for primitives and speed guide */
1582   const bool is_cppoint = (gpd->runtime.tot_cp_points > 0);
1583   const bool is_speed_guide = (ts->gp_sculpt.guide.use_guide &&
1584                                (draw_ctx->object_mode == OB_MODE_PAINT_GPENCIL));
1585   const bool is_show_gizmo = (((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) &&
1586                               ((v3d->gizmo_flag & V3D_GIZMO_HIDE_TOOL) == 0));
1587
1588   if ((overlay) && (is_paint_tool) && (is_cppoint || is_speed_guide) && (is_show_gizmo) &&
1589       ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0)) {
1590     DRWShadingGroup *shgrp = DRW_shgroup_create(e_data->gpencil_edit_point_sh, psl->drawing_pass);
1591     const float *viewport_size = DRW_viewport_size_get();
1592     DRW_shgroup_uniform_vec2(shgrp, "Viewport", viewport_size, 1);
1593
1594     /* clean previous version of the batch */
1595     if (stl->storage->buffer_ctrlpoint) {
1596       GPU_BATCH_DISCARD_SAFE(e_data->batch_buffer_ctrlpoint);
1597       MEM_SAFE_FREE(e_data->batch_buffer_ctrlpoint);
1598       stl->storage->buffer_ctrlpoint = false;
1599     }
1600
1601     e_data->batch_buffer_ctrlpoint = DRW_gpencil_get_buffer_ctrlpoint_geom(gpd);
1602
1603     DRW_shgroup_call(shgrp, e_data->batch_buffer_ctrlpoint, stl->storage->unit_matrix);
1604
1605     stl->storage->buffer_ctrlpoint = true;
1606   }
1607 }
1608
1609 /* create all missing batches */
1610 static void DRW_gpencil_create_batches(GpencilBatchCache *cache)
1611 {
1612   if ((cache->b_point.vbo) && (cache->b_point.batch == NULL)) {
1613     cache->b_point.batch = GPU_batch_create_ex(
1614         GPU_PRIM_POINTS, cache->b_point.vbo, NULL, GPU_BATCH_OWNS_VBO);
1615   }
1616   if ((cache->b_stroke.vbo) && (cache->b_stroke.batch == NULL)) {
1617     cache->b_stroke.batch = GPU_batch_create_ex(
1618         GPU_PRIM_LINE_STRIP_ADJ, cache->b_stroke.vbo, NULL, GPU_BATCH_OWNS_VBO);
1619   }
1620   if ((cache->b_fill.vbo) && (cache->b_fill.batch == NULL)) {
1621     cache->b_fill.batch = GPU_batch_create_ex(
1622         GPU_PRIM_TRIS, cache->b_fill.vbo, NULL, GPU_BATCH_OWNS_VBO);
1623   }
1624   if ((cache->b_edit.vbo) && (cache->b_edit.batch == NULL)) {
1625     cache->b_edit.batch = GPU_batch_create_ex(
1626         GPU_PRIM_POINTS, cache->b_edit.vbo, NULL, GPU_BATCH_OWNS_VBO);
1627   }
1628   if ((cache->b_edlin.vbo) && (cache->b_edlin.batch == NULL)) {
1629     cache->b_edlin.batch = GPU_batch_create_ex(
1630         GPU_PRIM_LINE_STRIP, cache->b_edlin.vbo, NULL, GPU_BATCH_OWNS_VBO);
1631   }
1632 }
1633
1634 /* create all shading groups */
1635 static void DRW_gpencil_shgroups_create(GPENCIL_e_data *e_data,
1636                                         void *vedata,
1637                                         Object *ob,
1638                                         GpencilBatchCache *cache,
1639                                         tGPencilObjectCache *cache_ob)
1640 {
1641   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1642   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1643   bGPdata *gpd = (bGPdata *)ob->data;
1644   DRWPass *stroke_pass = GPENCIL_3D_DRAWMODE(ob, gpd) ? psl->stroke_pass_3d : psl->stroke_pass_2d;
1645
1646   GpencilBatchGroup *elm = NULL;
1647   DRWShadingGroup *shgrp = NULL;
1648   tGPencilObjectCache_shgrp *array_elm = NULL;
1649
1650   bGPDlayer *gpl = NULL;
1651   bGPDlayer *gpl_prev = NULL;
1652   int idx = 0;
1653   bool tag_first = false;
1654
1655   const DRWContextState *draw_ctx = DRW_context_state_get();
1656   const View3D *v3d = draw_ctx->v3d;
1657
1658   const bool overlay = draw_ctx->v3d != NULL ?
1659                            (bool)((draw_ctx->v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) :
1660                            true;
1661   const bool main_onion = v3d != NULL ? (v3d->gp_flag & V3D_GP_SHOW_ONION_SKIN) : true;
1662   const bool do_onion = (bool)((gpd->flag & GP_DATA_STROKE_WEIGHTMODE) == 0) && main_onion &&
1663                         DRW_gpencil_onion_active(gpd) && overlay;
1664
1665   int start_stroke = 0;
1666   int start_point = 0;
1667   int start_fill = 0;
1668   int start_edit = 0;
1669   int start_edlin = 0;
1670
1671   for (int i = 0; i < cache->grp_used; i++) {
1672     elm = &cache->grp_cache[i];
1673     array_elm = &cache_ob->shgrp_array[idx];
1674     const float scale = cache_ob->scale;
1675
1676     /* save last group when change */
1677     if (gpl_prev == NULL) {
1678       gpl_prev = elm->gpl;
1679       tag_first = true;
1680     }
1681     else {
1682       if (elm->gpl != gpl_prev) {
1683         /* first layer is always blend Normal */
1684         array_elm->mode = idx == 0 ? eGplBlendMode_Normal : gpl->blend_mode;
1685         array_elm->end_shgrp = shgrp;
1686         gpl_prev = elm->gpl;
1687         tag_first = true;
1688         idx++;
1689       }
1690     }
1691
1692     gpl = elm->gpl;
1693     bGPDframe *gpf = elm->gpf;
1694     bGPDstroke *gps = elm->gps;
1695     MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1696     /* if the user switch used material from data to object,
1697      * the material could not be available */
1698     if (gp_style == NULL) {
1699       break;
1700     }
1701
1702     /* limit the number of shading groups */
1703     if (i >= GPENCIL_MAX_SHGROUPS) {
1704       break;
1705     }
1706
1707     switch (elm->type) {
1708       case eGpencilBatchGroupType_Stroke: {
1709         const int len = elm->vertex_idx - start_stroke;
1710
1711         shgrp = DRW_gpencil_shgroup_stroke_create(e_data,
1712                                                   vedata,
1713                                                   stroke_pass,
1714                                                   e_data->gpencil_stroke_sh,
1715                                                   ob,
1716                                                   gpd,
1717                                                   gpl,
1718                                                   gps,
1719                                                   gp_style,
1720                                                   stl->storage->shgroup_id,
1721                                                   elm->onion,
1722                                                   scale,
1723                                                   cache_ob->shading_type);
1724         if ((do_onion) || (elm->onion == false)) {
1725           DRW_shgroup_call_range(shgrp,
1726                                  cache->b_stroke.batch,
1727                                  (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1728                                                           cache_ob->obmat,
1729                                  start_stroke,
1730                                  len);
1731         }
1732         stl->storage->shgroup_id++;
1733         start_stroke = elm->vertex_idx;
1734         break;
1735       }
1736       case eGpencilBatchGroupType_Point: {
1737         const int len = elm->vertex_idx - start_point;
1738
1739         shgrp = DRW_gpencil_shgroup_point_create(e_data,
1740                                                  vedata,
1741                                                  stroke_pass,
1742                                                  e_data->gpencil_point_sh,
1743                                                  ob,
1744                                                  gpd,
1745                                                  gpl,
1746                                                  gps,
1747                                                  gp_style,
1748                                                  stl->storage->shgroup_id,
1749                                                  elm->onion,
1750                                                  scale,
1751                                                  cache_ob->shading_type);
1752
1753         if ((do_onion) || (elm->onion == false)) {
1754           DRW_shgroup_call_range(shgrp,
1755                                  cache->b_point.batch,
1756                                  (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1757                                                           cache_ob->obmat,
1758                                  start_point,
1759                                  len);
1760         }
1761         stl->storage->shgroup_id++;
1762         start_point = elm->vertex_idx;
1763         break;
1764       }
1765       case eGpencilBatchGroupType_Fill: {
1766         const int len = elm->vertex_idx - start_fill;
1767
1768         shgrp = DRW_gpencil_shgroup_fill_create(e_data,
1769                                                 vedata,
1770                                                 stroke_pass,
1771                                                 e_data->gpencil_fill_sh,
1772                                                 ob,
1773                                                 gpd,
1774                                                 gpl,
1775                                                 gp_style,
1776                                                 stl->storage->shgroup_id,
1777                                                 cache_ob->shading_type);
1778
1779         if ((do_onion) || (elm->onion == false)) {
1780           DRW_shgroup_call_range(shgrp,
1781                                  cache->b_fill.batch,
1782                                  (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1783                                                           cache_ob->obmat,
1784                                  start_fill,
1785                                  len);
1786         }
1787         stl->storage->shgroup_id++;
1788         start_fill = elm->vertex_idx;
1789         break;
1790       }
1791       case eGpencilBatchGroupType_Edit: {
1792         if (stl->g_data->shgrps_edit_point) {
1793           const int len = elm->vertex_idx - start_edit;
1794           /* use always the same group */
1795           DRW_shgroup_call_range(stl->g_data->shgrps_edit_point,
1796                                  cache->b_edit.batch,
1797                                  (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1798                                                           cache_ob->obmat,
1799                                  start_edit,
1800                                  len);
1801
1802           start_edit = elm->vertex_idx;
1803         }
1804         break;
1805       }
1806       case eGpencilBatchGroupType_Edlin: {
1807         if (stl->g_data->shgrps_edit_line) {
1808           const int len = elm->vertex_idx - start_edlin;
1809           /* use always the same group */
1810           DRW_shgroup_call_range(stl->g_data->shgrps_edit_line,
1811                                  cache->b_edlin.batch,
1812                                  (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1813                                                           cache_ob->obmat,
1814                                  start_edlin,
1815                                  len);
1816
1817           start_edlin = elm->vertex_idx;
1818         }
1819         break;
1820       }
1821       default: {
1822         break;
1823       }
1824     }
1825     /* save first group */
1826     if ((shgrp != NULL) && (tag_first)) {
1827       array_elm = &cache_ob->shgrp_array[idx];
1828       array_elm->mode = idx == 0 ? eGplBlendMode_Normal : gpl->blend_mode;
1829       array_elm->clamp_layer = gpl->flag & GP_LAYER_USE_MASK;
1830       array_elm->blend_opacity = gpl->opacity;
1831       array_elm->init_shgrp = shgrp;
1832       cache_ob->tot_layers++;
1833
1834       tag_first = false;
1835     }
1836   }
1837
1838   /* save last group */
1839   if (shgrp != NULL) {
1840     array_elm->mode = idx == 0 ? eGplBlendMode_Normal : gpl->blend_mode;
1841     array_elm->end_shgrp = shgrp;
1842   }
1843 }
1844 /* populate a datablock for multiedit (no onions, no modifiers) */
1845 void DRW_gpencil_populate_multiedit(GPENCIL_e_data *e_data,
1846                                     void *vedata,
1847                                     Object *ob,
1848                                     tGPencilObjectCache *cache_ob)
1849 {
1850   bGPdata *gpd = (bGPdata *)ob->data;
1851   bGPDframe *gpf = NULL;
1852
1853   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1854   const DRWContextState *draw_ctx = DRW_context_state_get();
1855   int cfra_eval = (int)DEG_get_ctime(draw_ctx->depsgraph);
1856   GpencilBatchCache *cache = gpencil_batch_cache_get(ob, cfra_eval);
1857
1858   /* check if playing animation */
1859   const bool playing = stl->storage->is_playing;
1860
1861   /* calc max size of VBOs */
1862   gpencil_calc_vertex(stl, cache_ob, cache, gpd, cfra_eval);
1863
1864   /* draw strokes */
1865   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1866     /* don't draw layer if hidden */
1867     if (gpl->flag & GP_LAYER_HIDE) {
1868       continue;
1869     }
1870
1871     /* list of frames to draw */
1872     if (!playing) {
1873       for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1874         if ((gpf == gpl->actframe) || (gpf->flag & GP_FRAME_SELECT)) {
1875           gpencil_draw_strokes(cache,
1876                                e_data,
1877                                vedata,
1878                                ob,
1879                                gpd,
1880                                gpl,
1881                                gpf,
1882                                gpf,
1883                                gpl->opacity,
1884                                gpl->tintcolor,
1885                                false,
1886                                cache_ob);
1887         }
1888       }
1889     }
1890     else {
1891       gpf = BKE_gpencil_layer_getframe(gpl, cfra_eval, GP_GETFRAME_USE_PREV);
1892       if (gpf) {
1893         gpencil_draw_strokes(cache,
1894                              e_data,
1895                              vedata,
1896                              ob,
1897                              gpd,
1898                              gpl,
1899                              gpf,
1900                              gpf,
1901                              gpl->opacity,
1902                              gpl->tintcolor,
1903                              false,
1904                              cache_ob);
1905       }
1906     }
1907   }
1908
1909   /* create batchs and shading groups */
1910   DRW_gpencil_create_batches(cache);
1911   DRW_gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
1912
1913   cache->is_dirty = false;
1914 }
1915
1916 /* ensure there is a derived frame */
1917 static void gpencil_ensure_derived_frame(bGPdata *gpd,
1918                                          bGPDlayer *gpl,
1919                                          bGPDframe *gpf,
1920                                          GpencilBatchCache *cache,
1921                                          bGPDframe **derived_gpf)
1922 {
1923   /* create derived frames array data or expand */
1924   int derived_idx = BLI_findindex(&gpd->layers, gpl);
1925   *derived_gpf = &cache->derived_array[derived_idx];
1926
1927   /* if no derived frame or dirty cache, create a new one */
1928   if ((*derived_gpf == NULL) || (cache->is_dirty)) {
1929     if (*derived_gpf != NULL) {
1930       /* first clear temp data */
1931       BKE_gpencil_free_frame_runtime_data(*derived_gpf);
1932     }
1933     /* create new data (do not assign new memory)*/
1934     gpencil_copy_frame(gpf, *derived_gpf);
1935   }
1936 }
1937
1938 /* helper for populate a complete grease pencil datablock */
1939 void DRW_gpencil_populate_datablock(GPENCIL_e_data *e_data,
1940                                     void *vedata,
1941                                     Object *ob,
1942                                     tGPencilObjectCache *cache_ob)
1943 {
1944   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1945   const DRWContextState *draw_ctx = DRW_context_state_get();
1946   const ViewLayer *view_layer = DEG_get_evaluated_view_layer(draw_ctx->depsgraph);
1947   Scene *scene = draw_ctx->scene;
1948
1949   bGPdata *gpd = (bGPdata *)ob->data;
1950
1951   View3D *v3d = draw_ctx->v3d;
1952   int cfra_eval = (int)DEG_get_ctime(draw_ctx->depsgraph);
1953
1954   bGPDframe *derived_gpf = NULL;
1955   const bool overlay = v3d != NULL ? (bool)((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) : true;
1956   const bool time_remap = BKE_gpencil_has_time_modifiers(ob);
1957
1958   float opacity;
1959   bGPDframe *gpf = NULL;
1960   bGPDlayer *gpl_active = BKE_gpencil_layer_getactive(gpd);
1961
1962   /* check if playing animation */
1963   const bool playing = stl->storage->is_playing;
1964
1965   GpencilBatchCache *cache = gpencil_batch_cache_get(ob, cfra_eval);
1966
1967   /* if object is duplicate, only create shading groups */
1968   if (cache_ob->is_dup_ob) {
1969     DRW_gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
1970     return;
1971   }
1972
1973   /* calc max size of VBOs */
1974   gpencil_calc_vertex(stl, cache_ob, cache, gpd, cfra_eval);
1975
1976   /* init general modifiers data */
1977   if (!stl->storage->simplify_modif) {
1978     if ((cache->is_dirty) && (ob->greasepencil_modifiers.first)) {
1979       BKE_gpencil_lattice_init(ob);
1980     }
1981   }
1982   /* draw normal strokes */
1983   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1984     /* don't draw layer if hidden */
1985     if (gpl->flag & GP_LAYER_HIDE) {
1986       continue;
1987     }
1988
1989     const bool is_solomode = GPENCIL_PAINT_MODE(gpd) && (!playing) && (!stl->storage->is_render) &&
1990                              (gpl->flag & GP_LAYER_SOLO_MODE);
1991
1992     /* filter view layer to gp layers in the same view layer (for compo) */
1993     if ((stl->storage->is_render) && (gpl->viewlayername[0] != '\0')) {
1994       if (!STREQ(view_layer->name, gpl->viewlayername)) {
1995         continue;
1996       }
1997     }
1998
1999     /* remap time */
2000     int remap_cfra = cfra_eval;
2001     if ((time_remap) && (!stl->storage->simplify_modif)) {
2002       remap_cfra = BKE_gpencil_time_modifier(
2003           draw_ctx->depsgraph, scene, ob, gpl, cfra_eval, stl->storage->is_render);
2004     }
2005
2006     gpf = BKE_gpencil_layer_getframe(gpl, remap_cfra, GP_GETFRAME_USE_PREV);
2007     if (gpf == NULL) {
2008       continue;
2009     }
2010
2011     /* if solo mode, display only frames with keyframe in the current frame */
2012     if ((is_solomode) && (gpf->framenum != remap_cfra)) {
2013       continue;
2014     }
2015
2016     opacity = gpl->opacity;
2017     /* if pose mode, maybe the overlay to fade geometry is enabled */
2018     if ((draw_ctx->obact) && (draw_ctx->object_mode == OB_MODE_POSE) &&
2019         (v3d->overlay.flag & V3D_OVERLAY_BONE_SELECT)) {
2020       opacity = opacity * v3d->overlay.xray_alpha_bone;
2021     }
2022     /* fade no active layers */
2023     if ((overlay) && (draw_ctx->object_mode == OB_MODE_PAINT_GPENCIL) &&
2024         (v3d->gp_flag & V3D_GP_FADE_NOACTIVE_LAYERS) && (draw_ctx->obact) &&
2025         (draw_ctx->obact == ob) && (gpl != gpl_active)) {
2026       opacity = opacity * v3d->overlay.gpencil_fade_layer;
2027     }
2028
2029     /* create derived frames array data or expand */
2030     gpencil_ensure_derived_frame(gpd, gpl, gpf, cache, &derived_gpf);
2031
2032     /* draw onion skins */
2033     if (!ID_IS_LINKED(&gpd->id)) {
2034       if ((gpl->onion_flag & GP_LAYER_ONIONSKIN) &&
2035           ((!playing) || (gpd->onion_flag & GP_ONION_GHOST_ALWAYS)) && (!cache_ob->is_dup_ob) &&
2036           (gpd->id.us <= 1)) {
2037         if ((!stl->storage->is_render) ||
2038             ((stl->storage->is_render) && (gpd->onion_flag & GP_ONION_GHOST_ALWAYS))) {
2039           gpencil_draw_onionskins(cache, vedata, ob, gpd, gpl, gpf);
2040         }
2041       }
2042     }
2043     /* draw normal strokes */
2044     gpencil_draw_strokes(cache,
2045                          e_data,
2046                          vedata,
2047                          ob,
2048                          gpd,
2049                          gpl,
2050                          gpf,
2051                          derived_gpf,
2052                          opacity,
2053                          gpl->tintcolor,
2054                          false,
2055                          cache_ob);
2056   }
2057
2058   /* clear any lattice data */
2059   if ((cache->is_dirty) && (ob->greasepencil_modifiers.first)) {
2060     BKE_gpencil_lattice_clear(ob);
2061   }
2062
2063   /* create batchs and shading groups */
2064   DRW_gpencil_create_batches(cache);
2065   DRW_gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
2066
2067   cache->is_dirty = false;
2068 }
2069
2070 void DRW_gpencil_populate_particles(GPENCIL_e_data *e_data, GHash *gh_objects, void *vedata)
2071 {
2072   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
2073
2074   /* add particles */
2075   for (int i = 0; i < stl->g_data->gp_cache_used; i++) {
2076     tGPencilObjectCache *cache_ob = &stl->g_data->gp_object_cache[i];
2077     if (cache_ob->is_dup_ob) {
2078       /* reasign duplicate objects because memory for particles is not available
2079        * and need to use the original datablock and runtime data */
2080       Object *ob = (Object *)BLI_ghash_lookup(gh_objects, cache_ob->name);
2081       if (ob) {
2082         cache_ob->ob = ob;
2083         cache_ob->gpd = (bGPdata *)ob->data;
2084         GpencilBatchCache *cache = ob->runtime.gpencil_cache;
2085         if (cache != NULL) {
2086           DRW_gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
2087         }
2088       }
2089     }
2090   }
2091 }