GPencil: Add option to mix color with texture
[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, true);
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, true);
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].use_follow_path = (gp_style->flag & GP_STYLE_COLOR_LOCK_DOTS) ? 0 : 1;
729     DRW_shgroup_uniform_int(grp, "use_follow_path", &stl->shgroups[id].use_follow_path, 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, "use_follow_path", &stl->storage->use_follow_path, 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, true);
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
874   /* set color using base color, tint color and opacity */
875   if (cache->is_dirty) {
876     if (!onion) {
877       /* if special stroke, use fill color as stroke color */
878       if (gps->flag & GP_STROKE_NOFILL) {
879         interp_v3_v3v3(tcolor, gps->runtime.tmp_fill_rgba, tintcolor, tintcolor[3]);
880         tcolor[3] = gps->runtime.tmp_fill_rgba[3] * opacity;
881       }
882       else {
883         interp_v3_v3v3(tcolor, gps->runtime.tmp_stroke_rgba, tintcolor, tintcolor[3]);
884         tcolor[3] = gps->runtime.tmp_stroke_rgba[3] * opacity;
885       }
886       copy_v4_v4(ink, tcolor);
887     }
888     else {
889       if (custonion) {
890         copy_v4_v4(ink, tintcolor);
891       }
892       else {
893         ARRAY_SET_ITEMS(tcolor, UNPACK3(gps->runtime.tmp_stroke_rgba), opacity);
894         copy_v4_v4(ink, tcolor);
895       }
896     }
897
898     sthickness = gps->thickness + gpl->line_change;
899     CLAMP_MIN(sthickness, 1);
900
901     if ((gps->totpoints > 1) && (gp_style->mode == GP_STYLE_MODE_LINE)) {
902       /* create vertex data */
903       const int old_len = cache->b_stroke.vbo_len;
904       DRW_gpencil_get_stroke_geom(&cache->b_stroke, gps, sthickness, ink);
905
906       /* add to list of groups */
907       if (old_len < cache->b_stroke.vbo_len) {
908         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
909                                                    gpl,
910                                                    gpf,
911                                                    gps,
912                                                    eGpencilBatchGroupType_Stroke,
913                                                    onion,
914                                                    cache->b_stroke.vbo_len,
915                                                    &cache->grp_size,
916                                                    &cache->grp_used);
917       }
918     }
919     else {
920       /* create vertex data */
921       const int old_len = cache->b_point.vbo_len;
922       DRW_gpencil_get_point_geom(&cache->b_point, gps, sthickness, ink);
923
924       /* add to list of groups */
925       if (old_len < cache->b_point.vbo_len) {
926         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
927                                                    gpl,
928                                                    gpf,
929                                                    gps,
930                                                    eGpencilBatchGroupType_Point,
931                                                    onion,
932                                                    cache->b_point.vbo_len,
933                                                    &cache->grp_size,
934                                                    &cache->grp_used);
935       }
936     }
937   }
938 }
939
940 /* add edit points vertex info */
941 static void gpencil_add_editpoints_vertexdata(GpencilBatchCache *cache,
942                                               Object *ob,
943                                               bGPdata *gpd,
944                                               bGPDlayer *gpl,
945                                               bGPDframe *gpf,
946                                               bGPDstroke *gps)
947 {
948   const DRWContextState *draw_ctx = DRW_context_state_get();
949   View3D *v3d = draw_ctx->v3d;
950   MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
951
952   /* alpha factor for edit points/line to make them more subtle */
953   float edit_alpha = v3d->vertex_opacity;
954
955   if (GPENCIL_ANY_EDIT_MODE(gpd)) {
956     Object *obact = DRW_context_state_get()->obact;
957     if ((!obact) || (obact->type != OB_GPENCIL)) {
958       return;
959     }
960     const bool is_weight_paint = (gpd) && (gpd->flag & GP_DATA_STROKE_WEIGHTMODE);
961
962     if (cache->is_dirty) {
963       if ((obact == ob) && ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) &&
964           (v3d->gp_flag & V3D_GP_SHOW_EDIT_LINES)) {
965         /* line of the original stroke */
966         DRW_gpencil_get_edlin_geom(&cache->b_edlin, gps, edit_alpha, gpd->flag);
967
968         /* add to list of groups */
969         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
970                                                    gpl,
971                                                    gpf,
972                                                    gps,
973                                                    eGpencilBatchGroupType_Edlin,
974                                                    false,
975                                                    cache->b_edlin.vbo_len,
976                                                    &cache->grp_size,
977                                                    &cache->grp_used);
978       }
979       /* edit points */
980       if ((gps->flag & GP_STROKE_SELECT) || (is_weight_paint)) {
981         if ((gpl->flag & GP_LAYER_UNLOCK_COLOR) ||
982             ((gp_style->flag & GP_STYLE_COLOR_LOCKED) == 0)) {
983           if (obact == ob) {
984             DRW_gpencil_get_edit_geom(&cache->b_edit, gps, edit_alpha, gpd->flag);
985
986             /* add to list of groups */
987             cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
988                                                        gpl,
989                                                        gpf,
990                                                        gps,
991                                                        eGpencilBatchGroupType_Edit,
992                                                        false,
993                                                        cache->b_edit.vbo_len,
994                                                        &cache->grp_size,
995                                                        &cache->grp_used);
996           }
997         }
998       }
999     }
1000   }
1001 }
1002
1003 /* main function to draw strokes */
1004 static void gpencil_draw_strokes(GpencilBatchCache *cache,
1005                                  GPENCIL_e_data *e_data,
1006                                  void *vedata,
1007                                  Object *ob,
1008                                  bGPdata *gpd,
1009                                  bGPDlayer *gpl,
1010                                  bGPDframe *src_gpf,
1011                                  bGPDframe *derived_gpf,
1012                                  const float opacity,
1013                                  const float tintcolor[4],
1014                                  const bool custonion,
1015                                  tGPencilObjectCache *cache_ob)
1016 {
1017   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1018   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1019   const DRWContextState *draw_ctx = DRW_context_state_get();
1020   Scene *scene = draw_ctx->scene;
1021   View3D *v3d = draw_ctx->v3d;
1022   bGPDstroke *gps, *src_gps;
1023   float viewmatrix[4][4];
1024   const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
1025   const bool playing = stl->storage->is_playing;
1026   const bool is_render = (bool)stl->storage->is_render;
1027   const bool is_mat_preview = (bool)stl->storage->is_mat_preview;
1028   const bool overlay_multiedit = v3d != NULL ? (v3d->gp_flag & V3D_GP_SHOW_MULTIEDIT_LINES) : true;
1029
1030   /* Get evaluation context */
1031   /* NOTE: We must check if C is valid, otherwise we get crashes when trying to save files
1032    * (i.e. the thumbnail offscreen rendering fails)
1033    */
1034   Depsgraph *depsgraph = DRW_context_state_get()->depsgraph;
1035
1036   /* get parent matrix and save as static data */
1037   ED_gpencil_parent_location(depsgraph, ob, gpd, gpl, viewmatrix);
1038   copy_m4_m4(derived_gpf->runtime.viewmatrix, viewmatrix);
1039
1040   if ((cache_ob != NULL) && (cache_ob->is_dup_ob)) {
1041     copy_m4_m4(derived_gpf->runtime.viewmatrix, cache_ob->obmat);
1042   }
1043
1044   /* apply geometry modifiers */
1045   if ((cache->is_dirty) && (ob->greasepencil_modifiers.first) && (!is_multiedit)) {
1046     if (!stl->storage->simplify_modif) {
1047       if (BKE_gpencil_has_geometry_modifiers(ob)) {
1048         BKE_gpencil_geometry_modifiers(depsgraph, ob, gpl, derived_gpf, stl->storage->is_render);
1049       }
1050     }
1051   }
1052
1053   if (src_gpf) {
1054     src_gps = src_gpf->strokes.first;
1055   }
1056   else {
1057     src_gps = NULL;
1058   }
1059
1060   for (gps = derived_gpf->strokes.first; gps; gps = gps->next) {
1061     MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1062
1063     /* check if stroke can be drawn */
1064     if (gpencil_can_draw_stroke(gp_style, gps, false, is_mat_preview) == false) {
1065       GP_SET_SRC_GPS(src_gps);
1066       continue;
1067     }
1068
1069     /* be sure recalc all cache in source stroke to avoid recalculation when frame change
1070      * and improve fps */
1071     if (src_gps) {
1072       DRW_gpencil_recalc_geometry_caches(ob, gpl, gp_style, src_gps);
1073     }
1074
1075     /* if the fill has any value, it's considered a fill and is not drawn if simplify fill is enabled */
1076     if ((stl->storage->simplify_fill) &&
1077         (scene->r.simplify_gpencil & SIMPLIFY_GPENCIL_REMOVE_FILL_LINE)) {
1078       if ((gp_style->fill_rgba[3] > GPENCIL_ALPHA_OPACITY_THRESH) ||
1079           (gp_style->fill_style > GP_STYLE_FILL_STYLE_SOLID) ||
1080           (gpl->blend_mode != eGplBlendMode_Normal)) {
1081         GP_SET_SRC_GPS(src_gps);
1082         continue;
1083       }
1084     }
1085
1086     if ((gpl->actframe->framenum == derived_gpf->framenum) || (!is_multiedit) ||
1087         (overlay_multiedit)) {
1088       /* copy color to temp fields to apply temporal changes in the stroke */
1089       copy_v4_v4(gps->runtime.tmp_stroke_rgba, gp_style->stroke_rgba);
1090       copy_v4_v4(gps->runtime.tmp_fill_rgba, gp_style->fill_rgba);
1091
1092       /* apply modifiers (only modify geometry, but not create ) */
1093       if ((cache->is_dirty) && (ob->greasepencil_modifiers.first) && (!is_multiedit)) {
1094         if (!stl->storage->simplify_modif) {
1095           BKE_gpencil_stroke_modifiers(
1096               depsgraph, ob, gpl, derived_gpf, gps, stl->storage->is_render);
1097         }
1098       }
1099
1100       /* hide any blend layer */
1101       if ((!stl->storage->simplify_blend) || (gpl->blend_mode == eGplBlendMode_Normal)) {
1102         /* fill */
1103         if ((gp_style->flag & GP_STYLE_FILL_SHOW) && (!stl->storage->simplify_fill) &&
1104             ((gps->flag & GP_STROKE_NOFILL) == 0)) {
1105           gpencil_add_fill_vertexdata(
1106               cache, ob, gpl, derived_gpf, gps, opacity, tintcolor, false, custonion);
1107         }
1108         /* stroke */
1109         /* No fill strokes, must show stroke always */
1110         if (((gp_style->flag & GP_STYLE_STROKE_SHOW) || (gps->flag & GP_STROKE_NOFILL)) &&
1111             ((gp_style->stroke_rgba[3] > GPENCIL_ALPHA_OPACITY_THRESH) ||
1112              (gpl->blend_mode == eGplBlendMode_Normal))) {
1113           /* recalc strokes uv (geometry can be changed by modifiers) */
1114           if (gps->flag & GP_STROKE_RECALC_GEOMETRY) {
1115             ED_gpencil_calc_stroke_uv(ob, gps);
1116           }
1117
1118           gpencil_add_stroke_vertexdata(
1119               cache, ob, gpl, derived_gpf, gps, opacity, tintcolor, false, custonion);
1120         }
1121       }
1122     }
1123
1124     /* edit points (only in edit mode and not play animation not render) */
1125     if ((draw_ctx->obact == ob) && (src_gps) && (!playing) && (!is_render) &&
1126         (!cache_ob->is_dup_ob)) {
1127       if ((gpl->flag & GP_LAYER_LOCKED) == 0) {
1128         if (!stl->g_data->shgrps_edit_line) {
1129           stl->g_data->shgrps_edit_line = DRW_shgroup_create(e_data->gpencil_line_sh,
1130                                                              psl->edit_pass);
1131         }
1132         if (!stl->g_data->shgrps_edit_point) {
1133           stl->g_data->shgrps_edit_point = DRW_shgroup_create(e_data->gpencil_edit_point_sh,
1134                                                               psl->edit_pass);
1135           const float *viewport_size = DRW_viewport_size_get();
1136           DRW_shgroup_uniform_vec2(stl->g_data->shgrps_edit_point, "Viewport", viewport_size, 1);
1137         }
1138
1139         gpencil_add_editpoints_vertexdata(cache, ob, gpd, gpl, derived_gpf, src_gps);
1140       }
1141     }
1142
1143     GP_SET_SRC_GPS(src_gps);
1144   }
1145 }
1146
1147 /* get alpha factor for onion strokes */
1148 static void gpencil_get_onion_alpha(float color[4], bGPdata *gpd)
1149 {
1150 #define MIN_ALPHA_VALUE 0.01f
1151
1152   /* if fade is disabled, opacity is equal in all frames */
1153   if ((gpd->onion_flag & GP_ONION_FADE) == 0) {
1154     color[3] = gpd->onion_factor;
1155   }
1156   else {
1157     /* add override opacity factor */
1158     color[3] += gpd->onion_factor - 0.5f;
1159   }
1160
1161   CLAMP(color[3], MIN_ALPHA_VALUE, 1.0f);
1162 }
1163
1164 /* function to draw strokes for onion only */
1165 static void gpencil_draw_onion_strokes(GpencilBatchCache *cache,
1166                                        void *vedata,
1167                                        Object *ob,
1168                                        bGPdata *gpd,
1169                                        bGPDlayer *gpl,
1170                                        bGPDframe *gpf,
1171                                        const float opacity,
1172                                        const float tintcolor[4],
1173                                        const bool custonion)
1174 {
1175   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1176   Depsgraph *depsgraph = DRW_context_state_get()->depsgraph;
1177
1178   float viewmatrix[4][4];
1179
1180   /* get parent matrix and save as static data */
1181   ED_gpencil_parent_location(depsgraph, ob, gpd, gpl, viewmatrix);
1182   copy_m4_m4(gpf->runtime.viewmatrix, viewmatrix);
1183
1184   for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1185     MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1186     if (gp_style == NULL) {
1187       continue;
1188     }
1189     copy_v4_v4(gps->runtime.tmp_stroke_rgba, gp_style->stroke_rgba);
1190     copy_v4_v4(gps->runtime.tmp_fill_rgba, gp_style->fill_rgba);
1191
1192     int id = stl->storage->shgroup_id;
1193     /* check if stroke can be drawn */
1194     if (gpencil_can_draw_stroke(gp_style, gps, true, false) == false) {
1195       continue;
1196     }
1197     /* limit the number of shading groups */
1198     if (id >= GPENCIL_MAX_SHGROUPS) {
1199       continue;
1200     }
1201
1202     /* stroke */
1203     gpencil_add_stroke_vertexdata(cache, ob, gpl, gpf, gps, opacity, tintcolor, true, custonion);
1204
1205     stl->storage->shgroup_id++;
1206   }
1207 }
1208
1209 /* draw onion-skinning for a layer */
1210 static void gpencil_draw_onionskins(GpencilBatchCache *cache,
1211                                     void *vedata,
1212                                     Object *ob,
1213                                     bGPdata *gpd,
1214                                     bGPDlayer *gpl,
1215                                     bGPDframe *gpf)
1216 {
1217
1218   const float default_color[3] = {UNPACK3(U.gpencil_new_layer_col)};
1219   const float alpha = 1.0f;
1220   float color[4];
1221   int idx;
1222   float fac = 1.0f;
1223   int step = 0;
1224   int mode = 0;
1225   bool colflag = false;
1226   bGPDframe *gpf_loop = NULL;
1227   int last = gpf->framenum;
1228
1229   colflag = (bool)gpd->onion_flag & GP_ONION_GHOST_PREVCOL;
1230
1231   /* -------------------------------
1232    * 1) Draw Previous Frames First
1233    * ------------------------------- */
1234   step = gpd->gstep;
1235   mode = gpd->onion_mode;
1236
1237   if (gpd->onion_flag & GP_ONION_GHOST_PREVCOL) {
1238     copy_v3_v3(color, gpd->gcolor_prev);
1239   }
1240   else {
1241     copy_v3_v3(color, default_color);
1242   }
1243
1244   idx = 0;
1245   for (bGPDframe *gf = gpf->prev; gf; gf = gf->prev) {
1246     /* only selected frames */
1247     if ((mode == GP_ONION_MODE_SELECTED) && ((gf->flag & GP_FRAME_SELECT) == 0)) {
1248       continue;
1249     }
1250     /* absolute range */
1251     if (mode == GP_ONION_MODE_ABSOLUTE) {
1252       if ((gpf->framenum - gf->framenum) > step) {
1253         break;
1254       }
1255     }
1256     /* relative range */
1257     if (mode == GP_ONION_MODE_RELATIVE) {
1258       idx++;
1259       if (idx > step) {
1260         break;
1261       }
1262     }
1263     /* alpha decreases with distance from curframe index */
1264     if (mode != GP_ONION_MODE_SELECTED) {
1265       if (mode == GP_ONION_MODE_ABSOLUTE) {
1266         fac = 1.0f - ((float)(gpf->framenum - gf->framenum) / (float)(step + 1));
1267       }
1268       else {
1269         fac = 1.0f - ((float)idx / (float)(step + 1));
1270       }
1271       color[3] = alpha * fac * 0.66f;
1272     }
1273     else {
1274       idx++;
1275       fac = alpha - ((1.1f - (1.0f / (float)idx)) * 0.66f);
1276       color[3] = fac;
1277     }
1278
1279     /* if loop option, save the frame to use later */
1280     if ((mode != GP_ONION_MODE_ABSOLUTE) && (gpd->onion_flag & GP_ONION_LOOP)) {
1281       gpf_loop = gf;
1282     }
1283
1284     gpencil_get_onion_alpha(color, gpd);
1285     gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gf, color[3], color, colflag);
1286   }
1287   /* -------------------------------
1288    * 2) Now draw next frames
1289    * ------------------------------- */
1290   step = gpd->gstep_next;
1291   mode = gpd->onion_mode;
1292
1293   if (gpd->onion_flag & GP_ONION_GHOST_NEXTCOL) {
1294     copy_v3_v3(color, gpd->gcolor_next);
1295   }
1296   else {
1297     copy_v3_v3(color, default_color);
1298   }
1299
1300   idx = 0;
1301   for (bGPDframe *gf = gpf->next; gf; gf = gf->next) {
1302     /* only selected frames */
1303     if ((mode == GP_ONION_MODE_SELECTED) && ((gf->flag & GP_FRAME_SELECT) == 0)) {
1304       continue;
1305     }
1306     /* absolute range */
1307     if (mode == GP_ONION_MODE_ABSOLUTE) {
1308       if ((gf->framenum - gpf->framenum) > step) {
1309         break;
1310       }
1311     }
1312     /* relative range */
1313     if (mode == GP_ONION_MODE_RELATIVE) {
1314       idx++;
1315       if (idx > step) {
1316         break;
1317       }
1318     }
1319     /* alpha decreases with distance from curframe index */
1320     if (mode != GP_ONION_MODE_SELECTED) {
1321       if (mode == GP_ONION_MODE_ABSOLUTE) {
1322         fac = 1.0f - ((float)(gf->framenum - gpf->framenum) / (float)(step + 1));
1323       }
1324       else {
1325         fac = 1.0f - ((float)idx / (float)(step + 1));
1326       }
1327       color[3] = alpha * fac * 0.66f;
1328     }
1329     else {
1330       idx++;
1331       fac = alpha - ((1.1f - (1.0f / (float)idx)) * 0.66f);
1332       color[3] = fac;
1333     }
1334
1335     gpencil_get_onion_alpha(color, gpd);
1336     gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gf, color[3], color, colflag);
1337     if (last < gf->framenum) {
1338       last = gf->framenum;
1339     }
1340   }
1341
1342   /* Draw first frame in blue for loop mode */
1343   if ((gpd->onion_flag & GP_ONION_LOOP) && (gpf_loop != NULL)) {
1344     if ((last == gpf->framenum) || (gpf->next == NULL)) {
1345       gpencil_get_onion_alpha(color, gpd);
1346       gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gpf_loop, color[3], color, colflag);
1347     }
1348   }
1349 }
1350
1351 static void gpencil_copy_frame(bGPDframe *gpf, bGPDframe *derived_gpf)
1352 {
1353   derived_gpf->prev = gpf->prev;
1354   derived_gpf->next = gpf->next;
1355   derived_gpf->framenum = gpf->framenum;
1356   derived_gpf->flag = gpf->flag;
1357   derived_gpf->key_type = gpf->key_type;
1358   derived_gpf->runtime = gpf->runtime;
1359   copy_m4_m4(derived_gpf->runtime.viewmatrix, gpf->runtime.viewmatrix);
1360
1361   /* copy strokes */
1362   BLI_listbase_clear(&derived_gpf->strokes);
1363   for (bGPDstroke *gps_src = gpf->strokes.first; gps_src; gps_src = gps_src->next) {
1364     /* make copy of source stroke */
1365     bGPDstroke *gps_dst = BKE_gpencil_stroke_duplicate(gps_src);
1366     BLI_addtail(&derived_gpf->strokes, gps_dst);
1367   }
1368 }
1369
1370 /* Triangulate stroke for high quality fill (this is done only if cache is null or stroke was modified) */
1371 void DRW_gpencil_triangulate_stroke_fill(Object *ob, bGPDstroke *gps)
1372 {
1373   BLI_assert(gps->totpoints >= 3);
1374
1375   bGPdata *gpd = (bGPdata *)ob->data;
1376
1377   /* allocate memory for temporary areas */
1378   gps->tot_triangles = gps->totpoints - 2;
1379   uint(*tmp_triangles)[3] = MEM_mallocN(sizeof(*tmp_triangles) * gps->tot_triangles,
1380                                         "GP Stroke temp triangulation");
1381   float(*points2d)[2] = MEM_mallocN(sizeof(*points2d) * gps->totpoints,
1382                                     "GP Stroke temp 2d points");
1383   float(*uv)[2] = MEM_mallocN(sizeof(*uv) * gps->totpoints, "GP Stroke temp 2d uv data");
1384
1385   int direction = 0;
1386
1387   /* convert to 2d and triangulate */
1388   BKE_gpencil_stroke_2d_flat(gps->points, gps->totpoints, points2d, &direction);
1389   BLI_polyfill_calc(points2d, (uint)gps->totpoints, direction, tmp_triangles);
1390
1391   /* calc texture coordinates automatically */
1392   float minv[2];
1393   float maxv[2];
1394   /* first needs bounding box data */
1395   if (gpd->flag & GP_DATA_UV_ADAPTIVE) {
1396     gpencil_calc_2d_bounding_box(points2d, gps->totpoints, minv, maxv);
1397   }
1398   else {
1399     ARRAY_SET_ITEMS(minv, -1.0f, -1.0f);
1400     ARRAY_SET_ITEMS(maxv, 1.0f, 1.0f);
1401   }
1402
1403   /* calc uv data */
1404   gpencil_calc_stroke_fill_uv(points2d, gps->totpoints, minv, maxv, uv);
1405
1406   /* Number of triangles */
1407   gps->tot_triangles = gps->totpoints - 2;
1408   /* save triangulation data in stroke cache */
1409   if (gps->tot_triangles > 0) {
1410     if (gps->triangles == NULL) {
1411       gps->triangles = MEM_callocN(sizeof(*gps->triangles) * gps->tot_triangles,
1412                                    "GP Stroke triangulation");
1413     }
1414     else {
1415       gps->triangles = MEM_recallocN(gps->triangles, sizeof(*gps->triangles) * gps->tot_triangles);
1416     }
1417
1418     for (int i = 0; i < gps->tot_triangles; i++) {
1419       bGPDtriangle *stroke_triangle = &gps->triangles[i];
1420       memcpy(gps->triangles[i].verts, tmp_triangles[i], sizeof(uint[3]));
1421       /* copy texture coordinates */
1422       copy_v2_v2(stroke_triangle->uv[0], uv[tmp_triangles[i][0]]);
1423       copy_v2_v2(stroke_triangle->uv[1], uv[tmp_triangles[i][1]]);
1424       copy_v2_v2(stroke_triangle->uv[2], uv[tmp_triangles[i][2]]);
1425     }
1426   }
1427   else {
1428     /* No triangles needed - Free anything allocated previously */
1429     if (gps->triangles) {
1430       MEM_freeN(gps->triangles);
1431     }
1432
1433     gps->triangles = NULL;
1434   }
1435
1436   /* disable recalculation flag */
1437   if (gps->flag & GP_STROKE_RECALC_GEOMETRY) {
1438     gps->flag &= ~GP_STROKE_RECALC_GEOMETRY;
1439   }
1440
1441   /* clear memory */
1442   MEM_SAFE_FREE(tmp_triangles);
1443   MEM_SAFE_FREE(points2d);
1444   MEM_SAFE_FREE(uv);
1445 }
1446
1447 /* draw stroke in drawing buffer */
1448 void DRW_gpencil_populate_buffer_strokes(GPENCIL_e_data *e_data,
1449                                          void *vedata,
1450                                          ToolSettings *ts,
1451                                          Object *ob)
1452 {
1453   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1454   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1455   const DRWContextState *draw_ctx = DRW_context_state_get();
1456   View3D *v3d = draw_ctx->v3d;
1457   const bool overlay = v3d != NULL ? (bool)((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) : true;
1458   Brush *brush = BKE_paint_brush(&ts->gp_paint->paint);
1459   bGPdata *gpd_eval = ob->data;
1460   /* need the original to avoid cow overhead while drawing */
1461   bGPdata *gpd = (bGPdata *)DEG_get_original_id(&gpd_eval->id);
1462
1463   MaterialGPencilStyle *gp_style = NULL;
1464   float obscale = mat4_to_scale(ob->obmat);
1465
1466   /* use the brush material */
1467   Material *ma = BKE_gpencil_object_material_get_from_brush(ob, brush);
1468   if (ma != NULL) {
1469     gp_style = ma->gp_style;
1470   }
1471   /* this is not common, but avoid any special situations when brush could be without material */
1472   if (gp_style == NULL) {
1473     gp_style = BKE_material_gpencil_settings_get(ob, ob->actcol);
1474   }
1475
1476   /* drawing strokes */
1477   /* Check if may need to draw the active stroke cache, only if this layer is the active layer
1478    * that is being edited. (Stroke buffer is currently stored in gp-data)
1479    */
1480   if (gpd->runtime.sbuffer_size > 0) {
1481     if ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0) {
1482       /* It should also be noted that sbuffer contains temporary point types
1483        * i.e. tGPspoints NOT bGPDspoints
1484        */
1485       short lthick = brush->size * obscale;
1486
1487       /* save gradient info */
1488       stl->storage->gradient_f = brush->gpencil_settings->gradient_f;
1489       copy_v2_v2(stl->storage->gradient_s, brush->gpencil_settings->gradient_s);
1490       stl->storage->use_follow_path = (gp_style->flag & GP_STYLE_COLOR_LOCK_DOTS) ? 0 : 1;
1491
1492       /* if only one point, don't need to draw buffer because the user has no time to see it */
1493       if (gpd->runtime.sbuffer_size > 1) {
1494         if ((gp_style) && (gp_style->mode == GP_STYLE_MODE_LINE)) {
1495           stl->g_data->shgrps_drawing_stroke = DRW_gpencil_shgroup_stroke_create(
1496               e_data,
1497               vedata,
1498               psl->drawing_pass,
1499               e_data->gpencil_stroke_sh,
1500               NULL,
1501               gpd,
1502               NULL,
1503               NULL,
1504               gp_style,
1505               -1,
1506               false,
1507               1.0f,
1508               (const int *)stl->storage->shade_render);
1509         }
1510         else {
1511           stl->g_data->shgrps_drawing_stroke = DRW_gpencil_shgroup_point_create(
1512               e_data,
1513               vedata,
1514               psl->drawing_pass,
1515               e_data->gpencil_point_sh,
1516               NULL,
1517               gpd,
1518               NULL,
1519               NULL,
1520               gp_style,
1521               -1,
1522               false,
1523               1.0f,
1524               (const int *)stl->storage->shade_render);
1525         }
1526
1527         /* clean previous version of the batch */
1528         if (stl->storage->buffer_stroke) {
1529           GPU_BATCH_DISCARD_SAFE(e_data->batch_buffer_stroke);
1530           MEM_SAFE_FREE(e_data->batch_buffer_stroke);
1531           stl->storage->buffer_stroke = false;
1532         }
1533
1534         /* use unit matrix because the buffer is in screen space and does not need conversion */
1535         if (gpd->runtime.mode == GP_STYLE_MODE_LINE) {
1536           e_data->batch_buffer_stroke = DRW_gpencil_get_buffer_stroke_geom(gpd, lthick);
1537         }
1538         else {
1539           e_data->batch_buffer_stroke = DRW_gpencil_get_buffer_point_geom(gpd, lthick);
1540         }
1541
1542         /* buffer strokes, must show stroke always */
1543         DRW_shgroup_call_add(stl->g_data->shgrps_drawing_stroke,
1544                              e_data->batch_buffer_stroke,
1545                              stl->storage->unit_matrix);
1546
1547         if ((gpd->runtime.sbuffer_size >= 3) &&
1548             (gpd->runtime.sfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) &&
1549             ((gpd->runtime.sbuffer_sflag & GP_STROKE_NOFILL) == 0) &&
1550             ((brush->gpencil_settings->flag & GP_BRUSH_DISSABLE_LASSO) == 0) &&
1551             (gp_style->flag & GP_STYLE_FILL_SHOW)) {
1552           /* if not solid, fill is simulated with solid color */
1553           if (gpd->runtime.bfill_style > 0) {
1554             gpd->runtime.sfill[3] = 0.5f;
1555           }
1556           stl->g_data->shgrps_drawing_fill = DRW_shgroup_create(e_data->gpencil_drawing_fill_sh,
1557                                                                 psl->drawing_pass);
1558
1559           /* clean previous version of the batch */
1560           if (stl->storage->buffer_fill) {
1561             GPU_BATCH_DISCARD_SAFE(e_data->batch_buffer_fill);
1562             MEM_SAFE_FREE(e_data->batch_buffer_fill);
1563             stl->storage->buffer_fill = false;
1564           }
1565
1566           e_data->batch_buffer_fill = DRW_gpencil_get_buffer_fill_geom(gpd);
1567           DRW_shgroup_call_add(stl->g_data->shgrps_drawing_fill,
1568                                e_data->batch_buffer_fill,
1569                                stl->storage->unit_matrix);
1570           stl->storage->buffer_fill = true;
1571         }
1572         stl->storage->buffer_stroke = true;
1573       }
1574     }
1575   }
1576
1577   /* control points for primitives and speed guide */
1578   const bool is_cppoint = (gpd->runtime.tot_cp_points > 0);
1579   const bool is_speed_guide = (ts->gp_sculpt.guide.use_guide &&
1580                                (draw_ctx->object_mode == OB_MODE_PAINT_GPENCIL));
1581   const bool is_show_gizmo = (((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) &&
1582                               ((v3d->gizmo_flag & V3D_GIZMO_HIDE_TOOL) == 0));
1583
1584   if ((overlay) && (is_cppoint || is_speed_guide) && (is_show_gizmo) &&
1585       ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0)) {
1586     DRWShadingGroup *shgrp = DRW_shgroup_create(e_data->gpencil_edit_point_sh, psl->drawing_pass);
1587     const float *viewport_size = DRW_viewport_size_get();
1588     DRW_shgroup_uniform_vec2(shgrp, "Viewport", viewport_size, 1);
1589
1590     /* clean previous version of the batch */
1591     if (stl->storage->buffer_ctrlpoint) {
1592       GPU_BATCH_DISCARD_SAFE(e_data->batch_buffer_ctrlpoint);
1593       MEM_SAFE_FREE(e_data->batch_buffer_ctrlpoint);
1594       stl->storage->buffer_ctrlpoint = false;
1595     }
1596
1597     e_data->batch_buffer_ctrlpoint = DRW_gpencil_get_buffer_ctrlpoint_geom(gpd);
1598
1599     DRW_shgroup_call_add(shgrp, e_data->batch_buffer_ctrlpoint, stl->storage->unit_matrix);
1600
1601     stl->storage->buffer_ctrlpoint = true;
1602   }
1603 }
1604
1605 /* create all missing batches */
1606 static void DRW_gpencil_create_batches(GpencilBatchCache *cache)
1607 {
1608   if ((cache->b_point.vbo) && (cache->b_point.batch == NULL)) {
1609     cache->b_point.batch = GPU_batch_create_ex(
1610         GPU_PRIM_POINTS, cache->b_point.vbo, NULL, GPU_BATCH_OWNS_VBO);
1611   }
1612   if ((cache->b_stroke.vbo) && (cache->b_stroke.batch == NULL)) {
1613     cache->b_stroke.batch = GPU_batch_create_ex(
1614         GPU_PRIM_LINE_STRIP_ADJ, cache->b_stroke.vbo, NULL, GPU_BATCH_OWNS_VBO);
1615   }
1616   if ((cache->b_fill.vbo) && (cache->b_fill.batch == NULL)) {
1617     cache->b_fill.batch = GPU_batch_create_ex(
1618         GPU_PRIM_TRIS, cache->b_fill.vbo, NULL, GPU_BATCH_OWNS_VBO);
1619   }
1620   if ((cache->b_edit.vbo) && (cache->b_edit.batch == NULL)) {
1621     cache->b_edit.batch = GPU_batch_create_ex(
1622         GPU_PRIM_POINTS, cache->b_edit.vbo, NULL, GPU_BATCH_OWNS_VBO);
1623   }
1624   if ((cache->b_edlin.vbo) && (cache->b_edlin.batch == NULL)) {
1625     cache->b_edlin.batch = GPU_batch_create_ex(
1626         GPU_PRIM_LINE_STRIP, cache->b_edlin.vbo, NULL, GPU_BATCH_OWNS_VBO);
1627   }
1628 }
1629
1630 /* create all shading groups */
1631 static void DRW_gpencil_shgroups_create(GPENCIL_e_data *e_data,
1632                                         void *vedata,
1633                                         Object *ob,
1634                                         GpencilBatchCache *cache,
1635                                         tGPencilObjectCache *cache_ob)
1636 {
1637   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1638   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1639   bGPdata *gpd = (bGPdata *)ob->data;
1640   DRWPass *stroke_pass = GPENCIL_3D_DRAWMODE(ob, gpd) ? psl->stroke_pass_3d : psl->stroke_pass_2d;
1641
1642   GpencilBatchGroup *elm = NULL;
1643   DRWShadingGroup *shgrp = NULL;
1644   tGPencilObjectCache_shgrp *array_elm = NULL;
1645
1646   bGPDlayer *gpl = NULL;
1647   bGPDlayer *gpl_prev = NULL;
1648   int idx = 0;
1649   bool tag_first = false;
1650
1651   int start_stroke = 0;
1652   int start_point = 0;
1653   int start_fill = 0;
1654   int start_edit = 0;
1655   int start_edlin = 0;
1656
1657   for (int i = 0; i < cache->grp_used; i++) {
1658     elm = &cache->grp_cache[i];
1659     array_elm = &cache_ob->shgrp_array[idx];
1660     const float scale = cache_ob->scale;
1661
1662     /* save last group when change */
1663     if (gpl_prev == NULL) {
1664       gpl_prev = elm->gpl;
1665       tag_first = true;
1666     }
1667     else {
1668       if (elm->gpl != gpl_prev) {
1669         /* first layer is always blend Normal */
1670         array_elm->mode = idx == 0 ? eGplBlendMode_Normal : gpl->blend_mode;
1671         array_elm->end_shgrp = shgrp;
1672         gpl_prev = elm->gpl;
1673         tag_first = true;
1674         idx++;
1675       }
1676     }
1677
1678     gpl = elm->gpl;
1679     bGPDframe *gpf = elm->gpf;
1680     bGPDstroke *gps = elm->gps;
1681     MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1682     /* if the user switch used material from data to object,
1683      * the material could not be available */
1684     if (gp_style == NULL) {
1685       break;
1686     }
1687
1688     /* limit the number of shading groups */
1689     if (i >= GPENCIL_MAX_SHGROUPS) {
1690       break;
1691     }
1692
1693     switch (elm->type) {
1694       case eGpencilBatchGroupType_Stroke: {
1695         const int len = elm->vertex_idx - start_stroke;
1696
1697         shgrp = DRW_gpencil_shgroup_stroke_create(e_data,
1698                                                   vedata,
1699                                                   stroke_pass,
1700                                                   e_data->gpencil_stroke_sh,
1701                                                   ob,
1702                                                   gpd,
1703                                                   gpl,
1704                                                   gps,
1705                                                   gp_style,
1706                                                   stl->storage->shgroup_id,
1707                                                   elm->onion,
1708                                                   scale,
1709                                                   cache_ob->shading_type);
1710
1711         DRW_shgroup_call_range_add(shgrp,
1712                                    cache->b_stroke.batch,
1713                                    (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1714                                                             cache_ob->obmat,
1715                                    start_stroke,
1716                                    len);
1717
1718         stl->storage->shgroup_id++;
1719         start_stroke = elm->vertex_idx;
1720         break;
1721       }
1722       case eGpencilBatchGroupType_Point: {
1723         const int len = elm->vertex_idx - start_point;
1724
1725         shgrp = DRW_gpencil_shgroup_point_create(e_data,
1726                                                  vedata,
1727                                                  stroke_pass,
1728                                                  e_data->gpencil_point_sh,
1729                                                  ob,
1730                                                  gpd,
1731                                                  gpl,
1732                                                  gps,
1733                                                  gp_style,
1734                                                  stl->storage->shgroup_id,
1735                                                  elm->onion,
1736                                                  scale,
1737                                                  cache_ob->shading_type);
1738
1739         DRW_shgroup_call_range_add(shgrp,
1740                                    cache->b_point.batch,
1741                                    (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1742                                                             cache_ob->obmat,
1743                                    start_point,
1744                                    len);
1745
1746         stl->storage->shgroup_id++;
1747         start_point = elm->vertex_idx;
1748         break;
1749       }
1750       case eGpencilBatchGroupType_Fill: {
1751         const int len = elm->vertex_idx - start_fill;
1752
1753         shgrp = DRW_gpencil_shgroup_fill_create(e_data,
1754                                                 vedata,
1755                                                 stroke_pass,
1756                                                 e_data->gpencil_fill_sh,
1757                                                 ob,
1758                                                 gpd,
1759                                                 gpl,
1760                                                 gp_style,
1761                                                 stl->storage->shgroup_id,
1762                                                 cache_ob->shading_type);
1763
1764         DRW_shgroup_call_range_add(shgrp,
1765                                    cache->b_fill.batch,
1766                                    (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1767                                                             cache_ob->obmat,
1768                                    start_fill,
1769                                    len);
1770
1771         stl->storage->shgroup_id++;
1772         start_fill = elm->vertex_idx;
1773         break;
1774       }
1775       case eGpencilBatchGroupType_Edit: {
1776         if (stl->g_data->shgrps_edit_point) {
1777           const int len = elm->vertex_idx - start_edit;
1778           /* use always the same group */
1779           DRW_shgroup_call_range_add(stl->g_data->shgrps_edit_point,
1780                                      cache->b_edit.batch,
1781                                      (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1782                                                               cache_ob->obmat,
1783                                      start_edit,
1784                                      len);
1785
1786           start_edit = elm->vertex_idx;
1787         }
1788         break;
1789       }
1790       case eGpencilBatchGroupType_Edlin: {
1791         if (stl->g_data->shgrps_edit_line) {
1792           const int len = elm->vertex_idx - start_edlin;
1793           /* use always the same group */
1794           DRW_shgroup_call_range_add(stl->g_data->shgrps_edit_line,
1795                                      cache->b_edlin.batch,
1796                                      (!cache_ob->is_dup_ob) ? gpf->runtime.viewmatrix :
1797                                                               cache_ob->obmat,
1798                                      start_edlin,
1799                                      len);
1800
1801           start_edlin = elm->vertex_idx;
1802         }
1803         break;
1804       }
1805       default: {
1806         break;
1807       }
1808     }
1809     /* save first group */
1810     if ((shgrp != NULL) && (tag_first)) {
1811       array_elm = &cache_ob->shgrp_array[idx];
1812       array_elm->mode = idx == 0 ? eGplBlendMode_Normal : gpl->blend_mode;
1813       array_elm->clamp_layer = gpl->flag & GP_LAYER_USE_MASK;
1814       array_elm->blend_opacity = gpl->opacity;
1815       array_elm->init_shgrp = shgrp;
1816       cache_ob->tot_layers++;
1817
1818       tag_first = false;
1819     }
1820   }
1821
1822   /* save last group */
1823   if (shgrp != NULL) {
1824     array_elm->mode = idx == 0 ? eGplBlendMode_Normal : gpl->blend_mode;
1825     array_elm->end_shgrp = shgrp;
1826   }
1827 }
1828 /* populate a datablock for multiedit (no onions, no modifiers) */
1829 void DRW_gpencil_populate_multiedit(GPENCIL_e_data *e_data,
1830                                     void *vedata,
1831                                     Object *ob,
1832                                     tGPencilObjectCache *cache_ob)
1833 {
1834   bGPdata *gpd = (bGPdata *)ob->data;
1835   bGPDframe *gpf = NULL;
1836
1837   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1838   const DRWContextState *draw_ctx = DRW_context_state_get();
1839   int cfra_eval = (int)DEG_get_ctime(draw_ctx->depsgraph);
1840   GpencilBatchCache *cache = gpencil_batch_cache_get(ob, cfra_eval);
1841
1842   /* check if playing animation */
1843   const bool playing = stl->storage->is_playing;
1844
1845   /* calc max size of VBOs */
1846   gpencil_calc_vertex(stl, cache_ob, cache, gpd, cfra_eval);
1847
1848   /* draw strokes */
1849   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1850     /* don't draw layer if hidden */
1851     if (gpl->flag & GP_LAYER_HIDE) {
1852       continue;
1853     }
1854
1855     /* list of frames to draw */
1856     if (!playing) {
1857       for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1858         if ((gpf == gpl->actframe) || (gpf->flag & GP_FRAME_SELECT)) {
1859           gpencil_draw_strokes(cache,
1860                                e_data,
1861                                vedata,
1862                                ob,
1863                                gpd,
1864                                gpl,
1865                                gpf,
1866                                gpf,
1867                                gpl->opacity,
1868                                gpl->tintcolor,
1869                                false,
1870                                cache_ob);
1871         }
1872       }
1873     }
1874     else {
1875       gpf = BKE_gpencil_layer_getframe(gpl, cfra_eval, GP_GETFRAME_USE_PREV);
1876       if (gpf) {
1877         gpencil_draw_strokes(cache,
1878                              e_data,
1879                              vedata,
1880                              ob,
1881                              gpd,
1882                              gpl,
1883                              gpf,
1884                              gpf,
1885                              gpl->opacity,
1886                              gpl->tintcolor,
1887                              false,
1888                              cache_ob);
1889       }
1890     }
1891   }
1892
1893   /* create batchs and shading groups */
1894   DRW_gpencil_create_batches(cache);
1895   DRW_gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
1896
1897   cache->is_dirty = false;
1898 }
1899
1900 /* helper for populate a complete grease pencil datablock */
1901 void DRW_gpencil_populate_datablock(GPENCIL_e_data *e_data,
1902                                     void *vedata,
1903                                     Object *ob,
1904                                     tGPencilObjectCache *cache_ob)
1905 {
1906   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1907   const DRWContextState *draw_ctx = DRW_context_state_get();
1908   const ViewLayer *view_layer = DEG_get_evaluated_view_layer(draw_ctx->depsgraph);
1909   Scene *scene = draw_ctx->scene;
1910
1911   bGPdata *gpd = (bGPdata *)ob->data;
1912
1913   View3D *v3d = draw_ctx->v3d;
1914   int cfra_eval = (int)DEG_get_ctime(draw_ctx->depsgraph);
1915
1916   bGPDframe *derived_gpf = NULL;
1917   const bool main_onion = v3d != NULL ? (v3d->gp_flag & V3D_GP_SHOW_ONION_SKIN) : true;
1918   const bool do_onion = (bool)((gpd->flag & GP_DATA_STROKE_WEIGHTMODE) == 0) && main_onion &&
1919                         DRW_gpencil_onion_active(gpd);
1920   const bool overlay = v3d != NULL ? (bool)((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) : true;
1921   const bool time_remap = BKE_gpencil_has_time_modifiers(ob);
1922
1923   float opacity;
1924   bGPDframe *gpf = NULL;
1925   bGPDlayer *gpl_active = BKE_gpencil_layer_getactive(gpd);
1926
1927   /* check if playing animation */
1928   const bool playing = stl->storage->is_playing;
1929
1930   GpencilBatchCache *cache = gpencil_batch_cache_get(ob, cfra_eval);
1931
1932   /* if object is duplicate, only create shading groups */
1933   if (cache_ob->is_dup_ob) {
1934     DRW_gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
1935     return;
1936   }
1937
1938   /* calc max size of VBOs */
1939   gpencil_calc_vertex(stl, cache_ob, cache, gpd, cfra_eval);
1940
1941   /* init general modifiers data */
1942   if (!stl->storage->simplify_modif) {
1943     if ((cache->is_dirty) && (ob->greasepencil_modifiers.first)) {
1944       BKE_gpencil_lattice_init(ob);
1945     }
1946   }
1947   /* draw normal strokes */
1948   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1949     /* don't draw layer if hidden */
1950     if (gpl->flag & GP_LAYER_HIDE) {
1951       continue;
1952     }
1953
1954     const bool is_solomode = GPENCIL_PAINT_MODE(gpd) && (!playing) && (!stl->storage->is_render) &&
1955                              (gpl->flag & GP_LAYER_SOLO_MODE);
1956
1957     /* filter view layer to gp layers in the same view layer (for compo) */
1958     if ((stl->storage->is_render) && (gpl->viewlayername[0] != '\0')) {
1959       if (!STREQ(view_layer->name, gpl->viewlayername)) {
1960         continue;
1961       }
1962     }
1963
1964     /* remap time */
1965     int remap_cfra = cfra_eval;
1966     if ((time_remap) && (!stl->storage->simplify_modif)) {
1967       remap_cfra = BKE_gpencil_time_modifier(
1968           draw_ctx->depsgraph, scene, ob, gpl, cfra_eval, stl->storage->is_render);
1969     }
1970
1971     gpf = BKE_gpencil_layer_getframe(gpl, remap_cfra, GP_GETFRAME_USE_PREV);
1972     if (gpf == NULL) {
1973       continue;
1974     }
1975
1976     /* if solo mode, display only frames with keyframe in the current frame */
1977     if ((is_solomode) && (gpf->framenum != remap_cfra)) {
1978       continue;
1979     }
1980
1981     opacity = gpl->opacity;
1982     /* if pose mode, maybe the overlay to fade geometry is enabled */
1983     if ((draw_ctx->obact) && (draw_ctx->object_mode == OB_MODE_POSE) &&
1984         (v3d->overlay.flag & V3D_OVERLAY_BONE_SELECT)) {
1985       opacity = opacity * v3d->overlay.xray_alpha_bone;
1986     }
1987     /* fade no active layers */
1988     if ((overlay) && (draw_ctx->object_mode == OB_MODE_PAINT_GPENCIL) &&
1989         (v3d->gp_flag & V3D_GP_FADE_NOACTIVE_LAYERS) && (draw_ctx->obact) &&
1990         (draw_ctx->obact == ob) && (gpl != gpl_active)) {
1991       opacity = opacity * v3d->overlay.gpencil_fade_layer;
1992     }
1993
1994     /* create derived frames array data or expand */
1995     int derived_idx = BLI_findindex(&gpd->layers, gpl);
1996     derived_gpf = &cache->derived_array[derived_idx];
1997
1998     /* if no derived frame or dirty cache, create a new one */
1999     if ((derived_gpf == NULL) || (cache->is_dirty)) {
2000       if (derived_gpf != NULL) {
2001         /* first clear temp data */
2002         BKE_gpencil_free_frame_runtime_data(derived_gpf);
2003       }
2004       /* create new data (do not assign new memory)*/
2005       gpencil_copy_frame(gpf, derived_gpf);
2006     }
2007
2008     /* draw onion skins */
2009     if (!ID_IS_LINKED(&gpd->id)) {
2010       if ((do_onion) && (gpl->onion_flag & GP_LAYER_ONIONSKIN) &&
2011           ((!playing) || (gpd->onion_flag & GP_ONION_GHOST_ALWAYS)) && (!cache_ob->is_dup_ob) &&
2012           (gpd->id.us <= 1)) {
2013         if (((!stl->storage->is_render) && (overlay)) ||
2014             ((stl->storage->is_render) && (gpd->onion_flag & GP_ONION_GHOST_ALWAYS))) {
2015           gpencil_draw_onionskins(cache, vedata, ob, gpd, gpl, gpf);
2016         }
2017       }
2018     }
2019     /* draw normal strokes */
2020     gpencil_draw_strokes(cache,
2021                          e_data,
2022                          vedata,
2023                          ob,
2024                          gpd,
2025                          gpl,
2026                          gpf,
2027                          derived_gpf,
2028                          opacity,
2029                          gpl->tintcolor,
2030                          false,
2031                          cache_ob);
2032   }
2033
2034   /* clear any lattice data */
2035   if ((cache->is_dirty) && (ob->greasepencil_modifiers.first)) {
2036     BKE_gpencil_lattice_clear(ob);
2037   }
2038
2039   /* create batchs and shading groups */
2040   DRW_gpencil_create_batches(cache);
2041   DRW_gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
2042
2043   cache->is_dirty = false;
2044 }
2045
2046 void DRW_gpencil_populate_particles(GPENCIL_e_data *e_data, GHash *gh_objects, void *vedata)
2047 {
2048   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
2049
2050   /* add particles */
2051   for (int i = 0; i < stl->g_data->gp_cache_used; i++) {
2052     tGPencilObjectCache *cache_ob = &stl->g_data->gp_object_cache[i];
2053     if (cache_ob->is_dup_ob) {
2054       /* reasign duplicate objects because memory for particles is not available
2055        * and need to use the original datablock and runtime data */
2056       Object *ob = (Object *)BLI_ghash_lookup(gh_objects, cache_ob->name);
2057       if (ob) {
2058         cache_ob->ob = ob;
2059         cache_ob->gpd = (bGPdata *)ob->data;
2060         GpencilBatchCache *cache = ob->runtime.gpencil_cache;
2061         if (cache != NULL) {
2062           DRW_gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
2063         }
2064       }
2065     }
2066   }
2067 }