9b75521794676f10dffd83c29ced13c973585b0d
[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 CHECKER 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 && 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 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) && (gp_style->flag & GP_STYLE_FILL_SHOW) &&
244           ((gp_style->fill_rgba[3] > GPENCIL_ALPHA_OPACITY_THRESH) || (gp_style->fill_style > 0) ||
245            (gpl->blend_mode != eGplBlendMode_Regular))) {
246         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         copy_v3_v3(stl->shgroups[id].wire_color, wire_col);
338         stl->shgroups[id].wire_color[3] = alpha;
339         break;
340       }
341       default: {
342         copy_v4_v4(stl->shgroups[id].wire_color, color);
343         break;
344       }
345     }
346   }
347   else {
348     copy_v4_v4(stl->shgroups[id].wire_color, color);
349   }
350
351   /* if solid, the alpha must be set to 1.0 */
352   if (stl->shgroups[id].shading_type[0] == OB_SOLID) {
353     stl->shgroups[id].wire_color[3] = 1.0f;
354   }
355 }
356
357 /* create shading group for filling */
358 static DRWShadingGroup *gpencil_shgroup_fill_create(GPENCIL_Data *vedata,
359                                                     DRWPass *pass,
360                                                     GPUShader *shader,
361                                                     Object *ob,
362                                                     bGPdata *gpd,
363                                                     bGPDlayer *gpl,
364                                                     MaterialGPencilStyle *gp_style,
365                                                     int id,
366                                                     int shading_type[2])
367 {
368   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
369   const DRWContextState *draw_ctx = DRW_context_state_get();
370   View3D *v3d = draw_ctx->v3d;
371
372   /* e_data.gpencil_fill_sh */
373   DRWShadingGroup *grp = DRW_shgroup_create(shader, pass);
374
375   DRW_shgroup_uniform_vec4(grp, "color2", gp_style->mix_rgba, 1);
376
377   /* set style type */
378   switch (gp_style->fill_style) {
379     case GP_STYLE_FILL_STYLE_SOLID:
380       stl->shgroups[id].fill_style = SOLID;
381       break;
382     case GP_STYLE_FILL_STYLE_GRADIENT:
383       if (gp_style->gradient_type == GP_STYLE_GRADIENT_LINEAR) {
384         stl->shgroups[id].fill_style = GRADIENT;
385       }
386       else {
387         stl->shgroups[id].fill_style = RADIAL;
388       }
389       break;
390     case GP_STYLE_FILL_STYLE_CHECKER:
391       stl->shgroups[id].fill_style = CHECKER;
392       break;
393     case GP_STYLE_FILL_STYLE_TEXTURE:
394       if (gp_style->flag & GP_STYLE_FILL_PATTERN) {
395         stl->shgroups[id].fill_style = PATTERN;
396       }
397       else {
398         stl->shgroups[id].fill_style = TEXTURE;
399       }
400       break;
401     default:
402       stl->shgroups[id].fill_style = GP_STYLE_FILL_STYLE_SOLID;
403       break;
404   }
405   DRW_shgroup_uniform_int(grp, "fill_type", &stl->shgroups[id].fill_style, 1);
406
407   DRW_shgroup_uniform_float(grp, "mix_factor", &gp_style->mix_factor, 1);
408
409   DRW_shgroup_uniform_float(grp, "gradient_angle", &gp_style->gradient_angle, 1);
410   DRW_shgroup_uniform_float(grp, "gradient_radius", &gp_style->gradient_radius, 1);
411   DRW_shgroup_uniform_float(grp, "pattern_gridsize", &gp_style->pattern_gridsize, 1);
412   DRW_shgroup_uniform_vec2(grp, "gradient_scale", gp_style->gradient_scale, 1);
413   DRW_shgroup_uniform_vec2(grp, "gradient_shift", gp_style->gradient_shift, 1);
414
415   DRW_shgroup_uniform_float(grp, "texture_angle", &gp_style->texture_angle, 1);
416   DRW_shgroup_uniform_vec2(grp, "texture_scale", gp_style->texture_scale, 1);
417   DRW_shgroup_uniform_vec2(grp, "texture_offset", gp_style->texture_offset, 1);
418   DRW_shgroup_uniform_float(grp, "texture_opacity", &gp_style->texture_opacity, 1);
419   DRW_shgroup_uniform_float(grp, "layer_opacity", &gpl->opacity, 1);
420
421   stl->shgroups[id].texture_mix = gp_style->flag & GP_STYLE_FILL_TEX_MIX ? 1 : 0;
422   DRW_shgroup_uniform_int(grp, "texture_mix", &stl->shgroups[id].texture_mix, 1);
423
424   stl->shgroups[id].texture_flip = gp_style->flag & GP_STYLE_COLOR_FLIP_FILL ? 1 : 0;
425   DRW_shgroup_uniform_int(grp, "texture_flip", &stl->shgroups[id].texture_flip, 1);
426
427   stl->shgroups[id].xray_mode = (ob->dtx & OB_DRAWXRAY) ? GP_XRAY_FRONT : GP_XRAY_3DSPACE;
428   DRW_shgroup_uniform_int(grp, "xraymode", &stl->shgroups[id].xray_mode, 1);
429   DRW_shgroup_uniform_int(grp, "drawmode", (const int *)&gpd->draw_mode, 1);
430
431   /* viewport x-ray */
432   stl->shgroups[id].is_xray = (ob->dt == OB_WIRE) ? 1 : stl->storage->is_xray;
433   DRW_shgroup_uniform_int(grp, "viewport_xray", (const int *)&stl->shgroups[id].is_xray, 1);
434
435   /* shading type */
436   stl->shgroups[id].shading_type[0] = GPENCIL_USE_SOLID(stl) ? (int)OB_RENDER : shading_type[0];
437   if (v3d) {
438     stl->shgroups[id].shading_type[1] = ((stl->shgroups[id].shading_type[0] == OB_WIRE) ?
439                                              v3d->shading.wire_color_type :
440                                              v3d->shading.color_type);
441   }
442
443   DRW_shgroup_uniform_int(grp, "shading_type", &stl->shgroups[id].shading_type[0], 2);
444
445   /* wire color */
446   set_wireframe_color(ob, gpl, v3d, stl, gp_style, id, true);
447   DRW_shgroup_uniform_vec4(grp, "wire_color", stl->shgroups[id].wire_color, 1);
448
449   /* image texture */
450   if ((gp_style->flag & GP_STYLE_FILL_TEX_MIX) ||
451       (gp_style->fill_style & GP_STYLE_FILL_STYLE_TEXTURE)) {
452     ImBuf *ibuf;
453     Image *image = gp_style->ima;
454     ImageUser iuser = {NULL};
455     void *lock;
456
457     iuser.ok = true;
458
459     ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
460
461     if (ibuf == NULL || ibuf->rect == NULL) {
462       BKE_image_release_ibuf(image, ibuf, NULL);
463     }
464     else {
465       GPUTexture *texture = GPU_texture_from_blender(gp_style->ima, &iuser, GL_TEXTURE_2D);
466       DRW_shgroup_uniform_texture(grp, "myTexture", texture);
467       DRW_shgroup_uniform_bool_copy(
468           grp, "myTexturePremultiplied", (image->alpha_mode == IMA_ALPHA_PREMUL));
469
470       stl->shgroups[id].texture_clamp = gp_style->flag & GP_STYLE_COLOR_TEX_CLAMP ? 1 : 0;
471       DRW_shgroup_uniform_int(grp, "texture_clamp", &stl->shgroups[id].texture_clamp, 1);
472
473       BKE_image_release_ibuf(image, ibuf, NULL);
474     }
475   }
476   else {
477     /* if no texture defined, need a blank texture to avoid errors in draw manager */
478     DRW_shgroup_uniform_texture(grp, "myTexture", stl->g_data->gpencil_blank_texture);
479     stl->shgroups[id].texture_clamp = 0;
480     DRW_shgroup_uniform_int(grp, "texture_clamp", &stl->shgroups[id].texture_clamp, 1);
481   }
482
483   return grp;
484 }
485
486 /* check if some onion is enabled */
487 bool gpencil_onion_active(bGPdata *gpd)
488 {
489   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
490     if (gpl->onion_flag & GP_LAYER_ONIONSKIN) {
491       return true;
492     }
493   }
494   return false;
495 }
496
497 /* create shading group for strokes */
498 DRWShadingGroup *gpencil_shgroup_stroke_create(GPENCIL_Data *vedata,
499                                                DRWPass *pass,
500                                                GPUShader *shader,
501                                                Object *ob,
502                                                bGPdata *gpd,
503                                                bGPDlayer *gpl,
504                                                bGPDstroke *gps,
505                                                MaterialGPencilStyle *gp_style,
506                                                int id,
507                                                bool onion,
508                                                const float scale,
509                                                const int shading_type[2])
510 {
511   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
512   const float *viewport_size = DRW_viewport_size_get();
513   const DRWContextState *draw_ctx = DRW_context_state_get();
514   View3D *v3d = draw_ctx->v3d;
515
516   /* e_data.gpencil_stroke_sh */
517   DRWShadingGroup *grp = DRW_shgroup_create(shader, pass);
518
519   DRW_shgroup_uniform_vec2(grp, "Viewport", viewport_size, 1);
520
521   DRW_shgroup_uniform_float(grp, "pixsize", stl->storage->pixsize, 1);
522
523   /* avoid wrong values */
524   if ((gpd) && (gpd->pixfactor == 0.0f)) {
525     gpd->pixfactor = GP_DEFAULT_PIX_FACTOR;
526   }
527
528   /* object scale and depth */
529   if ((ob) && (id > -1)) {
530     stl->shgroups[id].obj_scale = scale;
531     DRW_shgroup_uniform_float(grp, "objscale", &stl->shgroups[id].obj_scale, 1);
532     stl->shgroups[id].keep_size = (int)((gpd) && (gpd->flag & GP_DATA_STROKE_KEEPTHICKNESS));
533     DRW_shgroup_uniform_int(grp, "keep_size", &stl->shgroups[id].keep_size, 1);
534
535     stl->shgroups[id].stroke_style = gp_style->stroke_style;
536     stl->shgroups[id].color_type = GPENCIL_COLOR_SOLID;
537     if ((gp_style->stroke_style == GP_STYLE_STROKE_STYLE_TEXTURE) && (!onion)) {
538       stl->shgroups[id].color_type = GPENCIL_COLOR_TEXTURE;
539       if (gp_style->flag & GP_STYLE_STROKE_PATTERN) {
540         stl->shgroups[id].color_type = GPENCIL_COLOR_PATTERN;
541       }
542     }
543     DRW_shgroup_uniform_int(grp, "color_type", &stl->shgroups[id].color_type, 1);
544     DRW_shgroup_uniform_float(grp, "pixfactor", &gpd->pixfactor, 1);
545
546     stl->shgroups[id].caps_mode[0] = gps->caps[0];
547     stl->shgroups[id].caps_mode[1] = gps->caps[1];
548     DRW_shgroup_uniform_int(grp, "caps_mode", &stl->shgroups[id].caps_mode[0], 2);
549
550     stl->shgroups[id].gradient_f = gps->gradient_f;
551     copy_v2_v2(stl->shgroups[id].gradient_s, gps->gradient_s);
552     DRW_shgroup_uniform_float(grp, "gradient_f", &stl->shgroups[id].gradient_f, 1);
553
554     /* viewport x-ray */
555     stl->shgroups[id].is_xray = (ob->dt == OB_WIRE) ? 1 : stl->storage->is_xray;
556     DRW_shgroup_uniform_int(grp, "viewport_xray", (const int *)&stl->shgroups[id].is_xray, 1);
557
558     stl->shgroups[id].shading_type[0] = (GPENCIL_USE_SOLID(stl) || onion) ? (int)OB_RENDER :
559                                                                             shading_type[0];
560     if (v3d) {
561       stl->shgroups[id].shading_type[1] = ((stl->shgroups[id].shading_type[0] == OB_WIRE) ?
562                                                v3d->shading.wire_color_type :
563                                                v3d->shading.color_type);
564     }
565     DRW_shgroup_uniform_int(grp, "shading_type", &stl->shgroups[id].shading_type[0], 2);
566
567     /* wire color */
568     set_wireframe_color(ob, gpl, v3d, stl, gp_style, id, false);
569     DRW_shgroup_uniform_vec4(grp, "wire_color", stl->shgroups[id].wire_color, 1);
570
571     /* mix stroke factor */
572     stl->shgroups[id].mix_stroke_factor = (gp_style->flag & GP_STYLE_STROKE_TEX_MIX) ?
573                                               gp_style->mix_stroke_factor :
574                                               0.0f;
575     DRW_shgroup_uniform_float(grp, "mix_stroke_factor", &stl->shgroups[id].mix_stroke_factor, 1);
576   }
577   else {
578     stl->storage->obj_scale = 1.0f;
579     stl->storage->keep_size = 0;
580     stl->storage->pixfactor = GP_DEFAULT_PIX_FACTOR;
581     DRW_shgroup_uniform_float(grp, "objscale", &stl->storage->obj_scale, 1);
582     DRW_shgroup_uniform_int(grp, "keep_size", &stl->storage->keep_size, 1);
583     DRW_shgroup_uniform_int(grp, "color_type", &stl->storage->color_type, 1);
584     if (gpd) {
585       DRW_shgroup_uniform_float(grp, "pixfactor", &gpd->pixfactor, 1);
586     }
587     else {
588       DRW_shgroup_uniform_float(grp, "pixfactor", &stl->storage->pixfactor, 1);
589     }
590     const int zero[2] = {0, 0};
591     DRW_shgroup_uniform_int(grp, "caps_mode", &zero[0], 2);
592
593     DRW_shgroup_uniform_float(grp, "gradient_f", &stl->storage->gradient_f, 1);
594
595     /* viewport x-ray */
596     DRW_shgroup_uniform_int(grp, "viewport_xray", &stl->storage->is_xray, 1);
597     DRW_shgroup_uniform_int(grp, "shading_type", (const int *)&stl->storage->shade_render, 2);
598
599     /* mix stroke factor */
600     stl->storage->mix_stroke_factor = (gp_style->flag & GP_STYLE_STROKE_TEX_MIX) ?
601                                           gp_style->mix_stroke_factor :
602                                           0.0f;
603     DRW_shgroup_uniform_float(grp, "mix_stroke_factor", &stl->storage->mix_stroke_factor, 1);
604   }
605
606   DRW_shgroup_uniform_vec4(grp, "colormix", gp_style->stroke_rgba, 1);
607
608   if ((gpd) && (id > -1)) {
609     stl->shgroups[id].xray_mode = (ob->dtx & OB_DRAWXRAY) ? GP_XRAY_FRONT : GP_XRAY_3DSPACE;
610     DRW_shgroup_uniform_int(grp, "xraymode", &stl->shgroups[id].xray_mode, 1);
611   }
612   else {
613     /* for drawing always on predefined z-depth */
614     DRW_shgroup_uniform_int(grp, "xraymode", &stl->storage->xray, 1);
615   }
616
617   /* image texture for pattern */
618   if ((gp_style) && (gp_style->stroke_style == GP_STYLE_STROKE_STYLE_TEXTURE) && (!onion)) {
619     ImBuf *ibuf;
620     Image *image = gp_style->sima;
621     ImageUser iuser = {NULL};
622     void *lock;
623
624     iuser.ok = true;
625
626     ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
627
628     if (ibuf == NULL || ibuf->rect == NULL) {
629       BKE_image_release_ibuf(image, ibuf, NULL);
630     }
631     else {
632       GPUTexture *texture = GPU_texture_from_blender(gp_style->sima, &iuser, GL_TEXTURE_2D);
633       DRW_shgroup_uniform_texture(grp, "myTexture", texture);
634       DRW_shgroup_uniform_bool_copy(
635           grp, "myTexturePremultiplied", (image->alpha_mode == IMA_ALPHA_PREMUL));
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", stl->g_data->gpencil_blank_texture);
643   }
644
645   return grp;
646 }
647
648 /* create shading group for points */
649 static DRWShadingGroup *gpencil_shgroup_point_create(GPENCIL_Data *vedata,
650                                                      DRWPass *pass,
651                                                      GPUShader *shader,
652                                                      Object *ob,
653                                                      bGPdata *gpd,
654                                                      bGPDlayer *gpl,
655                                                      bGPDstroke *gps,
656                                                      MaterialGPencilStyle *gp_style,
657                                                      int id,
658                                                      bool onion,
659                                                      const float scale,
660                                                      const int shading_type[2])
661 {
662   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
663   const float *viewport_size = DRW_viewport_size_get();
664   const DRWContextState *draw_ctx = DRW_context_state_get();
665   View3D *v3d = draw_ctx->v3d;
666
667   /* e_data.gpencil_stroke_sh */
668   DRWShadingGroup *grp = DRW_shgroup_create(shader, pass);
669
670   DRW_shgroup_uniform_vec2(grp, "Viewport", viewport_size, 1);
671   DRW_shgroup_uniform_float(grp, "pixsize", stl->storage->pixsize, 1);
672
673   /* avoid wrong values */
674   if ((gpd) && (gpd->pixfactor == 0.0f)) {
675     gpd->pixfactor = GP_DEFAULT_PIX_FACTOR;
676   }
677
678   /* object scale and depth */
679   if ((ob) && (id > -1)) {
680     stl->shgroups[id].obj_scale = scale;
681     DRW_shgroup_uniform_float(grp, "objscale", &stl->shgroups[id].obj_scale, 1);
682     stl->shgroups[id].keep_size = (int)((gpd) && (gpd->flag & GP_DATA_STROKE_KEEPTHICKNESS));
683     DRW_shgroup_uniform_int(grp, "keep_size", &stl->shgroups[id].keep_size, 1);
684
685     stl->shgroups[id].mode = gp_style->mode;
686     stl->shgroups[id].stroke_style = gp_style->stroke_style;
687     stl->shgroups[id].color_type = GPENCIL_COLOR_SOLID;
688     if ((gp_style->stroke_style == GP_STYLE_STROKE_STYLE_TEXTURE) && (!onion)) {
689       stl->shgroups[id].color_type = GPENCIL_COLOR_TEXTURE;
690       if (gp_style->flag & GP_STYLE_STROKE_PATTERN) {
691         stl->shgroups[id].color_type = GPENCIL_COLOR_PATTERN;
692       }
693     }
694     DRW_shgroup_uniform_int(grp, "color_type", &stl->shgroups[id].color_type, 1);
695     DRW_shgroup_uniform_int(grp, "mode", &stl->shgroups[id].mode, 1);
696     DRW_shgroup_uniform_float(grp, "pixfactor", &gpd->pixfactor, 1);
697
698     stl->shgroups[id].gradient_f = gps->gradient_f;
699     copy_v2_v2(stl->shgroups[id].gradient_s, gps->gradient_s);
700     DRW_shgroup_uniform_float(grp, "gradient_f", &stl->shgroups[id].gradient_f, 1);
701     DRW_shgroup_uniform_vec2(grp, "gradient_s", stl->shgroups[id].gradient_s, 1);
702
703     /* viewport x-ray */
704     stl->shgroups[id].is_xray = (ob->dt == OB_WIRE) ? 1 : stl->storage->is_xray;
705     DRW_shgroup_uniform_int(grp, "viewport_xray", (const int *)&stl->shgroups[id].is_xray, 1);
706
707     stl->shgroups[id].shading_type[0] = (GPENCIL_USE_SOLID(stl) || onion) ? (int)OB_RENDER :
708                                                                             shading_type[0];
709     if (v3d) {
710       stl->shgroups[id].shading_type[1] = ((stl->shgroups[id].shading_type[0] == OB_WIRE) ?
711                                                v3d->shading.wire_color_type :
712                                                v3d->shading.color_type);
713     }
714     DRW_shgroup_uniform_int(grp, "shading_type", &stl->shgroups[id].shading_type[0], 2);
715
716     /* wire color */
717     set_wireframe_color(ob, gpl, v3d, stl, gp_style, id, false);
718     DRW_shgroup_uniform_vec4(grp, "wire_color", stl->shgroups[id].wire_color, 1);
719
720     /* mix stroke factor */
721     stl->shgroups[id].mix_stroke_factor = (gp_style->flag & GP_STYLE_STROKE_TEX_MIX) ?
722                                               gp_style->mix_stroke_factor :
723                                               0.0f;
724     DRW_shgroup_uniform_float(grp, "mix_stroke_factor", &stl->shgroups[id].mix_stroke_factor, 1);
725
726     /* lock rotation of dots and boxes */
727     stl->shgroups[id].alignment_mode = gp_style->alignment_mode;
728     DRW_shgroup_uniform_int(grp, "alignment_mode", &stl->shgroups[id].alignment_mode, 1);
729   }
730   else {
731     stl->storage->obj_scale = 1.0f;
732     stl->storage->keep_size = 0;
733     stl->storage->pixfactor = GP_DEFAULT_PIX_FACTOR;
734     stl->storage->mode = gp_style->mode;
735     DRW_shgroup_uniform_float(grp, "objscale", &stl->storage->obj_scale, 1);
736     DRW_shgroup_uniform_int(grp, "keep_size", &stl->storage->keep_size, 1);
737     DRW_shgroup_uniform_int(grp, "color_type", &stl->storage->color_type, 1);
738     DRW_shgroup_uniform_int(grp, "mode", &stl->storage->mode, 1);
739     if (gpd) {
740       DRW_shgroup_uniform_float(grp, "pixfactor", &gpd->pixfactor, 1);
741     }
742     else {
743       DRW_shgroup_uniform_float(grp, "pixfactor", &stl->storage->pixfactor, 1);
744     }
745
746     DRW_shgroup_uniform_float(grp, "gradient_f", &stl->storage->gradient_f, 1);
747     DRW_shgroup_uniform_vec2(grp, "gradient_s", stl->storage->gradient_s, 1);
748
749     /* viewport x-ray */
750     DRW_shgroup_uniform_int(grp, "viewport_xray", &stl->storage->is_xray, 1);
751     DRW_shgroup_uniform_int(grp, "shading_type", (const int *)&stl->storage->shade_render, 2);
752
753     /* mix stroke factor */
754     stl->storage->mix_stroke_factor = (gp_style->flag & GP_STYLE_STROKE_TEX_MIX) ?
755                                           gp_style->mix_stroke_factor :
756                                           0.0f;
757     DRW_shgroup_uniform_float(grp, "mix_stroke_factor", &stl->storage->mix_stroke_factor, 1);
758
759     /* lock rotation of dots and boxes */
760     DRW_shgroup_uniform_int(grp, "alignment_mode", &stl->storage->alignment_mode, 1);
761   }
762
763   DRW_shgroup_uniform_vec4(grp, "colormix", gp_style->stroke_rgba, 1);
764
765   if ((gpd) && (id > -1)) {
766     stl->shgroups[id].xray_mode = (ob->dtx & OB_DRAWXRAY) ? GP_XRAY_FRONT : GP_XRAY_3DSPACE;
767     DRW_shgroup_uniform_int(grp, "xraymode", (const int *)&stl->shgroups[id].xray_mode, 1);
768   }
769   else {
770     /* for drawing always on predefined z-depth */
771     DRW_shgroup_uniform_int(grp, "xraymode", &stl->storage->xray, 1);
772   }
773
774   /* image texture */
775   if ((gp_style) && (gp_style->stroke_style == GP_STYLE_STROKE_STYLE_TEXTURE) && (!onion)) {
776     ImBuf *ibuf;
777     Image *image = gp_style->sima;
778     ImageUser iuser = {NULL};
779     void *lock;
780
781     iuser.ok = true;
782
783     ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
784
785     if (ibuf == NULL || ibuf->rect == NULL) {
786       BKE_image_release_ibuf(image, ibuf, NULL);
787     }
788     else {
789       GPUTexture *texture = GPU_texture_from_blender(gp_style->sima, &iuser, GL_TEXTURE_2D);
790       DRW_shgroup_uniform_texture(grp, "myTexture", texture);
791       DRW_shgroup_uniform_bool_copy(
792           grp, "myTexturePremultiplied", (image->alpha_mode == IMA_ALPHA_PREMUL));
793
794       BKE_image_release_ibuf(image, ibuf, NULL);
795     }
796   }
797   else {
798     /* if no texture defined, need a blank texture to avoid errors in draw manager */
799     DRW_shgroup_uniform_texture(grp, "myTexture", stl->g_data->gpencil_blank_texture);
800   }
801
802   return grp;
803 }
804
805 /* add fill vertex info  */
806 static void gpencil_add_fill_vertexdata(GpencilBatchCache *cache,
807                                         Object *ob,
808                                         bGPDlayer *gpl,
809                                         bGPDframe *gpf,
810                                         bGPDstroke *gps,
811                                         float opacity,
812                                         const float tintcolor[4],
813                                         const bool onion,
814                                         const bool custonion)
815 {
816   MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
817   if (gps->totpoints >= 3) {
818     float tfill[4];
819     /* set color using material, tint color and opacity */
820     interp_v3_v3v3(tfill, gps->runtime.tmp_fill_rgba, tintcolor, tintcolor[3]);
821     tfill[3] = gps->runtime.tmp_fill_rgba[3] * opacity;
822     if ((tfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) || (gp_style->fill_style > 0) ||
823         (gpl->blend_mode != eGplBlendMode_Regular)) {
824       if (cache->is_dirty) {
825         const float *color;
826         if (!onion) {
827           color = tfill;
828         }
829         else {
830           if (custonion) {
831             color = tintcolor;
832           }
833           else {
834             ARRAY_SET_ITEMS(tfill, UNPACK3(gps->runtime.tmp_fill_rgba), tintcolor[3]);
835             color = tfill;
836           }
837         }
838         /* create vertex data */
839         const int old_len = cache->b_fill.vbo_len;
840         gpencil_get_fill_geom(&cache->b_fill, ob, gps, color);
841
842         /* add to list of groups */
843         if (old_len < cache->b_fill.vbo_len) {
844           cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
845                                                      gpl,
846                                                      gpf,
847                                                      gps,
848                                                      eGpencilBatchGroupType_Fill,
849                                                      onion,
850                                                      cache->b_fill.vbo_len,
851                                                      &cache->grp_size,
852                                                      &cache->grp_used);
853         }
854       }
855     }
856   }
857 }
858
859 /* add stroke vertex info */
860 static void gpencil_add_stroke_vertexdata(GpencilBatchCache *cache,
861                                           Object *ob,
862                                           bGPDlayer *gpl,
863                                           bGPDframe *gpf,
864                                           bGPDstroke *gps,
865                                           const float opacity,
866                                           const float tintcolor[4],
867                                           const bool onion,
868                                           const bool custonion)
869 {
870   float tcolor[4];
871   float ink[4];
872   short sthickness;
873   MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
874   const int alignment_mode = (gp_style) ? gp_style->alignment_mode : GP_STYLE_FOLLOW_PATH;
875
876   /* set color using base color, tint color and opacity */
877   if (cache->is_dirty) {
878     if (!onion) {
879       /* if special stroke, use fill color as stroke color */
880       if (gps->flag & GP_STROKE_NOFILL) {
881         interp_v3_v3v3(tcolor, gps->runtime.tmp_fill_rgba, tintcolor, tintcolor[3]);
882         tcolor[3] = gps->runtime.tmp_fill_rgba[3] * opacity;
883       }
884       else {
885         interp_v3_v3v3(tcolor, gps->runtime.tmp_stroke_rgba, tintcolor, tintcolor[3]);
886         tcolor[3] = gps->runtime.tmp_stroke_rgba[3] * opacity;
887       }
888       copy_v4_v4(ink, tcolor);
889     }
890     else {
891       if (custonion) {
892         copy_v4_v4(ink, tintcolor);
893       }
894       else {
895         ARRAY_SET_ITEMS(tcolor, UNPACK3(gps->runtime.tmp_stroke_rgba), opacity);
896         copy_v4_v4(ink, tcolor);
897       }
898     }
899
900     sthickness = gps->thickness + gpl->line_change;
901     CLAMP_MIN(sthickness, 1);
902
903     if ((gps->totpoints > 1) && (gp_style->mode == GP_STYLE_MODE_LINE)) {
904       /* create vertex data */
905       const int old_len = cache->b_stroke.vbo_len;
906       gpencil_get_stroke_geom(&cache->b_stroke, gps, sthickness, ink);
907
908       /* add to list of groups */
909       if (old_len < cache->b_stroke.vbo_len) {
910         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
911                                                    gpl,
912                                                    gpf,
913                                                    gps,
914                                                    eGpencilBatchGroupType_Stroke,
915                                                    onion,
916                                                    cache->b_stroke.vbo_len,
917                                                    &cache->grp_size,
918                                                    &cache->grp_used);
919       }
920     }
921     else {
922       /* create vertex data */
923       const int old_len = cache->b_point.vbo_len;
924       gpencil_get_point_geom(&cache->b_point, gps, sthickness, ink, alignment_mode);
925
926       /* add to list of groups */
927       if (old_len < cache->b_point.vbo_len) {
928         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
929                                                    gpl,
930                                                    gpf,
931                                                    gps,
932                                                    eGpencilBatchGroupType_Point,
933                                                    onion,
934                                                    cache->b_point.vbo_len,
935                                                    &cache->grp_size,
936                                                    &cache->grp_used);
937       }
938     }
939   }
940 }
941
942 /* add edit points vertex info */
943 static void gpencil_add_editpoints_vertexdata(GpencilBatchCache *cache,
944                                               Object *ob,
945                                               bGPdata *gpd,
946                                               bGPDlayer *gpl,
947                                               bGPDframe *gpf,
948                                               bGPDstroke *gps)
949 {
950   const DRWContextState *draw_ctx = DRW_context_state_get();
951   View3D *v3d = draw_ctx->v3d;
952   MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
953
954   /* alpha factor for edit points/line to make them more subtle */
955   float edit_alpha = v3d->vertex_opacity;
956
957   if (GPENCIL_ANY_EDIT_MODE(gpd)) {
958     Object *obact = DRW_context_state_get()->obact;
959     if ((!obact) || (obact->type != OB_GPENCIL)) {
960       return;
961     }
962     const bool is_weight_paint = (gpd) && (gpd->flag & GP_DATA_STROKE_WEIGHTMODE);
963
964     if (cache->is_dirty) {
965       if ((obact == ob) && ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) &&
966           (v3d->gp_flag & V3D_GP_SHOW_EDIT_LINES)) {
967         /* line of the original stroke */
968         gpencil_get_edlin_geom(&cache->b_edlin, gps, edit_alpha, gpd->flag);
969
970         /* add to list of groups */
971         cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
972                                                    gpl,
973                                                    gpf,
974                                                    gps,
975                                                    eGpencilBatchGroupType_Edlin,
976                                                    false,
977                                                    cache->b_edlin.vbo_len,
978                                                    &cache->grp_size,
979                                                    &cache->grp_used);
980       }
981       /* edit points */
982       if ((gps->flag & GP_STROKE_SELECT) || (is_weight_paint)) {
983         if ((gpl->flag & GP_LAYER_UNLOCK_COLOR) ||
984             ((gp_style->flag & GP_STYLE_COLOR_LOCKED) == 0)) {
985           if (obact == ob) {
986             gpencil_get_edit_geom(&cache->b_edit, gps, edit_alpha, gpd->flag);
987
988             /* add to list of groups */
989             cache->grp_cache = gpencil_group_cache_add(cache->grp_cache,
990                                                        gpl,
991                                                        gpf,
992                                                        gps,
993                                                        eGpencilBatchGroupType_Edit,
994                                                        false,
995                                                        cache->b_edit.vbo_len,
996                                                        &cache->grp_size,
997                                                        &cache->grp_used);
998           }
999         }
1000       }
1001     }
1002   }
1003 }
1004
1005 /* main function to draw strokes */
1006 static void gpencil_draw_strokes(GpencilBatchCache *cache,
1007                                  GPENCIL_e_data *e_data,
1008                                  void *vedata,
1009                                  Object *ob,
1010                                  bGPdata *gpd,
1011                                  bGPDlayer *gpl,
1012                                  bGPDframe *src_gpf,
1013                                  bGPDframe *derived_gpf,
1014                                  const float opacity,
1015                                  const float tintcolor[4],
1016                                  const bool custonion,
1017                                  tGPencilObjectCache *cache_ob)
1018 {
1019   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1020   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1021   const DRWContextState *draw_ctx = DRW_context_state_get();
1022   Scene *scene = draw_ctx->scene;
1023   View3D *v3d = draw_ctx->v3d;
1024   bGPDstroke *gps, *src_gps;
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   if ((cache_ob != NULL) && (cache_ob->is_dup_ob)) {
1039     copy_m4_m4(derived_gpf->runtime.parent_obmat, cache_ob->obmat);
1040   }
1041   else {
1042     ED_gpencil_parent_location(depsgraph, ob, gpd, gpl, derived_gpf->runtime.parent_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       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_Regular)) {
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_Regular)) {
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_Regular))) {
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   /* get parent matrix and save as static data */
1181   ED_gpencil_parent_location(depsgraph, ob, gpd, gpl, gpf->runtime.parent_obmat);
1182
1183   for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1184     MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1185     if (gp_style == NULL) {
1186       continue;
1187     }
1188     copy_v4_v4(gps->runtime.tmp_stroke_rgba, gp_style->stroke_rgba);
1189     copy_v4_v4(gps->runtime.tmp_fill_rgba, gp_style->fill_rgba);
1190
1191     int id = stl->storage->shgroup_id;
1192     /* check if stroke can be drawn */
1193     if (gpencil_can_draw_stroke(gp_style, gps, true, false) == false) {
1194       continue;
1195     }
1196     /* limit the number of shading groups */
1197     if (id >= GPENCIL_MAX_SHGROUPS) {
1198       continue;
1199     }
1200
1201     /* stroke */
1202     gpencil_add_stroke_vertexdata(cache, ob, gpl, gpf, gps, opacity, tintcolor, true, custonion);
1203
1204     stl->storage->shgroup_id++;
1205   }
1206 }
1207
1208 /* draw onion-skinning for a layer */
1209 static void gpencil_draw_onionskins(GpencilBatchCache *cache,
1210                                     void *vedata,
1211                                     Object *ob,
1212                                     bGPdata *gpd,
1213                                     bGPDlayer *gpl,
1214                                     bGPDframe *gpf)
1215 {
1216
1217   const float default_color[3] = {UNPACK3(U.gpencil_new_layer_col)};
1218   const float alpha = 1.0f;
1219   float color[4];
1220   int idx;
1221   float fac = 1.0f;
1222   int step = 0;
1223   int mode = 0;
1224   bool colflag = false;
1225   bGPDframe *gpf_loop = NULL;
1226   int last = gpf->framenum;
1227
1228   colflag = (bool)gpd->onion_flag & GP_ONION_GHOST_PREVCOL;
1229   const short onion_keytype = gpd->onion_keytype;
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     /* verify keyframe type */
1251     if ((onion_keytype > -1) && (gf->key_type != onion_keytype)) {
1252       continue;
1253     }
1254     /* absolute range */
1255     if (mode == GP_ONION_MODE_ABSOLUTE) {
1256       if ((gpf->framenum - gf->framenum) > step) {
1257         break;
1258       }
1259     }
1260     /* relative range */
1261     if (mode == GP_ONION_MODE_RELATIVE) {
1262       idx++;
1263       if (idx > step) {
1264         break;
1265       }
1266     }
1267     /* alpha decreases with distance from curframe index */
1268     if (mode != GP_ONION_MODE_SELECTED) {
1269       if (mode == GP_ONION_MODE_ABSOLUTE) {
1270         fac = 1.0f - ((float)(gpf->framenum - gf->framenum) / (float)(step + 1));
1271       }
1272       else {
1273         fac = 1.0f - ((float)idx / (float)(step + 1));
1274       }
1275       color[3] = alpha * fac * 0.66f;
1276     }
1277     else {
1278       idx++;
1279       fac = alpha - ((1.1f - (1.0f / (float)idx)) * 0.66f);
1280       color[3] = fac;
1281     }
1282
1283     /* if loop option, save the frame to use later */
1284     if ((mode != GP_ONION_MODE_ABSOLUTE) && (gpd->onion_flag & GP_ONION_LOOP)) {
1285       gpf_loop = gf;
1286     }
1287
1288     gpencil_get_onion_alpha(color, gpd);
1289     gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gf, color[3], color, colflag);
1290   }
1291   /* -------------------------------
1292    * 2) Now draw next frames
1293    * ------------------------------- */
1294   step = gpd->gstep_next;
1295   mode = gpd->onion_mode;
1296
1297   if (gpd->onion_flag & GP_ONION_GHOST_NEXTCOL) {
1298     copy_v3_v3(color, gpd->gcolor_next);
1299   }
1300   else {
1301     copy_v3_v3(color, default_color);
1302   }
1303
1304   idx = 0;
1305   for (bGPDframe *gf = gpf->next; gf; gf = gf->next) {
1306     /* only selected frames */
1307     if ((mode == GP_ONION_MODE_SELECTED) && ((gf->flag & GP_FRAME_SELECT) == 0)) {
1308       continue;
1309     }
1310     /* verify keyframe type */
1311     if ((onion_keytype > -1) && (gf->key_type != onion_keytype)) {
1312       continue;
1313     }
1314     /* absolute range */
1315     if (mode == GP_ONION_MODE_ABSOLUTE) {
1316       if ((gf->framenum - gpf->framenum) > step) {
1317         break;
1318       }
1319     }
1320     /* relative range */
1321     if (mode == GP_ONION_MODE_RELATIVE) {
1322       idx++;
1323       if (idx > step) {
1324         break;
1325       }
1326     }
1327     /* alpha decreases with distance from curframe index */
1328     if (mode != GP_ONION_MODE_SELECTED) {
1329       if (mode == GP_ONION_MODE_ABSOLUTE) {
1330         fac = 1.0f - ((float)(gf->framenum - gpf->framenum) / (float)(step + 1));
1331       }
1332       else {
1333         fac = 1.0f - ((float)idx / (float)(step + 1));
1334       }
1335       color[3] = alpha * fac * 0.66f;
1336     }
1337     else {
1338       idx++;
1339       fac = alpha - ((1.1f - (1.0f / (float)idx)) * 0.66f);
1340       color[3] = fac;
1341     }
1342
1343     gpencil_get_onion_alpha(color, gpd);
1344     gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gf, color[3], color, colflag);
1345     if (last < gf->framenum) {
1346       last = gf->framenum;
1347     }
1348   }
1349
1350   /* Draw first frame in blue for loop mode */
1351   if ((gpd->onion_flag & GP_ONION_LOOP) && (gpf_loop != NULL)) {
1352     if ((last == gpf->framenum) || (gpf->next == NULL)) {
1353       gpencil_get_onion_alpha(color, gpd);
1354       gpencil_draw_onion_strokes(cache, vedata, ob, gpd, gpl, gpf_loop, color[3], color, colflag);
1355     }
1356   }
1357 }
1358
1359 static void gpencil_copy_frame(bGPDframe *gpf, bGPDframe *derived_gpf)
1360 {
1361   derived_gpf->prev = gpf->prev;
1362   derived_gpf->next = gpf->next;
1363   derived_gpf->framenum = gpf->framenum;
1364   derived_gpf->flag = gpf->flag;
1365   derived_gpf->key_type = gpf->key_type;
1366   derived_gpf->runtime = gpf->runtime;
1367   copy_m4_m4(derived_gpf->runtime.parent_obmat, gpf->runtime.parent_obmat);
1368
1369   /* copy strokes */
1370   BLI_listbase_clear(&derived_gpf->strokes);
1371   for (bGPDstroke *gps_src = gpf->strokes.first; gps_src; gps_src = gps_src->next) {
1372     /* make copy of source stroke */
1373     bGPDstroke *gps_dst = BKE_gpencil_stroke_duplicate(gps_src);
1374     BLI_addtail(&derived_gpf->strokes, gps_dst);
1375   }
1376 }
1377
1378 /* Triangulate stroke for high quality fill (this is done only if cache is null or stroke was
1379  * modified) */
1380 void gpencil_triangulate_stroke_fill(Object *ob, bGPDstroke *gps)
1381 {
1382   BLI_assert(gps->totpoints >= 3);
1383
1384   bGPdata *gpd = (bGPdata *)ob->data;
1385
1386   /* allocate memory for temporary areas */
1387   gps->tot_triangles = gps->totpoints - 2;
1388   uint(*tmp_triangles)[3] = MEM_mallocN(sizeof(*tmp_triangles) * gps->tot_triangles,
1389                                         "GP Stroke temp triangulation");
1390   float(*points2d)[2] = MEM_mallocN(sizeof(*points2d) * gps->totpoints,
1391                                     "GP Stroke temp 2d points");
1392   float(*uv)[2] = MEM_mallocN(sizeof(*uv) * gps->totpoints, "GP Stroke temp 2d uv data");
1393
1394   int direction = 0;
1395
1396   /* convert to 2d and triangulate */
1397   BKE_gpencil_stroke_2d_flat(gps->points, gps->totpoints, points2d, &direction);
1398   BLI_polyfill_calc(points2d, (uint)gps->totpoints, direction, tmp_triangles);
1399
1400   /* calc texture coordinates automatically */
1401   float minv[2];
1402   float maxv[2];
1403   /* first needs bounding box data */
1404   if (gpd->flag & GP_DATA_UV_ADAPTIVE) {
1405     gpencil_calc_2d_bounding_box(points2d, gps->totpoints, minv, maxv);
1406   }
1407   else {
1408     ARRAY_SET_ITEMS(minv, -1.0f, -1.0f);
1409     ARRAY_SET_ITEMS(maxv, 1.0f, 1.0f);
1410   }
1411
1412   /* calc uv data */
1413   gpencil_calc_stroke_fill_uv(points2d, gps->totpoints, minv, maxv, uv);
1414
1415   /* Number of triangles */
1416   gps->tot_triangles = gps->totpoints - 2;
1417   /* save triangulation data in stroke cache */
1418   if (gps->tot_triangles > 0) {
1419     if (gps->triangles == NULL) {
1420       gps->triangles = MEM_callocN(sizeof(*gps->triangles) * gps->tot_triangles,
1421                                    "GP Stroke triangulation");
1422     }
1423     else {
1424       gps->triangles = MEM_recallocN(gps->triangles, sizeof(*gps->triangles) * gps->tot_triangles);
1425     }
1426
1427     for (int i = 0; i < gps->tot_triangles; i++) {
1428       bGPDtriangle *stroke_triangle = &gps->triangles[i];
1429       memcpy(gps->triangles[i].verts, tmp_triangles[i], sizeof(uint[3]));
1430       /* copy texture coordinates */
1431       copy_v2_v2(stroke_triangle->uv[0], uv[tmp_triangles[i][0]]);
1432       copy_v2_v2(stroke_triangle->uv[1], uv[tmp_triangles[i][1]]);
1433       copy_v2_v2(stroke_triangle->uv[2], uv[tmp_triangles[i][2]]);
1434     }
1435   }
1436   else {
1437     /* No triangles needed - Free anything allocated previously */
1438     if (gps->triangles) {
1439       MEM_freeN(gps->triangles);
1440     }
1441
1442     gps->triangles = NULL;
1443   }
1444
1445   /* disable recalculation flag */
1446   if (gps->flag & GP_STROKE_RECALC_GEOMETRY) {
1447     gps->flag &= ~GP_STROKE_RECALC_GEOMETRY;
1448   }
1449
1450   /* clear memory */
1451   MEM_SAFE_FREE(tmp_triangles);
1452   MEM_SAFE_FREE(points2d);
1453   MEM_SAFE_FREE(uv);
1454 }
1455
1456 /* Check if stencil is required */
1457 static bool gpencil_is_stencil_required(MaterialGPencilStyle *gp_style)
1458 {
1459   return (bool)(gp_style->stroke_style == GP_STYLE_STROKE_STYLE_SOLID);
1460 }
1461
1462 /* draw stroke in drawing buffer */
1463 void gpencil_populate_buffer_strokes(GPENCIL_e_data *e_data,
1464                                      void *vedata,
1465                                      ToolSettings *ts,
1466                                      Object *ob)
1467 {
1468   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1469   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1470   const DRWContextState *draw_ctx = DRW_context_state_get();
1471   View3D *v3d = draw_ctx->v3d;
1472   const bool overlay = v3d != NULL ? (bool)((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) : true;
1473   Brush *brush = BKE_paint_brush(&ts->gp_paint->paint);
1474   const bool is_paint_tool = (bool)((brush) && (brush->gpencil_tool == GPAINT_TOOL_DRAW));
1475   bGPdata *gpd_eval = ob->data;
1476   /* need the original to avoid cow overhead while drawing */
1477   bGPdata *gpd = (bGPdata *)DEG_get_original_id(&gpd_eval->id);
1478
1479   MaterialGPencilStyle *gp_style = NULL;
1480   float obscale = mat4_to_scale(ob->obmat);
1481
1482   /* use the brush material */
1483   Material *ma = BKE_gpencil_object_material_get_from_brush(ob, brush);
1484   if (ma != NULL) {
1485     gp_style = ma->gp_style;
1486   }
1487   /* this is not common, but avoid any special situations when brush could be without material */
1488   if (gp_style == NULL) {
1489     gp_style = BKE_material_gpencil_settings_get(ob, ob->actcol);
1490   }
1491
1492   /* drawing strokes */
1493   /* Check if may need to draw the active stroke cache, only if this layer is the active layer
1494    * that is being edited. (Stroke buffer is currently stored in gp-data)
1495    */
1496   if (gpd->runtime.sbuffer_used > 0) {
1497     if ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0) {
1498       /* It should also be noted that sbuffer contains temporary point types
1499        * i.e. tGPspoints NOT bGPDspoints
1500        */
1501       short lthick = brush->size * obscale;
1502
1503       /* save gradient info */
1504       stl->storage->gradient_f = brush->gpencil_settings->gradient_f;
1505       copy_v2_v2(stl->storage->gradient_s, brush->gpencil_settings->gradient_s);
1506       stl->storage->alignment_mode = (gp_style) ? gp_style->alignment_mode : GP_STYLE_FOLLOW_PATH;
1507
1508       /* if only one point, don't need to draw buffer because the user has no time to see it */
1509       if (gpd->runtime.sbuffer_used > 1) {
1510         if ((gp_style) && (gp_style->mode == GP_STYLE_MODE_LINE)) {
1511           stl->g_data->shgrps_drawing_stroke = gpencil_shgroup_stroke_create(
1512               vedata,
1513               psl->drawing_pass,
1514               e_data->gpencil_stroke_sh,
1515               NULL,
1516               gpd,
1517               NULL,
1518               NULL,
1519               gp_style,
1520               -1,
1521               false,
1522               1.0f,
1523               (const int *)stl->storage->shade_render);
1524
1525           if (gpencil_is_stencil_required(gp_style)) {
1526             DRW_shgroup_stencil_mask(stl->g_data->shgrps_drawing_stroke, 0x01);
1527           }
1528           else {
1529             /* Disable stencil for this type */
1530             DRW_shgroup_state_disable(stl->g_data->shgrps_drawing_stroke,
1531                                       DRW_STATE_WRITE_STENCIL | DRW_STATE_STENCIL_NEQUAL);
1532           }
1533         }
1534         else {
1535           stl->g_data->shgrps_drawing_stroke = gpencil_shgroup_point_create(
1536               vedata,
1537               psl->drawing_pass,
1538               e_data->gpencil_point_sh,
1539               NULL,
1540               gpd,
1541               NULL,
1542               NULL,
1543               gp_style,
1544               -1,
1545               false,
1546               1.0f,
1547               (const int *)stl->storage->shade_render);
1548           /* Disable stencil for this type */
1549           DRW_shgroup_state_disable(stl->g_data->shgrps_drawing_stroke,
1550                                     DRW_STATE_WRITE_STENCIL | DRW_STATE_STENCIL_NEQUAL);
1551         }
1552
1553         /* use unit matrix because the buffer is in screen space and does not need conversion */
1554         if (gpd->runtime.mode == GP_STYLE_MODE_LINE) {
1555           stl->g_data->batch_buffer_stroke = gpencil_get_buffer_stroke_geom(gpd, lthick);
1556         }
1557         else {
1558           stl->g_data->batch_buffer_stroke = gpencil_get_buffer_point_geom(gpd, lthick);
1559         }
1560
1561         /* buffer strokes, must show stroke always */
1562         DRW_shgroup_call(
1563             stl->g_data->shgrps_drawing_stroke, stl->g_data->batch_buffer_stroke, NULL);
1564
1565         if ((gpd->runtime.sbuffer_used >= 3) &&
1566             (gpd->runtime.sfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) &&
1567             ((gpd->runtime.sbuffer_sflag & GP_STROKE_NOFILL) == 0) &&
1568             ((brush->gpencil_settings->flag & GP_BRUSH_DISSABLE_LASSO) == 0) &&
1569             (gp_style->flag & GP_STYLE_FILL_SHOW)) {
1570           /* if not solid, fill is simulated with solid color */
1571           if (gpd->runtime.bfill_style > 0) {
1572             gpd->runtime.sfill[3] = 0.5f;
1573           }
1574           stl->g_data->shgrps_drawing_fill = DRW_shgroup_create(e_data->gpencil_drawing_fill_sh,
1575                                                                 psl->drawing_pass);
1576           /* Disable stencil for this type */
1577           DRW_shgroup_state_disable(stl->g_data->shgrps_drawing_fill,
1578                                     DRW_STATE_WRITE_STENCIL | DRW_STATE_STENCIL_NEQUAL);
1579
1580           stl->g_data->batch_buffer_fill = gpencil_get_buffer_fill_geom(gpd);
1581           DRW_shgroup_call(stl->g_data->shgrps_drawing_fill, stl->g_data->batch_buffer_fill, NULL);
1582         }
1583       }
1584     }
1585   }
1586
1587   /* control points for primitives and speed guide */
1588   const bool is_cppoint = (gpd->runtime.tot_cp_points > 0);
1589   const bool is_speed_guide = (ts->gp_sculpt.guide.use_guide &&
1590                                (draw_ctx->object_mode == OB_MODE_PAINT_GPENCIL));
1591   const bool is_show_gizmo = (((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) &&
1592                               ((v3d->gizmo_flag & V3D_GIZMO_HIDE_TOOL) == 0));
1593
1594   if ((overlay) && (is_paint_tool) && (is_cppoint || is_speed_guide) && (is_show_gizmo) &&
1595       ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0)) {
1596     DRWShadingGroup *shgrp = DRW_shgroup_create(e_data->gpencil_edit_point_sh, psl->drawing_pass);
1597     const float *viewport_size = DRW_viewport_size_get();
1598     DRW_shgroup_uniform_vec2(shgrp, "Viewport", viewport_size, 1);
1599     /* Disable stencil for this type */
1600     DRW_shgroup_state_disable(shgrp, DRW_STATE_WRITE_STENCIL | DRW_STATE_STENCIL_NEQUAL);
1601     stl->g_data->batch_buffer_ctrlpoint = gpencil_get_buffer_ctrlpoint_geom(gpd);
1602
1603     DRW_shgroup_call(shgrp, stl->g_data->batch_buffer_ctrlpoint, NULL);
1604   }
1605 }
1606
1607 /* create all missing batches */
1608 static void gpencil_create_batches(GpencilBatchCache *cache)
1609 {
1610   if ((cache->b_point.vbo) && (cache->b_point.batch == NULL)) {
1611     cache->b_point.batch = GPU_batch_create_ex(
1612         GPU_PRIM_POINTS, cache->b_point.vbo, NULL, GPU_BATCH_OWNS_VBO);
1613   }
1614   if ((cache->b_stroke.vbo) && (cache->b_stroke.batch == NULL)) {
1615     cache->b_stroke.batch = GPU_batch_create_ex(
1616         GPU_PRIM_LINE_STRIP_ADJ, cache->b_stroke.vbo, NULL, GPU_BATCH_OWNS_VBO);
1617   }
1618   if ((cache->b_fill.vbo) && (cache->b_fill.batch == NULL)) {
1619     cache->b_fill.batch = GPU_batch_create_ex(
1620         GPU_PRIM_TRIS, cache->b_fill.vbo, NULL, GPU_BATCH_OWNS_VBO);
1621   }
1622   if ((cache->b_edit.vbo) && (cache->b_edit.batch == NULL)) {
1623     cache->b_edit.batch = GPU_batch_create_ex(
1624         GPU_PRIM_POINTS, cache->b_edit.vbo, NULL, GPU_BATCH_OWNS_VBO);
1625   }
1626   if ((cache->b_edlin.vbo) && (cache->b_edlin.batch == NULL)) {
1627     cache->b_edlin.batch = GPU_batch_create_ex(
1628         GPU_PRIM_LINE_STRIP, cache->b_edlin.vbo, NULL, GPU_BATCH_OWNS_VBO);
1629   }
1630 }
1631
1632 /* create all shading groups */
1633 static void gpencil_shgroups_create(GPENCIL_e_data *e_data,
1634                                     void *vedata,
1635                                     Object *ob,
1636                                     GpencilBatchCache *cache,
1637                                     tGPencilObjectCache *cache_ob)
1638 {
1639   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1640   GPENCIL_PassList *psl = ((GPENCIL_Data *)vedata)->psl;
1641   bGPdata *gpd = (bGPdata *)ob->data;
1642   DRWPass *stroke_pass = GPENCIL_3D_DRAWMODE(ob, gpd) ? psl->stroke_pass_3d : psl->stroke_pass_2d;
1643
1644   GpencilBatchGroup *elm = NULL;
1645   DRWShadingGroup *shgrp = NULL;
1646   tGPencilObjectCache_shgrp *array_elm = NULL;
1647
1648   bGPDlayer *gpl = NULL;
1649   bGPDlayer *gpl_prev = NULL;
1650   int idx = 0;
1651   bool tag_first = false;
1652
1653   const DRWContextState *draw_ctx = DRW_context_state_get();
1654   const View3D *v3d = draw_ctx->v3d;
1655
1656   const bool overlay = draw_ctx->v3d != NULL ?
1657                            (bool)((draw_ctx->v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) :
1658                            true;
1659   const bool main_onion = v3d != NULL ? (v3d->gp_flag & V3D_GP_SHOW_ONION_SKIN) : true;
1660   const bool do_onion = (bool)((gpd->flag & GP_DATA_STROKE_WEIGHTMODE) == 0) && main_onion &&
1661                         gpencil_onion_active(gpd) && overlay;
1662
1663   int start_stroke = 0;
1664   int start_point = 0;
1665   int start_fill = 0;
1666   int start_edit = 0;
1667   int start_edlin = 0;
1668
1669   uint stencil_id = 1;
1670   for (int i = 0; i < cache->grp_used; i++) {
1671     elm = &cache->grp_cache[i];
1672     array_elm = &cache_ob->shgrp_array[idx];
1673     const float scale = cache_ob->scale;
1674
1675     /* Limit stencil id */
1676     if (stencil_id > 255) {
1677       stencil_id = 1;
1678     }
1679
1680     /* save last group when change */
1681     if (gpl_prev == NULL) {
1682       gpl_prev = elm->gpl;
1683       tag_first = true;
1684     }
1685     else {
1686       if (elm->gpl != gpl_prev) {
1687         /* first layer is always blend Normal */
1688         array_elm->mode = idx == 0 ? eGplBlendMode_Regular : gpl->blend_mode;
1689         array_elm->end_shgrp = shgrp;
1690         gpl_prev = elm->gpl;
1691         tag_first = true;
1692         idx++;
1693       }
1694     }
1695
1696     gpl = elm->gpl;
1697     bGPDframe *gpf = elm->gpf;
1698     bGPDstroke *gps = elm->gps;
1699     MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1700     /* if the user switch used material from data to object,
1701      * the material could not be available */
1702     if (gp_style == NULL) {
1703       break;
1704     }
1705
1706     /* limit the number of shading groups */
1707     if (i >= GPENCIL_MAX_SHGROUPS) {
1708       break;
1709     }
1710
1711     float(*obmat)[4] = (!cache_ob->is_dup_ob) ? gpf->runtime.parent_obmat : cache_ob->obmat;
1712     switch (elm->type) {
1713       case eGpencilBatchGroupType_Stroke: {
1714         const int len = elm->vertex_idx - start_stroke;
1715
1716         shgrp = gpencil_shgroup_stroke_create(vedata,
1717                                               stroke_pass,
1718                                               e_data->gpencil_stroke_sh,
1719                                               ob,
1720                                               gpd,
1721                                               gpl,
1722                                               gps,
1723                                               gp_style,
1724                                               stl->storage->shgroup_id,
1725                                               elm->onion,
1726                                               scale,
1727                                               cache_ob->shading_type);
1728         if ((do_onion) || (elm->onion == false)) {
1729           DRW_shgroup_call_range_obmat(shgrp, cache->b_stroke.batch, obmat, start_stroke, len);
1730         }
1731         stl->storage->shgroup_id++;
1732         start_stroke = elm->vertex_idx;
1733
1734         /* set stencil mask id */
1735         if (gpencil_is_stencil_required(gp_style)) {
1736           DRW_shgroup_stencil_mask(shgrp, stencil_id);
1737           stencil_id++;
1738         }
1739         else {
1740           /* Disable stencil for this type */
1741           DRW_shgroup_state_disable(shgrp, DRW_STATE_WRITE_STENCIL | DRW_STATE_STENCIL_NEQUAL);
1742           /* set stencil mask id as not used */
1743           DRW_shgroup_stencil_mask(shgrp, 0x0);
1744         }
1745         break;
1746       }
1747       case eGpencilBatchGroupType_Point: {
1748         const int len = elm->vertex_idx - start_point;
1749
1750         shgrp = gpencil_shgroup_point_create(vedata,
1751                                              stroke_pass,
1752                                              e_data->gpencil_point_sh,
1753                                              ob,
1754                                              gpd,
1755                                              gpl,
1756                                              gps,
1757                                              gp_style,
1758                                              stl->storage->shgroup_id,
1759                                              elm->onion,
1760                                              scale,
1761                                              cache_ob->shading_type);
1762
1763         if ((do_onion) || (elm->onion == false)) {
1764           DRW_shgroup_call_range_obmat(shgrp, cache->b_point.batch, obmat, start_point, len);
1765         }
1766         stl->storage->shgroup_id++;
1767         start_point = elm->vertex_idx;
1768
1769         /* Disable stencil for this type */
1770         DRW_shgroup_state_disable(shgrp, DRW_STATE_WRITE_STENCIL | DRW_STATE_STENCIL_NEQUAL);
1771         /* set stencil mask id as not used */
1772         DRW_shgroup_stencil_mask(shgrp, 0x0);
1773         break;
1774       }
1775       case eGpencilBatchGroupType_Fill: {
1776         const int len = elm->vertex_idx - start_fill;
1777
1778         shgrp = gpencil_shgroup_fill_create(vedata,
1779                                             stroke_pass,
1780                                             e_data->gpencil_fill_sh,
1781                                             ob,
1782                                             gpd,
1783                                             gpl,
1784                                             gp_style,
1785                                             stl->storage->shgroup_id,
1786                                             cache_ob->shading_type);
1787
1788         if ((do_onion) || (elm->onion == false)) {
1789           DRW_shgroup_call_range_obmat(shgrp, cache->b_fill.batch, obmat, start_fill, len);
1790         }
1791         stl->storage->shgroup_id++;
1792         start_fill = elm->vertex_idx;
1793
1794         /* Disable stencil for this type */
1795         DRW_shgroup_state_disable(shgrp, DRW_STATE_WRITE_STENCIL | DRW_STATE_STENCIL_NEQUAL);
1796         /* set stencil mask id as not used */
1797         DRW_shgroup_stencil_mask(shgrp, 0x0);
1798         break;
1799       }
1800       case eGpencilBatchGroupType_Edit: {
1801         if (stl->g_data->shgrps_edit_point) {
1802           const int len = elm->vertex_idx - start_edit;
1803           /* use always the same group */
1804           DRW_shgroup_call_range_obmat(
1805               stl->g_data->shgrps_edit_point, cache->b_edit.batch, obmat, start_edit, len);
1806
1807           start_edit = elm->vertex_idx;
1808         }
1809         break;
1810       }
1811       case eGpencilBatchGroupType_Edlin: {
1812         if (stl->g_data->shgrps_edit_line) {
1813           const int len = elm->vertex_idx - start_edlin;
1814           /* use always the same group */
1815           DRW_shgroup_call_range_obmat(
1816               stl->g_data->shgrps_edit_line, cache->b_edlin.batch, obmat, start_edlin, len);
1817
1818           start_edlin = elm->vertex_idx;
1819         }
1820         break;
1821       }
1822       default: {
1823         break;
1824       }
1825     }
1826     /* save first group */
1827     if ((shgrp != NULL) && (tag_first)) {
1828       array_elm = &cache_ob->shgrp_array[idx];
1829       array_elm->mode = idx == 0 ? eGplBlendMode_Regular : gpl->blend_mode;
1830       array_elm->mask_layer = gpl->flag & GP_LAYER_USE_MASK;
1831       array_elm->blend_opacity = gpl->opacity;
1832       array_elm->init_shgrp = shgrp;
1833       cache_ob->tot_layers++;
1834
1835       tag_first = false;
1836     }
1837   }
1838
1839   /* save last group */
1840   if (shgrp != NULL) {
1841     array_elm->mode = idx == 0 ? eGplBlendMode_Regular : gpl->blend_mode;
1842     array_elm->end_shgrp = shgrp;
1843   }
1844 }
1845 /* populate a datablock for multiedit (no onions, no modifiers) */
1846 void gpencil_populate_multiedit(GPENCIL_e_data *e_data,
1847                                 void *vedata,
1848                                 Object *ob,
1849                                 tGPencilObjectCache *cache_ob)
1850 {
1851   bGPdata *gpd = (bGPdata *)ob->data;
1852   bGPDframe *gpf = NULL;
1853
1854   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1855   const DRWContextState *draw_ctx = DRW_context_state_get();
1856   int cfra_eval = (int)DEG_get_ctime(draw_ctx->depsgraph);
1857   GpencilBatchCache *cache = gpencil_batch_cache_get(ob, cfra_eval);
1858
1859   /* check if playing animation */
1860   const bool playing = stl->storage->is_playing;
1861
1862   /* calc max size of VBOs */
1863   gpencil_calc_vertex(stl, cache_ob, cache, gpd, cfra_eval);
1864
1865   /* draw strokes */
1866   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1867     /* don't draw layer if hidden */
1868     if (gpl->flag & GP_LAYER_HIDE) {
1869       continue;
1870     }
1871
1872     /* list of frames to draw */
1873     if (!playing) {
1874       for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1875         if ((gpf == gpl->actframe) || (gpf->flag & GP_FRAME_SELECT)) {
1876           gpencil_draw_strokes(cache,
1877                                e_data,
1878                                vedata,
1879                                ob,
1880                                gpd,
1881                                gpl,
1882                                gpf,
1883                                gpf,
1884                                gpl->opacity,
1885                                gpl->tintcolor,
1886                                false,
1887                                cache_ob);
1888         }
1889       }
1890     }
1891     else {
1892       gpf = BKE_gpencil_layer_getframe(gpl, cfra_eval, GP_GETFRAME_USE_PREV);
1893       if (gpf) {
1894         gpencil_draw_strokes(cache,
1895                              e_data,
1896                              vedata,
1897                              ob,
1898                              gpd,
1899                              gpl,
1900                              gpf,
1901                              gpf,
1902                              gpl->opacity,
1903                              gpl->tintcolor,
1904                              false,
1905                              cache_ob);
1906       }
1907     }
1908   }
1909
1910   /* create batchs and shading groups */
1911   gpencil_create_batches(cache);
1912   gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
1913
1914   cache->is_dirty = false;
1915 }
1916
1917 /* ensure there is a derived frame */
1918 static void gpencil_ensure_derived_frame(bGPdata *gpd,
1919                                          bGPDlayer *gpl,
1920                                          bGPDframe *gpf,
1921                                          GpencilBatchCache *cache,
1922                                          bGPDframe **derived_gpf)
1923 {
1924   /* create derived frames array data or expand */
1925   int derived_idx = BLI_findindex(&gpd->layers, gpl);
1926   *derived_gpf = &cache->derived_array[derived_idx];
1927
1928   /* if no derived frame or dirty cache, create a new one */
1929   if ((*derived_gpf == NULL) || (cache->is_dirty)) {
1930     if (*derived_gpf != NULL) {
1931       /* first clear temp data */
1932       BKE_gpencil_free_frame_runtime_data(*derived_gpf);
1933     }
1934     /* create new data (do not assign new memory)*/
1935     gpencil_copy_frame(gpf, *derived_gpf);
1936   }
1937 }
1938
1939 /* helper for populate a complete grease pencil datablock */
1940 void gpencil_populate_datablock(GPENCIL_e_data *e_data,
1941                                 void *vedata,
1942                                 Object *ob,
1943                                 tGPencilObjectCache *cache_ob)
1944 {
1945   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
1946   const DRWContextState *draw_ctx = DRW_context_state_get();
1947   const ViewLayer *view_layer = DEG_get_evaluated_view_layer(draw_ctx->depsgraph);
1948   Scene *scene = draw_ctx->scene;
1949
1950   bGPdata *gpd = (bGPdata *)ob->data;
1951
1952   View3D *v3d = draw_ctx->v3d;
1953   int cfra_eval = (int)DEG_get_ctime(draw_ctx->depsgraph);
1954
1955   bGPDframe *derived_gpf = NULL;
1956   const bool overlay = v3d != NULL ? (bool)((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) : true;
1957   const bool time_remap = BKE_gpencil_has_time_modifiers(ob);
1958
1959   float opacity;
1960   bGPDframe *gpf = NULL;
1961   bGPDlayer *gpl_active = BKE_gpencil_layer_getactive(gpd);
1962
1963   /* check if playing animation */
1964   const bool playing = stl->storage->is_playing;
1965
1966   GpencilBatchCache *cache = gpencil_batch_cache_get(ob, cfra_eval);
1967
1968   /* if object is duplicate, only create shading groups */
1969   if (cache_ob->is_dup_ob) {
1970     gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
1971     return;
1972   }
1973
1974   /* calc max size of VBOs */
1975   gpencil_calc_vertex(stl, cache_ob, cache, gpd, cfra_eval);
1976
1977   /* init general modifiers data */
1978   if (!stl->storage->simplify_modif) {
1979     if ((cache->is_dirty) && (ob->greasepencil_modifiers.first)) {
1980       BKE_gpencil_lattice_init(ob);
1981     }
1982   }
1983   /* draw normal strokes */
1984   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1985     /* don't draw layer if hidden */
1986     if (gpl->flag & GP_LAYER_HIDE) {
1987       continue;
1988     }
1989
1990     const bool is_solomode = GPENCIL_PAINT_MODE(gpd) && (!playing) && (!stl->storage->is_render) &&
1991                              (gpl->flag & GP_LAYER_SOLO_MODE);
1992
1993     /* filter view layer to gp layers in the same view layer (for compo) */
1994     if ((stl->storage->is_render) && (gpl->viewlayername[0] != '\0')) {
1995       if (!STREQ(view_layer->name, gpl->viewlayername)) {
1996         continue;
1997       }
1998     }
1999
2000     /* remap time */
2001     int remap_cfra = cfra_eval;
2002     if ((time_remap) && (!stl->storage->simplify_modif)) {
2003       remap_cfra = BKE_gpencil_time_modifier(
2004           draw_ctx->depsgraph, scene, ob, gpl, cfra_eval, stl->storage->is_render);
2005     }
2006
2007     gpf = BKE_gpencil_layer_getframe(gpl, remap_cfra, GP_GETFRAME_USE_PREV);
2008     if (gpf == NULL) {
2009       continue;
2010     }
2011
2012     /* if solo mode, display only frames with keyframe in the current frame */
2013     if ((is_solomode) && (gpf->framenum != remap_cfra)) {
2014       continue;
2015     }
2016
2017     opacity = gpl->opacity;
2018     /* if pose mode, maybe the overlay to fade geometry is enabled */
2019     if ((draw_ctx->obact) && (draw_ctx->object_mode == OB_MODE_POSE) &&
2020         (v3d->overlay.flag & V3D_OVERLAY_BONE_SELECT)) {
2021       opacity = opacity * v3d->overlay.xray_alpha_bone;
2022     }
2023     /* fade no active layers */
2024     if ((overlay) && (draw_ctx->object_mode == OB_MODE_PAINT_GPENCIL) &&
2025         (v3d->gp_flag & V3D_GP_FADE_NOACTIVE_LAYERS) && (draw_ctx->obact) &&
2026         (draw_ctx->obact == ob) && (gpl != gpl_active)) {
2027       opacity = opacity * v3d->overlay.gpencil_fade_layer;
2028     }
2029
2030     /* create derived frames array data or expand */
2031     gpencil_ensure_derived_frame(gpd, gpl, gpf, cache, &derived_gpf);
2032
2033     /* draw onion skins */
2034     if (!ID_IS_LINKED(&gpd->id)) {
2035       if ((gpl->onion_flag & GP_LAYER_ONIONSKIN) &&
2036           ((!playing) || (gpd->onion_flag & GP_ONION_GHOST_ALWAYS)) && (!cache_ob->is_dup_ob) &&
2037           (gpd->id.us <= 1)) {
2038         if ((!stl->storage->is_render) ||
2039             ((stl->storage->is_render) && (gpd->onion_flag & GP_ONION_GHOST_ALWAYS))) {
2040           gpencil_draw_onionskins(cache, vedata, ob, gpd, gpl, gpf);
2041         }
2042       }
2043     }
2044     /* draw normal strokes */
2045     gpencil_draw_strokes(cache,
2046                          e_data,
2047                          vedata,
2048                          ob,
2049                          gpd,
2050                          gpl,
2051                          gpf,
2052                          derived_gpf,
2053                          opacity,
2054                          gpl->tintcolor,
2055                          false,
2056                          cache_ob);
2057   }
2058
2059   /* clear any lattice data */
2060   if ((cache->is_dirty) && (ob->greasepencil_modifiers.first)) {
2061     BKE_gpencil_lattice_clear(ob);
2062   }
2063
2064   /* create batchs and shading groups */
2065   gpencil_create_batches(cache);
2066   gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
2067
2068   cache->is_dirty = false;
2069 }
2070
2071 void gpencil_populate_particles(GPENCIL_e_data *e_data, GHash *gh_objects, void *vedata)
2072 {
2073   GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
2074
2075   /* add particles */
2076   for (int i = 0; i < stl->g_data->gp_cache_used; i++) {
2077     tGPencilObjectCache *cache_ob = &stl->g_data->gp_object_cache[i];
2078     if (cache_ob->is_dup_ob) {
2079       /* Reassign duplicate objects because memory for particles is not available
2080        * and need to use the original data-block and run-time data. */
2081       Object *ob = (Object *)BLI_ghash_lookup(gh_objects, cache_ob->name);
2082       if (ob) {
2083         cache_ob->ob = ob;
2084         cache_ob->gpd = (bGPdata *)ob->data;
2085         GpencilBatchCache *cache = ob->runtime.gpencil_cache;
2086         if (cache != NULL) {
2087           gpencil_shgroups_create(e_data, vedata, ob, cache, cache_ob);
2088         }
2089       }
2090     }
2091   }
2092 }