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