Fix: GPencil mask shows in view layer render
[blender.git] / source / blender / blenkernel / intern / gpencil.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2008, Blender Foundation
17  * This is a new part of Blender
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <math.h>
25 #include <stddef.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "CLG_log.h"
31
32 #include "MEM_guardedalloc.h"
33
34 #include "BLI_blenlib.h"
35 #include "BLI_math_vector.h"
36 #include "BLI_string_utils.h"
37
38 #include "BLT_translation.h"
39
40 #include "IMB_imbuf.h"
41 #include "IMB_imbuf_types.h"
42
43 /* Allow using deprecated functionality for .blend file I/O. */
44 #define DNA_DEPRECATED_ALLOW
45
46 #include "DNA_gpencil_types.h"
47 #include "DNA_material_types.h"
48 #include "DNA_meshdata_types.h"
49 #include "DNA_space_types.h"
50
51 #include "BKE_action.h"
52 #include "BKE_anim_data.h"
53 #include "BKE_collection.h"
54 #include "BKE_colortools.h"
55 #include "BKE_deform.h"
56 #include "BKE_gpencil.h"
57 #include "BKE_gpencil_geom.h"
58 #include "BKE_icons.h"
59 #include "BKE_idtype.h"
60 #include "BKE_image.h"
61 #include "BKE_lib_id.h"
62 #include "BKE_lib_query.h"
63 #include "BKE_main.h"
64 #include "BKE_material.h"
65 #include "BKE_paint.h"
66
67 #include "BLI_math_color.h"
68
69 #include "DEG_depsgraph_query.h"
70
71 #include "BLO_read_write.h"
72
73 #include "BKE_gpencil.h"
74
75 static CLG_LogRef LOG = {"bke.gpencil"};
76
77 static void greasepencil_copy_data(Main *UNUSED(bmain),
78                                    ID *id_dst,
79                                    const ID *id_src,
80                                    const int UNUSED(flag))
81 {
82   bGPdata *gpd_dst = (bGPdata *)id_dst;
83   const bGPdata *gpd_src = (const bGPdata *)id_src;
84
85   /* duplicate material array */
86   if (gpd_src->mat) {
87     gpd_dst->mat = MEM_dupallocN(gpd_src->mat);
88   }
89
90   /* copy layers */
91   BLI_listbase_clear(&gpd_dst->layers);
92   LISTBASE_FOREACH (bGPDlayer *, gpl_src, &gpd_src->layers) {
93     /* make a copy of source layer and its data */
94
95     /* TODO here too could add unused flags... */
96     bGPDlayer *gpl_dst = BKE_gpencil_layer_duplicate(gpl_src, true, true);
97
98     /* Apply local layer transform to all frames. Calc the active frame is not enough
99      * because onion skin can use more frames. This is more slow but required here. */
100     if (gpl_dst->actframe != NULL) {
101       bool transformed = ((!is_zero_v3(gpl_dst->location)) || (!is_zero_v3(gpl_dst->rotation)) ||
102                           (!is_one_v3(gpl_dst->scale)));
103       if (transformed) {
104         loc_eul_size_to_mat4(
105             gpl_dst->layer_mat, gpl_dst->location, gpl_dst->rotation, gpl_dst->scale);
106         bool do_onion = ((gpl_dst->onion_flag & GP_LAYER_ONIONSKIN) != 0);
107         bGPDframe *init_gpf = (do_onion) ? gpl_dst->frames.first : gpl_dst->actframe;
108         for (bGPDframe *gpf = init_gpf; gpf; gpf = gpf->next) {
109           LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
110             bGPDspoint *pt;
111             int i;
112             for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
113               mul_m4_v3(gpl_dst->layer_mat, &pt->x);
114             }
115           }
116           /* if not onion, exit loop. */
117           if (!do_onion) {
118             break;
119           }
120         }
121       }
122     }
123
124     BLI_addtail(&gpd_dst->layers, gpl_dst);
125   }
126 }
127
128 static void greasepencil_free_data(ID *id)
129 {
130   /* Really not ideal, but for now will do... In theory custom behaviors like not freeing cache
131    * should be handled through specific API, and not be part of the generic one. */
132   BKE_gpencil_free((bGPdata *)id, true);
133 }
134
135 static void greasepencil_foreach_id(ID *id, LibraryForeachIDData *data)
136 {
137   bGPdata *gpencil = (bGPdata *)id;
138   /* materials */
139   for (int i = 0; i < gpencil->totcol; i++) {
140     BKE_LIB_FOREACHID_PROCESS(data, gpencil->mat[i], IDWALK_CB_USER);
141   }
142
143   LISTBASE_FOREACH (bGPDlayer *, gplayer, &gpencil->layers) {
144     BKE_LIB_FOREACHID_PROCESS(data, gplayer->parent, IDWALK_CB_NOP);
145   }
146 }
147
148 static void greasepencil_blend_write(BlendWriter *writer, ID *id, const void *id_address)
149 {
150   bGPdata *gpd = (bGPdata *)id;
151   if (gpd->id.us > 0 || BLO_write_is_undo(writer)) {
152     /* Clean up, important in undo case to reduce false detection of changed data-blocks. */
153     /* XXX not sure why the whole run-time data is not cleared in reading code,
154      * for now mimicking it here. */
155     gpd->runtime.sbuffer = NULL;
156     gpd->runtime.sbuffer_used = 0;
157     gpd->runtime.sbuffer_size = 0;
158     gpd->runtime.tot_cp_points = 0;
159
160     /* write gpd data block to file */
161     BLO_write_id_struct(writer, bGPdata, id_address, &gpd->id);
162     BKE_id_blend_write(writer, &gpd->id);
163
164     if (gpd->adt) {
165       BKE_animdata_blend_write(writer, gpd->adt);
166     }
167
168     BLO_write_pointer_array(writer, gpd->totcol, gpd->mat);
169
170     /* write grease-pencil layers to file */
171     BLO_write_struct_list(writer, bGPDlayer, &gpd->layers);
172     LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
173       /* Write mask list. */
174       BLO_write_struct_list(writer, bGPDlayer_Mask, &gpl->mask_layers);
175       /* write this layer's frames to file */
176       BLO_write_struct_list(writer, bGPDframe, &gpl->frames);
177       LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
178         /* write strokes */
179         BLO_write_struct_list(writer, bGPDstroke, &gpf->strokes);
180         LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
181           BLO_write_struct_array(writer, bGPDspoint, gps->totpoints, gps->points);
182           BLO_write_struct_array(writer, bGPDtriangle, gps->tot_triangles, gps->triangles);
183           BKE_defvert_blend_write(writer, gps->totpoints, gps->dvert);
184           if (gps->editcurve != NULL) {
185             bGPDcurve *gpc = gps->editcurve;
186             BLO_write_struct(writer, bGPDcurve, gpc);
187             BLO_write_struct_array(
188                 writer, bGPDcurve_point, gpc->tot_curve_points, gpc->curve_points);
189           }
190         }
191       }
192     }
193   }
194 }
195
196 void BKE_gpencil_blend_read_data(BlendDataReader *reader, bGPdata *gpd)
197 {
198   /* we must firstly have some grease-pencil data to link! */
199   if (gpd == NULL) {
200     return;
201   }
202
203   /* relink animdata */
204   BLO_read_data_address(reader, &gpd->adt);
205   BKE_animdata_blend_read_data(reader, gpd->adt);
206
207   /* Ensure full objectmode for linked grease pencil. */
208   if (gpd->id.lib != NULL) {
209     gpd->flag &= ~GP_DATA_STROKE_PAINTMODE;
210     gpd->flag &= ~GP_DATA_STROKE_EDITMODE;
211     gpd->flag &= ~GP_DATA_STROKE_SCULPTMODE;
212     gpd->flag &= ~GP_DATA_STROKE_WEIGHTMODE;
213     gpd->flag &= ~GP_DATA_STROKE_VERTEXMODE;
214   }
215
216   /* init stroke buffer */
217   gpd->runtime.sbuffer = NULL;
218   gpd->runtime.sbuffer_used = 0;
219   gpd->runtime.sbuffer_size = 0;
220   gpd->runtime.tot_cp_points = 0;
221
222   /* relink palettes (old palettes deprecated, only to convert old files) */
223   BLO_read_list(reader, &gpd->palettes);
224   if (gpd->palettes.first != NULL) {
225     LISTBASE_FOREACH (bGPDpalette *, palette, &gpd->palettes) {
226       BLO_read_list(reader, &palette->colors);
227     }
228   }
229
230   /* materials */
231   BLO_read_pointer_array(reader, (void **)&gpd->mat);
232
233   /* relink layers */
234   BLO_read_list(reader, &gpd->layers);
235
236   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
237     /* relink frames */
238     BLO_read_list(reader, &gpl->frames);
239
240     BLO_read_data_address(reader, &gpl->actframe);
241
242     gpl->runtime.icon_id = 0;
243
244     /* Relink masks. */
245     BLO_read_list(reader, &gpl->mask_layers);
246
247     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
248       /* relink strokes (and their points) */
249       BLO_read_list(reader, &gpf->strokes);
250
251       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
252         /* relink stroke points array */
253         BLO_read_data_address(reader, &gps->points);
254         /* Relink geometry*/
255         BLO_read_data_address(reader, &gps->triangles);
256
257         /* relink stroke edit curve. */
258         BLO_read_data_address(reader, &gps->editcurve);
259         if (gps->editcurve != NULL) {
260           /* relink curve point array */
261           BLO_read_data_address(reader, &gps->editcurve->curve_points);
262         }
263
264         /* relink weight data */
265         if (gps->dvert) {
266           BLO_read_data_address(reader, &gps->dvert);
267           BKE_defvert_blend_read(reader, gps->totpoints, gps->dvert);
268         }
269       }
270     }
271   }
272 }
273
274 static void greasepencil_blend_read_data(BlendDataReader *reader, ID *id)
275 {
276   bGPdata *gpd = (bGPdata *)id;
277   BKE_gpencil_blend_read_data(reader, gpd);
278 }
279
280 static void greasepencil_blend_read_lib(BlendLibReader *reader, ID *id)
281 {
282   bGPdata *gpd = (bGPdata *)id;
283
284   /* Relink all data-lock linked by GP data-lock */
285   /* Layers */
286   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
287     /* Layer -> Parent References */
288     BLO_read_id_address(reader, gpd->id.lib, &gpl->parent);
289   }
290
291   /* materials */
292   for (int a = 0; a < gpd->totcol; a++) {
293     BLO_read_id_address(reader, gpd->id.lib, &gpd->mat[a]);
294   }
295 }
296
297 static void greasepencil_blend_read_expand(BlendExpander *expander, ID *id)
298 {
299   bGPdata *gpd = (bGPdata *)id;
300   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
301     BLO_expand(expander, gpl->parent);
302   }
303
304   for (int a = 0; a < gpd->totcol; a++) {
305     BLO_expand(expander, gpd->mat[a]);
306   }
307 }
308
309 IDTypeInfo IDType_ID_GD = {
310     .id_code = ID_GD,
311     .id_filter = FILTER_ID_GD,
312     .main_listbase_index = INDEX_ID_GD,
313     .struct_size = sizeof(bGPdata),
314     .name = "GPencil",
315     .name_plural = "grease_pencils",
316     .translation_context = BLT_I18NCONTEXT_ID_GPENCIL,
317     .flags = 0,
318
319     .init_data = NULL,
320     .copy_data = greasepencil_copy_data,
321     .free_data = greasepencil_free_data,
322     .make_local = NULL,
323     .foreach_id = greasepencil_foreach_id,
324     .foreach_cache = NULL,
325     .owner_get = NULL,
326
327     .blend_write = greasepencil_blend_write,
328     .blend_read_data = greasepencil_blend_read_data,
329     .blend_read_lib = greasepencil_blend_read_lib,
330     .blend_read_expand = greasepencil_blend_read_expand,
331
332     .blend_read_undo_preserve = NULL,
333
334     .lib_override_apply_post = NULL,
335 };
336
337 /* ************************************************** */
338 /* Draw Engine */
339
340 void (*BKE_gpencil_batch_cache_dirty_tag_cb)(bGPdata *gpd) = NULL;
341 void (*BKE_gpencil_batch_cache_free_cb)(bGPdata *gpd) = NULL;
342
343 void BKE_gpencil_batch_cache_dirty_tag(bGPdata *gpd)
344 {
345   if (gpd) {
346     DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
347     BKE_gpencil_batch_cache_dirty_tag_cb(gpd);
348   }
349 }
350
351 void BKE_gpencil_batch_cache_free(bGPdata *gpd)
352 {
353   if (gpd) {
354     BKE_gpencil_batch_cache_free_cb(gpd);
355   }
356 }
357
358 /* ************************************************** */
359 /* Memory Management */
360
361 /* clean vertex groups weights */
362 void BKE_gpencil_free_point_weights(MDeformVert *dvert)
363 {
364   if (dvert == NULL) {
365     return;
366   }
367   MEM_SAFE_FREE(dvert->dw);
368 }
369
370 void BKE_gpencil_free_stroke_weights(bGPDstroke *gps)
371 {
372   if (gps == NULL) {
373     return;
374   }
375
376   if (gps->dvert == NULL) {
377     return;
378   }
379
380   for (int i = 0; i < gps->totpoints; i++) {
381     MDeformVert *dvert = &gps->dvert[i];
382     BKE_gpencil_free_point_weights(dvert);
383   }
384 }
385
386 void BKE_gpencil_free_stroke_editcurve(bGPDstroke *gps)
387 {
388   if (gps == NULL) {
389     return;
390   }
391   bGPDcurve *editcurve = gps->editcurve;
392   if (editcurve == NULL) {
393     return;
394   }
395   MEM_freeN(editcurve->curve_points);
396   MEM_freeN(editcurve);
397   gps->editcurve = NULL;
398 }
399
400 /* free stroke, doesn't unlink from any listbase */
401 void BKE_gpencil_free_stroke(bGPDstroke *gps)
402 {
403   if (gps == NULL) {
404     return;
405   }
406   /* free stroke memory arrays, then stroke itself */
407   if (gps->points) {
408     MEM_freeN(gps->points);
409   }
410   if (gps->dvert) {
411     BKE_gpencil_free_stroke_weights(gps);
412     MEM_freeN(gps->dvert);
413   }
414   if (gps->triangles) {
415     MEM_freeN(gps->triangles);
416   }
417   if (gps->editcurve != NULL) {
418     BKE_gpencil_free_stroke_editcurve(gps);
419   }
420
421   MEM_freeN(gps);
422 }
423
424 /* Free strokes belonging to a gp-frame */
425 bool BKE_gpencil_free_strokes(bGPDframe *gpf)
426 {
427   bool changed = (BLI_listbase_is_empty(&gpf->strokes) == false);
428
429   /* free strokes */
430   LISTBASE_FOREACH_MUTABLE (bGPDstroke *, gps, &gpf->strokes) {
431     BKE_gpencil_free_stroke(gps);
432   }
433   BLI_listbase_clear(&gpf->strokes);
434
435   return changed;
436 }
437
438 /* Free all of a gp-layer's frames */
439 void BKE_gpencil_free_frames(bGPDlayer *gpl)
440 {
441   bGPDframe *gpf_next;
442
443   /* error checking */
444   if (gpl == NULL) {
445     return;
446   }
447
448   /* free frames */
449   for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf_next) {
450     gpf_next = gpf->next;
451
452     /* free strokes and their associated memory */
453     BKE_gpencil_free_strokes(gpf);
454     BLI_freelinkN(&gpl->frames, gpf);
455   }
456   gpl->actframe = NULL;
457 }
458
459 void BKE_gpencil_free_layer_masks(bGPDlayer *gpl)
460 {
461   /* Free masks.*/
462   bGPDlayer_Mask *mask_next = NULL;
463   for (bGPDlayer_Mask *mask = gpl->mask_layers.first; mask; mask = mask_next) {
464     mask_next = mask->next;
465     BLI_freelinkN(&gpl->mask_layers, mask);
466   }
467 }
468 /* Free all of the gp-layers for a viewport (list should be &gpd->layers or so) */
469 void BKE_gpencil_free_layers(ListBase *list)
470 {
471   bGPDlayer *gpl_next;
472
473   /* error checking */
474   if (list == NULL) {
475     return;
476   }
477
478   /* delete layers */
479   for (bGPDlayer *gpl = list->first; gpl; gpl = gpl_next) {
480     gpl_next = gpl->next;
481
482     /* free layers and their data */
483     BKE_gpencil_free_frames(gpl);
484
485     /* Free masks.*/
486     BKE_gpencil_free_layer_masks(gpl);
487
488     BLI_freelinkN(list, gpl);
489   }
490 }
491
492 /** Free (or release) any data used by this grease pencil (does not free the gpencil itself). */
493 void BKE_gpencil_free(bGPdata *gpd, bool free_all)
494 {
495   /* free layers */
496   BKE_gpencil_free_layers(&gpd->layers);
497
498   /* materials */
499   MEM_SAFE_FREE(gpd->mat);
500
501   /* free all data */
502   if (free_all) {
503     /* clear cache */
504     BKE_gpencil_batch_cache_free(gpd);
505   }
506 }
507
508 /**
509  * Delete grease pencil evaluated data
510  * \param gpd_eval: Grease pencil data-block
511  */
512 void BKE_gpencil_eval_delete(bGPdata *gpd_eval)
513 {
514   BKE_gpencil_free(gpd_eval, true);
515   BKE_libblock_free_data(&gpd_eval->id, false);
516   MEM_freeN(gpd_eval);
517 }
518
519 /**
520  * Tag data-block for depsgraph update.
521  * Wrapper to avoid include Depsgraph tag functions in other modules.
522  * \param gpd: Grease pencil data-block.
523  */
524 void BKE_gpencil_tag(bGPdata *gpd)
525 {
526   DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
527 }
528
529 /* ************************************************** */
530 /* Container Creation */
531
532 /**
533  * Add a new gp-frame to the given layer.
534  * \param gpl: Grease pencil layer
535  * \param cframe: Frame number
536  * \return Pointer to new frame
537  */
538 bGPDframe *BKE_gpencil_frame_addnew(bGPDlayer *gpl, int cframe)
539 {
540   bGPDframe *gpf = NULL, *gf = NULL;
541   short state = 0;
542
543   /* error checking */
544   if (gpl == NULL) {
545     return NULL;
546   }
547
548   /* allocate memory for this frame */
549   gpf = MEM_callocN(sizeof(bGPDframe), "bGPDframe");
550   gpf->framenum = cframe;
551
552   /* find appropriate place to add frame */
553   if (gpl->frames.first) {
554     for (gf = gpl->frames.first; gf; gf = gf->next) {
555       /* check if frame matches one that is supposed to be added */
556       if (gf->framenum == cframe) {
557         state = -1;
558         break;
559       }
560
561       /* if current frame has already exceeded the frame to add, add before */
562       if (gf->framenum > cframe) {
563         BLI_insertlinkbefore(&gpl->frames, gf, gpf);
564         state = 1;
565         break;
566       }
567     }
568   }
569
570   /* check whether frame was added successfully */
571   if (state == -1) {
572     CLOG_ERROR(
573         &LOG, "Frame (%d) existed already for this layer_active. Using existing frame", cframe);
574
575     /* free the newly created one, and use the old one instead */
576     MEM_freeN(gpf);
577
578     /* return existing frame instead... */
579     BLI_assert(gf != NULL);
580     gpf = gf;
581   }
582   else if (state == 0) {
583     /* add to end then! */
584     BLI_addtail(&gpl->frames, gpf);
585   }
586
587   /* return frame */
588   return gpf;
589 }
590
591 /**
592  * Add a copy of the active gp-frame to the given layer.
593  * \param gpl: Grease pencil layer
594  * \param cframe: Frame number
595  * \return Pointer to new frame
596  */
597 bGPDframe *BKE_gpencil_frame_addcopy(bGPDlayer *gpl, int cframe)
598 {
599   bGPDframe *new_frame;
600   bool found = false;
601
602   /* Error checking/handling */
603   if (gpl == NULL) {
604     /* no layer */
605     return NULL;
606   }
607   if (gpl->actframe == NULL) {
608     /* no active frame, so just create a new one from scratch */
609     return BKE_gpencil_frame_addnew(gpl, cframe);
610   }
611
612   /* Create a copy of the frame */
613   new_frame = BKE_gpencil_frame_duplicate(gpl->actframe, true);
614
615   /* Find frame to insert it before */
616   LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
617     if (gpf->framenum > cframe) {
618       /* Add it here */
619       BLI_insertlinkbefore(&gpl->frames, gpf, new_frame);
620
621       found = true;
622       break;
623     }
624     if (gpf->framenum == cframe) {
625       /* This only happens when we're editing with framelock on...
626        * - Delete the new frame and don't do anything else here...
627        */
628       BKE_gpencil_free_strokes(new_frame);
629       MEM_freeN(new_frame);
630       new_frame = NULL;
631
632       found = true;
633       break;
634     }
635   }
636
637   if (found == false) {
638     /* Add new frame to the end */
639     BLI_addtail(&gpl->frames, new_frame);
640   }
641
642   /* Ensure that frame is set up correctly, and return it */
643   if (new_frame) {
644     new_frame->framenum = cframe;
645     gpl->actframe = new_frame;
646   }
647
648   return new_frame;
649 }
650
651 /**
652  * Add a new gp-layer and make it the active layer.
653  * \param gpd: Grease pencil data-block
654  * \param name: Name of the layer
655  * \param setactive: Set as active
656  * \return Pointer to new layer
657  */
658 bGPDlayer *BKE_gpencil_layer_addnew(bGPdata *gpd, const char *name, bool setactive)
659 {
660   bGPDlayer *gpl = NULL;
661   bGPDlayer *gpl_active = NULL;
662
663   /* check that list is ok */
664   if (gpd == NULL) {
665     return NULL;
666   }
667
668   /* allocate memory for frame and add to end of list */
669   gpl = MEM_callocN(sizeof(bGPDlayer), "bGPDlayer");
670
671   gpl_active = BKE_gpencil_layer_active_get(gpd);
672
673   /* Add to data-block. */
674   if (gpl_active == NULL) {
675     BLI_addtail(&gpd->layers, gpl);
676   }
677   else {
678     /* if active layer, add after that layer */
679     BLI_insertlinkafter(&gpd->layers, gpl_active, gpl);
680   }
681
682   /* annotation vs GP Object behavior is slightly different */
683   if (gpd->flag & GP_DATA_ANNOTATIONS) {
684     /* set default color of new strokes for this layer */
685     copy_v4_v4(gpl->color, U.gpencil_new_layer_col);
686     gpl->opacity = 1.0f;
687
688     /* set default thickness of new strokes for this layer */
689     gpl->thickness = 3;
690
691     /* Onion colors */
692     ARRAY_SET_ITEMS(gpl->gcolor_prev, 0.302f, 0.851f, 0.302f);
693     ARRAY_SET_ITEMS(gpl->gcolor_next, 0.250f, 0.1f, 1.0f);
694   }
695   else {
696     /* thickness parameter represents "thickness change", not absolute thickness */
697     gpl->thickness = 0;
698     gpl->opacity = 1.0f;
699     /* default channel color */
700     ARRAY_SET_ITEMS(gpl->color, 0.2f, 0.2f, 0.2f);
701     /* Default vertex mix. */
702     gpl->vertex_paint_opacity = 1.0f;
703     /* Enable onion skin. */
704     gpl->onion_flag |= GP_LAYER_ONIONSKIN;
705   }
706
707   /* auto-name */
708   BLI_strncpy(gpl->info, name, sizeof(gpl->info));
709   BLI_uniquename(&gpd->layers,
710                  gpl,
711                  (gpd->flag & GP_DATA_ANNOTATIONS) ? DATA_("Note") : DATA_("GP_Layer"),
712                  '.',
713                  offsetof(bGPDlayer, info),
714                  sizeof(gpl->info));
715
716   /* Enable always affected by scene lights. */
717   gpl->flag |= GP_LAYER_USE_LIGHTS;
718
719   /* Init transform. */
720   zero_v3(gpl->location);
721   zero_v3(gpl->rotation);
722   copy_v3_fl(gpl->scale, 1.0f);
723   loc_eul_size_to_mat4(gpl->layer_mat, gpl->location, gpl->rotation, gpl->scale);
724   invert_m4_m4(gpl->layer_invmat, gpl->layer_mat);
725
726   /* make this one the active one */
727   if (setactive) {
728     BKE_gpencil_layer_active_set(gpd, gpl);
729   }
730
731   /* return layer */
732   return gpl;
733 }
734
735 /**
736  * Add a new grease pencil data-block.
737  * \param bmain: Main pointer
738  * \param name: Name of the datablock
739  * \return Pointer to new data-block
740  */
741 bGPdata *BKE_gpencil_data_addnew(Main *bmain, const char name[])
742 {
743   bGPdata *gpd;
744
745   /* allocate memory for a new block */
746   gpd = BKE_libblock_alloc(bmain, ID_GD, name, 0);
747
748   /* initial settings */
749   gpd->flag = (GP_DATA_DISPINFO | GP_DATA_EXPAND);
750
751   /* general flags */
752   gpd->flag |= GP_DATA_VIEWALIGN;
753   /* always enable object onion skin switch */
754   gpd->flag |= GP_DATA_SHOW_ONIONSKINS;
755   /* GP object specific settings */
756   ARRAY_SET_ITEMS(gpd->line_color, 0.6f, 0.6f, 0.6f, 0.5f);
757
758   gpd->pixfactor = GP_DEFAULT_PIX_FACTOR;
759
760   gpd->curve_edit_resolution = GP_DEFAULT_CURVE_RESOLUTION;
761   gpd->curve_edit_threshold = GP_DEFAULT_CURVE_ERROR;
762   gpd->curve_edit_corner_angle = GP_DEFAULT_CURVE_EDIT_CORNER_ANGLE;
763
764   /* use adaptive curve resolution by default */
765   gpd->flag |= GP_DATA_CURVE_ADAPTIVE_RESOLUTION;
766
767   gpd->zdepth_offset = 0.150f;
768
769   /* grid settings */
770   ARRAY_SET_ITEMS(gpd->grid.color, 0.5f, 0.5f, 0.5f); /* Color */
771   ARRAY_SET_ITEMS(gpd->grid.scale, 1.0f, 1.0f);       /* Scale */
772   gpd->grid.lines = GP_DEFAULT_GRID_LINES;            /* Number of lines */
773
774   /* Onion-skinning settings (data-block level) */
775   gpd->onion_keytype = -1; /* All by default. */
776   gpd->onion_flag |= (GP_ONION_GHOST_PREVCOL | GP_ONION_GHOST_NEXTCOL);
777   gpd->onion_flag |= GP_ONION_FADE;
778   gpd->onion_mode = GP_ONION_MODE_RELATIVE;
779   gpd->onion_factor = 0.5f;
780   ARRAY_SET_ITEMS(gpd->gcolor_prev, 0.145098f, 0.419608f, 0.137255f); /* green */
781   ARRAY_SET_ITEMS(gpd->gcolor_next, 0.125490f, 0.082353f, 0.529412f); /* blue */
782   gpd->gstep = 1;
783   gpd->gstep_next = 1;
784
785   return gpd;
786 }
787
788 /* ************************************************** */
789 /* Primitive Creation */
790 /* Utilities for easier bulk-creation of geometry */
791
792 /**
793  * Populate stroke with point data from data buffers.
794  * \param gps: Grease pencil stroke
795  * \param array: Flat array of point data values. Each entry has #GP_PRIM_DATABUF_SIZE values.
796  * \param totpoints: Total of points
797  * \param mat: 4x4 transform matrix to transform points into the right coordinate space.
798  */
799 void BKE_gpencil_stroke_add_points(bGPDstroke *gps,
800                                    const float *array,
801                                    const int totpoints,
802                                    const float mat[4][4])
803 {
804   for (int i = 0; i < totpoints; i++) {
805     bGPDspoint *pt = &gps->points[i];
806     const int x = GP_PRIM_DATABUF_SIZE * i;
807
808     pt->x = array[x];
809     pt->y = array[x + 1];
810     pt->z = array[x + 2];
811     mul_m4_v3(mat, &pt->x);
812
813     pt->pressure = array[x + 3];
814     pt->strength = array[x + 4];
815   }
816 }
817
818 /**
819  * Create a new stroke, with pre-allocated data buffers.
820  * \param mat_idx: Index of the material
821  * \param totpoints: Total points
822  * \param thickness: Stroke thickness
823  * \return Pointer to new stroke
824  */
825 bGPDstroke *BKE_gpencil_stroke_new(int mat_idx, int totpoints, short thickness)
826 {
827   /* allocate memory for a new stroke */
828   bGPDstroke *gps = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
829
830   gps->thickness = thickness;
831   gps->fill_opacity_fac = 1.0f;
832   gps->hardeness = 1.0f;
833   copy_v2_fl(gps->aspect_ratio, 1.0f);
834
835   gps->uv_scale = 1.0f;
836
837   gps->inittime = 0;
838
839   gps->flag = GP_STROKE_3DSPACE;
840
841   gps->totpoints = totpoints;
842   if (gps->totpoints > 0) {
843     gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
844   }
845   else {
846     gps->points = NULL;
847   }
848
849   /* initialize triangle memory to dummy data */
850   gps->triangles = NULL;
851   gps->tot_triangles = 0;
852
853   gps->mat_nr = mat_idx;
854
855   gps->dvert = NULL;
856   gps->editcurve = NULL;
857
858   return gps;
859 }
860
861 /**
862  * Create a new stroke and add to frame.
863  * \param gpf: Grease pencil frame
864  * \param mat_idx: Material index
865  * \param totpoints: Total points
866  * \param thickness: Stroke thickness
867  * \param insert_at_head: Add to the head of the strokes list
868  * \return Pointer to new stroke
869  */
870 bGPDstroke *BKE_gpencil_stroke_add(
871     bGPDframe *gpf, int mat_idx, int totpoints, short thickness, const bool insert_at_head)
872 {
873   bGPDstroke *gps = BKE_gpencil_stroke_new(mat_idx, totpoints, thickness);
874
875   /* Add to frame. */
876   if ((gps != NULL) && (gpf != NULL)) {
877     if (!insert_at_head) {
878       BLI_addtail(&gpf->strokes, gps);
879     }
880     else {
881       BLI_addhead(&gpf->strokes, gps);
882     }
883   }
884
885   return gps;
886 }
887
888 /**
889  * Add a stroke and copy the temporary drawing color value
890  * from one of the existing stroke.
891  * \param gpf: Grease pencil frame
892  * \param existing: Stroke with the style to copy
893  * \param mat_idx: Material index
894  * \param totpoints: Total points
895  * \param thickness: Stroke thickness
896  * \return Pointer to new stroke
897  */
898 bGPDstroke *BKE_gpencil_stroke_add_existing_style(
899     bGPDframe *gpf, bGPDstroke *existing, int mat_idx, int totpoints, short thickness)
900 {
901   bGPDstroke *gps = BKE_gpencil_stroke_add(gpf, mat_idx, totpoints, thickness, false);
902   /* Copy run-time color data so that strokes added in the modifier has the style.
903    * There are depsgraph reference pointers inside,
904    * change the copy function if interfere with future drawing implementation. */
905   memcpy(&gps->runtime, &existing->runtime, sizeof(bGPDstroke_Runtime));
906   return gps;
907 }
908
909 bGPDcurve *BKE_gpencil_stroke_editcurve_new(const int tot_curve_points)
910 {
911   bGPDcurve *new_gp_curve = (bGPDcurve *)MEM_callocN(sizeof(bGPDcurve), __func__);
912   new_gp_curve->tot_curve_points = tot_curve_points;
913   new_gp_curve->curve_points = (bGPDcurve_point *)MEM_callocN(
914       sizeof(bGPDcurve_point) * tot_curve_points, __func__);
915
916   return new_gp_curve;
917 }
918
919 /* ************************************************** */
920 /* Data Duplication */
921
922 /**
923  * Make a copy of a given gpencil weights.
924  * \param gps_src: Source grease pencil stroke
925  * \param gps_dst: Destination grease pencil stroke
926  */
927 void BKE_gpencil_stroke_weights_duplicate(bGPDstroke *gps_src, bGPDstroke *gps_dst)
928 {
929   if (gps_src == NULL) {
930     return;
931   }
932   BLI_assert(gps_src->totpoints == gps_dst->totpoints);
933
934   BKE_defvert_array_copy(gps_dst->dvert, gps_src->dvert, gps_src->totpoints);
935 }
936
937 /* Make a copy of a given gpencil stroke editcurve */
938 bGPDcurve *BKE_gpencil_stroke_curve_duplicate(bGPDcurve *gpc_src)
939 {
940   bGPDcurve *gpc_dst = MEM_dupallocN(gpc_src);
941
942   if (gpc_src->curve_points != NULL) {
943     gpc_dst->curve_points = MEM_dupallocN(gpc_src->curve_points);
944   }
945
946   return gpc_dst;
947 }
948
949 /**
950  * Make a copy of a given grease-pencil stroke.
951  * \param gps_src: Source grease pencil strokes.
952  * \param dup_points: Duplicate points data.
953  * \param dup_curve: Duplicate curve data.
954  * \return Pointer to new stroke.
955  */
956 bGPDstroke *BKE_gpencil_stroke_duplicate(bGPDstroke *gps_src,
957                                          const bool dup_points,
958                                          const bool dup_curve)
959 {
960   bGPDstroke *gps_dst = NULL;
961
962   gps_dst = MEM_dupallocN(gps_src);
963   gps_dst->prev = gps_dst->next = NULL;
964   gps_dst->triangles = MEM_dupallocN(gps_src->triangles);
965
966   if (dup_points) {
967     gps_dst->points = MEM_dupallocN(gps_src->points);
968
969     if (gps_src->dvert != NULL) {
970       gps_dst->dvert = MEM_dupallocN(gps_src->dvert);
971       BKE_gpencil_stroke_weights_duplicate(gps_src, gps_dst);
972     }
973     else {
974       gps_dst->dvert = NULL;
975     }
976   }
977   else {
978     gps_dst->points = NULL;
979     gps_dst->dvert = NULL;
980   }
981
982   if (dup_curve && gps_src->editcurve != NULL) {
983     gps_dst->editcurve = BKE_gpencil_stroke_curve_duplicate(gps_src->editcurve);
984   }
985   else {
986     gps_dst->editcurve = NULL;
987   }
988
989   /* return new stroke */
990   return gps_dst;
991 }
992
993 /**
994  * Make a copy of a given gpencil frame.
995  * \param gpf_src: Source grease pencil frame
996  * \return Pointer to new frame
997  */
998 bGPDframe *BKE_gpencil_frame_duplicate(const bGPDframe *gpf_src, const bool dup_strokes)
999 {
1000   bGPDstroke *gps_dst = NULL;
1001   bGPDframe *gpf_dst;
1002
1003   /* error checking */
1004   if (gpf_src == NULL) {
1005     return NULL;
1006   }
1007
1008   /* make a copy of the source frame */
1009   gpf_dst = MEM_dupallocN(gpf_src);
1010   gpf_dst->prev = gpf_dst->next = NULL;
1011
1012   /* Copy strokes. */
1013   BLI_listbase_clear(&gpf_dst->strokes);
1014   if (dup_strokes) {
1015     LISTBASE_FOREACH (bGPDstroke *, gps_src, &gpf_src->strokes) {
1016       /* make copy of source stroke */
1017       gps_dst = BKE_gpencil_stroke_duplicate(gps_src, true, true);
1018       BLI_addtail(&gpf_dst->strokes, gps_dst);
1019     }
1020   }
1021
1022   /* return new frame */
1023   return gpf_dst;
1024 }
1025
1026 /**
1027  * Make a copy of strokes between gpencil frames.
1028  * \param gpf_src: Source grease pencil frame
1029  * \param gpf_dst: Destination grease pencil frame
1030  */
1031 void BKE_gpencil_frame_copy_strokes(bGPDframe *gpf_src, struct bGPDframe *gpf_dst)
1032 {
1033   bGPDstroke *gps_dst = NULL;
1034   /* error checking */
1035   if ((gpf_src == NULL) || (gpf_dst == NULL)) {
1036     return;
1037   }
1038
1039   /* copy strokes */
1040   BLI_listbase_clear(&gpf_dst->strokes);
1041   LISTBASE_FOREACH (bGPDstroke *, gps_src, &gpf_src->strokes) {
1042     /* make copy of source stroke */
1043     gps_dst = BKE_gpencil_stroke_duplicate(gps_src, true, true);
1044     BLI_addtail(&gpf_dst->strokes, gps_dst);
1045   }
1046 }
1047
1048 /**
1049  * Make a copy of a given gpencil layer.
1050  * \param gpl_src: Source grease pencil layer
1051  * \return Pointer to new layer
1052  */
1053 bGPDlayer *BKE_gpencil_layer_duplicate(const bGPDlayer *gpl_src,
1054                                        const bool dup_frames,
1055                                        const bool dup_strokes)
1056 {
1057   const bGPDframe *gpf_src;
1058   bGPDframe *gpf_dst;
1059   bGPDlayer *gpl_dst;
1060
1061   /* error checking */
1062   if (gpl_src == NULL) {
1063     return NULL;
1064   }
1065
1066   /* make a copy of source layer */
1067   gpl_dst = MEM_dupallocN(gpl_src);
1068   gpl_dst->prev = gpl_dst->next = NULL;
1069
1070   /* Copy masks. */
1071   BLI_listbase_clear(&gpl_dst->mask_layers);
1072   LISTBASE_FOREACH (bGPDlayer_Mask *, mask_src, &gpl_src->mask_layers) {
1073     bGPDlayer_Mask *mask_dst = MEM_dupallocN(mask_src);
1074     mask_dst->prev = mask_dst->next = NULL;
1075     BLI_addtail(&gpl_dst->mask_layers, mask_dst);
1076   }
1077
1078   /* copy frames */
1079   BLI_listbase_clear(&gpl_dst->frames);
1080   if (dup_frames) {
1081     for (gpf_src = gpl_src->frames.first; gpf_src; gpf_src = gpf_src->next) {
1082       /* make a copy of source frame */
1083       gpf_dst = BKE_gpencil_frame_duplicate(gpf_src, dup_strokes);
1084       BLI_addtail(&gpl_dst->frames, gpf_dst);
1085
1086       /* if source frame was the current layer's 'active' frame, reassign that too */
1087       if (gpf_src == gpl_dst->actframe) {
1088         gpl_dst->actframe = gpf_dst;
1089       }
1090     }
1091   }
1092
1093   /* return new layer */
1094   return gpl_dst;
1095 }
1096
1097 /**
1098  * Make a copy of a given gpencil data-block.
1099  *
1100  * XXX: Should this be deprecated?
1101  */
1102 bGPdata *BKE_gpencil_data_duplicate(Main *bmain, const bGPdata *gpd_src, bool internal_copy)
1103 {
1104   bGPdata *gpd_dst;
1105
1106   /* Yuck and super-uber-hyper yuck!!!
1107    * Should be replaceable with a no-main copy (LIB_ID_COPY_NO_MAIN etc.), but not sure about it,
1108    * so for now keep old code for that one. */
1109
1110   /* error checking */
1111   if (gpd_src == NULL) {
1112     return NULL;
1113   }
1114
1115   if (internal_copy) {
1116     /* make a straight copy for undo buffers used during stroke drawing */
1117     gpd_dst = MEM_dupallocN(gpd_src);
1118   }
1119   else {
1120     BLI_assert(bmain != NULL);
1121     gpd_dst = (bGPdata *)BKE_id_copy(bmain, &gpd_src->id);
1122   }
1123
1124   /* Copy internal data (layers, etc.) */
1125   greasepencil_copy_data(bmain, &gpd_dst->id, &gpd_src->id, 0);
1126
1127   /* return new */
1128   return gpd_dst;
1129 }
1130
1131 /* ************************************************** */
1132 /* GP Stroke API */
1133
1134 /**
1135  * Ensure selection status of stroke is in sync with its points.
1136  * \param gps: Grease pencil stroke
1137  */
1138 void BKE_gpencil_stroke_sync_selection(bGPdata *gpd, bGPDstroke *gps)
1139 {
1140   bGPDspoint *pt;
1141   int i;
1142
1143   /* error checking */
1144   if (gps == NULL) {
1145     return;
1146   }
1147
1148   /* we'll stop when we find the first selected point,
1149    * so initially, we must deselect
1150    */
1151   gps->flag &= ~GP_STROKE_SELECT;
1152   BKE_gpencil_stroke_select_index_reset(gps);
1153
1154   for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1155     if (pt->flag & GP_SPOINT_SELECT) {
1156       gps->flag |= GP_STROKE_SELECT;
1157       break;
1158     }
1159   }
1160
1161   if (gps->flag & GP_STROKE_SELECT) {
1162     BKE_gpencil_stroke_select_index_set(gpd, gps);
1163   }
1164 }
1165
1166 void BKE_gpencil_curve_sync_selection(bGPdata *gpd, bGPDstroke *gps)
1167 {
1168   bGPDcurve *gpc = gps->editcurve;
1169   if (gpc == NULL) {
1170     return;
1171   }
1172
1173   gps->flag &= ~GP_STROKE_SELECT;
1174   BKE_gpencil_stroke_select_index_reset(gps);
1175   gpc->flag &= ~GP_CURVE_SELECT;
1176
1177   bool is_selected = false;
1178   for (int i = 0; i < gpc->tot_curve_points; i++) {
1179     bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
1180     BezTriple *bezt = &gpc_pt->bezt;
1181
1182     if (BEZT_ISSEL_ANY(bezt)) {
1183       gpc_pt->flag |= GP_SPOINT_SELECT;
1184     }
1185     else {
1186       gpc_pt->flag &= ~GP_SPOINT_SELECT;
1187     }
1188
1189     if (gpc_pt->flag & GP_SPOINT_SELECT) {
1190       is_selected = true;
1191     }
1192   }
1193
1194   if (is_selected) {
1195     gpc->flag |= GP_CURVE_SELECT;
1196     gps->flag |= GP_STROKE_SELECT;
1197     BKE_gpencil_stroke_select_index_set(gpd, gps);
1198   }
1199 }
1200
1201 /* Assign unique stroke ID for selection. */
1202 void BKE_gpencil_stroke_select_index_set(bGPdata *gpd, bGPDstroke *gps)
1203 {
1204   gpd->select_last_index++;
1205   gps->select_index = gpd->select_last_index;
1206 }
1207
1208 /* Reset unique stroke ID for selection. */
1209 void BKE_gpencil_stroke_select_index_reset(bGPDstroke *gps)
1210 {
1211   gps->select_index = 0;
1212 }
1213
1214 /* ************************************************** */
1215 /* GP Frame API */
1216
1217 /**
1218  * Delete the last stroke of the given frame.
1219  * \param gpl: Grease pencil layer
1220  * \param gpf: Grease pencil frame
1221  */
1222 void BKE_gpencil_frame_delete_laststroke(bGPDlayer *gpl, bGPDframe *gpf)
1223 {
1224   bGPDstroke *gps = (gpf) ? gpf->strokes.last : NULL;
1225   int cfra = (gpf) ? gpf->framenum : 0; /* assume that the current frame was not locked */
1226
1227   /* error checking */
1228   if (ELEM(NULL, gpf, gps)) {
1229     return;
1230   }
1231
1232   /* free the stroke and its data */
1233   if (gps->points) {
1234     MEM_freeN(gps->points);
1235   }
1236   if (gps->dvert) {
1237     BKE_gpencil_free_stroke_weights(gps);
1238     MEM_freeN(gps->dvert);
1239   }
1240   MEM_freeN(gps->triangles);
1241   BLI_freelinkN(&gpf->strokes, gps);
1242
1243   /* if frame has no strokes after this, delete it */
1244   if (BLI_listbase_is_empty(&gpf->strokes)) {
1245     BKE_gpencil_layer_frame_delete(gpl, gpf);
1246     BKE_gpencil_layer_frame_get(gpl, cfra, GP_GETFRAME_USE_PREV);
1247   }
1248 }
1249
1250 /* ************************************************** */
1251 /* GP Layer API */
1252
1253 /**
1254  * Check if the given layer is able to be edited or not.
1255  * \param gpl: Grease pencil layer
1256  * \return True if layer is editable
1257  */
1258 bool BKE_gpencil_layer_is_editable(const bGPDlayer *gpl)
1259 {
1260   /* Sanity check */
1261   if (gpl == NULL) {
1262     return false;
1263   }
1264
1265   /* Layer must be: Visible + Editable */
1266   if ((gpl->flag & (GP_LAYER_HIDE | GP_LAYER_LOCKED)) == 0) {
1267     return true;
1268   }
1269
1270   /* Something failed */
1271   return false;
1272 }
1273
1274 /**
1275  * Look up the gp-frame on the requested frame number, but don't add a new one.
1276  * \param gpl: Grease pencil layer
1277  * \param cframe: Frame number
1278  * \return Pointer to frame
1279  */
1280 bGPDframe *BKE_gpencil_layer_frame_find(bGPDlayer *gpl, int cframe)
1281 {
1282   bGPDframe *gpf;
1283
1284   /* Search in reverse order, since this is often used for playback/adding,
1285    * where it's less likely that we're interested in the earlier frames
1286    */
1287   for (gpf = gpl->frames.last; gpf; gpf = gpf->prev) {
1288     if (gpf->framenum == cframe) {
1289       return gpf;
1290     }
1291   }
1292
1293   return NULL;
1294 }
1295
1296 /**
1297  * Get the appropriate gp-frame from a given layer
1298  * - this sets the layer's actframe var (if allowed to)
1299  * - extension beyond range (if first gp-frame is after all frame in interest and cannot add)
1300  *
1301  * \param gpl: Grease pencil layer
1302  * \param cframe: Frame number
1303  * \param addnew: Add option
1304  * \return Pointer to new frame
1305  */
1306 bGPDframe *BKE_gpencil_layer_frame_get(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
1307 {
1308   bGPDframe *gpf = NULL;
1309   bool found = false;
1310
1311   /* error checking */
1312   if (gpl == NULL) {
1313     return NULL;
1314   }
1315
1316   /* check if there is already an active frame */
1317   if (gpl->actframe) {
1318     gpf = gpl->actframe;
1319
1320     /* do not allow any changes to layer's active frame if layer is locked from changes
1321      * or if the layer has been set to stay on the current frame
1322      */
1323     if (gpl->flag & GP_LAYER_FRAMELOCK) {
1324       return gpf;
1325     }
1326     /* do not allow any changes to actframe if frame has painting tag attached to it */
1327     if (gpf->flag & GP_FRAME_PAINT) {
1328       return gpf;
1329     }
1330
1331     /* try to find matching frame */
1332     if (gpf->framenum < cframe) {
1333       for (; gpf; gpf = gpf->next) {
1334         if (gpf->framenum == cframe) {
1335           found = true;
1336           break;
1337         }
1338         if ((gpf->next) && (gpf->next->framenum > cframe)) {
1339           found = true;
1340           break;
1341         }
1342       }
1343
1344       /* set the appropriate frame */
1345       if (addnew) {
1346         if ((found) && (gpf->framenum == cframe)) {
1347           gpl->actframe = gpf;
1348         }
1349         else if (addnew == GP_GETFRAME_ADD_COPY) {
1350           gpl->actframe = BKE_gpencil_frame_addcopy(gpl, cframe);
1351         }
1352         else {
1353           gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
1354         }
1355       }
1356       else if (found) {
1357         gpl->actframe = gpf;
1358       }
1359       else {
1360         gpl->actframe = gpl->frames.last;
1361       }
1362     }
1363     else {
1364       for (; gpf; gpf = gpf->prev) {
1365         if (gpf->framenum <= cframe) {
1366           found = true;
1367           break;
1368         }
1369       }
1370
1371       /* set the appropriate frame */
1372       if (addnew) {
1373         if ((found) && (gpf->framenum == cframe)) {
1374           gpl->actframe = gpf;
1375         }
1376         else if (addnew == GP_GETFRAME_ADD_COPY) {
1377           gpl->actframe = BKE_gpencil_frame_addcopy(gpl, cframe);
1378         }
1379         else {
1380           gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
1381         }
1382       }
1383       else if (found) {
1384         gpl->actframe = gpf;
1385       }
1386       else {
1387         gpl->actframe = gpl->frames.first;
1388       }
1389     }
1390   }
1391   else if (gpl->frames.first) {
1392     /* check which of the ends to start checking from */
1393     const int first = ((bGPDframe *)(gpl->frames.first))->framenum;
1394     const int last = ((bGPDframe *)(gpl->frames.last))->framenum;
1395
1396     if (abs(cframe - first) > abs(cframe - last)) {
1397       /* find gp-frame which is less than or equal to cframe */
1398       for (gpf = gpl->frames.last; gpf; gpf = gpf->prev) {
1399         if (gpf->framenum <= cframe) {
1400           found = true;
1401           break;
1402         }
1403       }
1404     }
1405     else {
1406       /* find gp-frame which is less than or equal to cframe */
1407       for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1408         if (gpf->framenum <= cframe) {
1409           found = true;
1410           break;
1411         }
1412       }
1413     }
1414
1415     /* set the appropriate frame */
1416     if (addnew) {
1417       if ((found) && (gpf->framenum == cframe)) {
1418         gpl->actframe = gpf;
1419       }
1420       else {
1421         gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
1422       }
1423     }
1424     else if (found) {
1425       gpl->actframe = gpf;
1426     }
1427     else {
1428       /* If delete first frame, need to find one. */
1429       if (gpl->frames.first != NULL) {
1430         gpl->actframe = gpl->frames.first;
1431       }
1432       else {
1433         /* unresolved errogenous situation! */
1434         CLOG_STR_ERROR(&LOG, "cannot find appropriate gp-frame");
1435         /* gpl->actframe should still be NULL */
1436       }
1437     }
1438   }
1439   else {
1440     /* currently no frames (add if allowed to) */
1441     if (addnew) {
1442       gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
1443     }
1444     else {
1445       /* don't do anything... this may be when no frames yet! */
1446       /* gpl->actframe should still be NULL */
1447     }
1448   }
1449
1450   /* Don't select first frame if greater than current frame. */
1451   if ((gpl->actframe != NULL) && (gpl->actframe == gpl->frames.first) &&
1452       (gpl->actframe->framenum > cframe)) {
1453     gpl->actframe = NULL;
1454   }
1455
1456   /* return */
1457   return gpl->actframe;
1458 }
1459
1460 /**
1461  * Delete the given frame from a layer.
1462  * \param gpl: Grease pencil layer
1463  * \param gpf: Grease pencil frame
1464  * \return True if delete was done
1465  */
1466 bool BKE_gpencil_layer_frame_delete(bGPDlayer *gpl, bGPDframe *gpf)
1467 {
1468   bool changed = false;
1469
1470   /* error checking */
1471   if (ELEM(NULL, gpl, gpf)) {
1472     return false;
1473   }
1474
1475   /* if this frame was active, make the previous frame active instead
1476    * since it's tricky to set active frame otherwise
1477    */
1478   if (gpl->actframe == gpf) {
1479     gpl->actframe = gpf->prev;
1480   }
1481
1482   /* free the frame and its data */
1483   changed = BKE_gpencil_free_strokes(gpf);
1484   BLI_freelinkN(&gpl->frames, gpf);
1485
1486   return changed;
1487 }
1488
1489 /**
1490  * Get layer by name
1491  * \param gpd: Grease pencil data-block
1492  * \param name: Layer name
1493  * \return Pointer to layer
1494  */
1495 bGPDlayer *BKE_gpencil_layer_named_get(bGPdata *gpd, const char *name)
1496 {
1497   if (name[0] == '\0') {
1498     return NULL;
1499   }
1500   return BLI_findstring(&gpd->layers, name, offsetof(bGPDlayer, info));
1501 }
1502
1503 /**
1504  * Get mask layer by name.
1505  * \param gpl: Grease pencil layer
1506  * \param name: Mask name
1507  * \return Pointer to mask layer
1508  */
1509 bGPDlayer_Mask *BKE_gpencil_layer_mask_named_get(bGPDlayer *gpl, const char *name)
1510 {
1511   if (name[0] == '\0') {
1512     return NULL;
1513   }
1514   return BLI_findstring(&gpl->mask_layers, name, offsetof(bGPDlayer_Mask, name));
1515 }
1516
1517 /**
1518  * Add grease pencil mask layer.
1519  * \param gpl: Grease pencil layer
1520  * \param name: Name of the mask
1521  * \return Pointer to new mask layer
1522  */
1523 bGPDlayer_Mask *BKE_gpencil_layer_mask_add(bGPDlayer *gpl, const char *name)
1524 {
1525
1526   bGPDlayer_Mask *mask = MEM_callocN(sizeof(bGPDlayer_Mask), "bGPDlayer_Mask");
1527   BLI_addtail(&gpl->mask_layers, mask);
1528   BLI_strncpy(mask->name, name, sizeof(mask->name));
1529   gpl->act_mask++;
1530
1531   return mask;
1532 }
1533
1534 /**
1535  * Remove grease pencil mask layer.
1536  * \param gpl: Grease pencil layer
1537  * \param mask: Grease pencil mask layer
1538  */
1539 void BKE_gpencil_layer_mask_remove(bGPDlayer *gpl, bGPDlayer_Mask *mask)
1540 {
1541   BLI_freelinkN(&gpl->mask_layers, mask);
1542   gpl->act_mask--;
1543   CLAMP_MIN(gpl->act_mask, 0);
1544 }
1545
1546 /**
1547  * Remove any reference to mask layer.
1548  * \param gpd: Grease pencil data-block
1549  * \param name: Name of the mask layer
1550  */
1551 void BKE_gpencil_layer_mask_remove_ref(bGPdata *gpd, const char *name)
1552 {
1553   bGPDlayer_Mask *mask_next;
1554
1555   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1556     for (bGPDlayer_Mask *mask = gpl->mask_layers.first; mask; mask = mask_next) {
1557       mask_next = mask->next;
1558       if (STREQ(mask->name, name)) {
1559         BKE_gpencil_layer_mask_remove(gpl, mask);
1560       }
1561     }
1562   }
1563 }
1564
1565 static int gpencil_cb_sort_masks(const void *arg1, const void *arg2)
1566 {
1567   /* sort is inverted as layer list. */
1568   const struct bGPDlayer_Mask *mask1 = arg1;
1569   const struct bGPDlayer_Mask *mask2 = arg2;
1570   int val = 0;
1571
1572   if (mask1->sort_index < mask2->sort_index) {
1573     val = 1;
1574   }
1575   else if (mask1->sort_index > mask2->sort_index) {
1576     val = -1;
1577   }
1578
1579   return val;
1580 }
1581
1582 /**
1583  * Sort grease pencil mask layers.
1584  * \param gpd: Grease pencil data-block
1585  * \param gpl: Grease pencil layer
1586  */
1587 void BKE_gpencil_layer_mask_sort(bGPdata *gpd, bGPDlayer *gpl)
1588 {
1589   /* Update sort index. */
1590   LISTBASE_FOREACH (bGPDlayer_Mask *, mask, &gpl->mask_layers) {
1591     bGPDlayer *gpl_mask = BKE_gpencil_layer_named_get(gpd, mask->name);
1592     if (gpl_mask != NULL) {
1593       mask->sort_index = BLI_findindex(&gpd->layers, gpl_mask);
1594     }
1595     else {
1596       mask->sort_index = 0;
1597     }
1598   }
1599   BLI_listbase_sort(&gpl->mask_layers, gpencil_cb_sort_masks);
1600 }
1601
1602 /**
1603  * Sort all grease pencil mask layer.
1604  * \param gpd: Grease pencil data-block
1605  */
1606 void BKE_gpencil_layer_mask_sort_all(bGPdata *gpd)
1607 {
1608   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1609     BKE_gpencil_layer_mask_sort(gpd, gpl);
1610   }
1611 }
1612
1613 static int gpencil_cb_cmp_frame(void *thunk, const void *a, const void *b)
1614 {
1615   const bGPDframe *frame_a = a;
1616   const bGPDframe *frame_b = b;
1617
1618   if (frame_a->framenum < frame_b->framenum) {
1619     return -1;
1620   }
1621   if (frame_a->framenum > frame_b->framenum) {
1622     return 1;
1623   }
1624   if (thunk != NULL) {
1625     *((bool *)thunk) = true;
1626   }
1627   /* Sort selected last. */
1628   if ((frame_a->flag & GP_FRAME_SELECT) && ((frame_b->flag & GP_FRAME_SELECT) == 0)) {
1629     return 1;
1630   }
1631   return 0;
1632 }
1633
1634 /**
1635  * Sort grease pencil frames.
1636  * \param gpl: Grease pencil layer
1637  * \param r_has_duplicate_frames: Duplicated frames flag
1638  */
1639 void BKE_gpencil_layer_frames_sort(struct bGPDlayer *gpl, bool *r_has_duplicate_frames)
1640 {
1641   BLI_listbase_sort_r(&gpl->frames, gpencil_cb_cmp_frame, r_has_duplicate_frames);
1642 }
1643
1644 /**
1645  * Get the active grease pencil layer for editing.
1646  * \param gpd: Grease pencil data-block
1647  * \return Pointer to layer
1648  */
1649 bGPDlayer *BKE_gpencil_layer_active_get(bGPdata *gpd)
1650 {
1651   /* error checking */
1652   if (ELEM(NULL, gpd, gpd->layers.first)) {
1653     return NULL;
1654   }
1655
1656   /* loop over layers until found (assume only one active) */
1657   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1658     if (gpl->flag & GP_LAYER_ACTIVE) {
1659       return gpl;
1660     }
1661   }
1662
1663   /* no active layer found */
1664   return NULL;
1665 }
1666
1667 bGPDlayer *BKE_gpencil_layer_get_by_name(bGPdata *gpd, char *name, int first_if_not_found)
1668 {
1669   bGPDlayer *gpl;
1670   int i = 0;
1671
1672   /* error checking */
1673   if (ELEM(NULL, gpd, gpd->layers.first)) {
1674     return NULL;
1675   }
1676
1677   /* loop over layers until found (assume only one active) */
1678   for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1679     if (STREQ(name, gpl->info)) {
1680       return gpl;
1681     }
1682     i++;
1683   }
1684
1685   /* no such layer */
1686   if (first_if_not_found) {
1687     return gpd->layers.first;
1688   }
1689   return NULL;
1690 }
1691
1692 /**
1693  * Set active grease pencil layer.
1694  * \param gpd: Grease pencil data-block
1695  * \param active: Grease pencil layer to set as active
1696  */
1697 void BKE_gpencil_layer_active_set(bGPdata *gpd, bGPDlayer *active)
1698 {
1699   /* error checking */
1700   if (ELEM(NULL, gpd, gpd->layers.first, active)) {
1701     return;
1702   }
1703
1704   /* loop over layers deactivating all */
1705   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1706     gpl->flag &= ~GP_LAYER_ACTIVE;
1707     if (gpd->flag & GP_DATA_AUTOLOCK_LAYERS) {
1708       gpl->flag |= GP_LAYER_LOCKED;
1709     }
1710   }
1711
1712   /* set as active one */
1713   active->flag |= GP_LAYER_ACTIVE;
1714   if (gpd->flag & GP_DATA_AUTOLOCK_LAYERS) {
1715     active->flag &= ~GP_LAYER_LOCKED;
1716   }
1717 }
1718
1719 /**
1720  * Set locked layers for autolock mode.
1721  * \param gpd: Grease pencil data-block
1722  * \param unlock: Unlock flag
1723  */
1724 void BKE_gpencil_layer_autolock_set(bGPdata *gpd, const bool unlock)
1725 {
1726   BLI_assert(gpd != NULL);
1727
1728   if (gpd->flag & GP_DATA_AUTOLOCK_LAYERS) {
1729     bGPDlayer *layer_active = BKE_gpencil_layer_active_get(gpd);
1730
1731     /* Lock all other layers */
1732     LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1733       /* unlock active layer */
1734       if (gpl == layer_active) {
1735         gpl->flag &= ~GP_LAYER_LOCKED;
1736       }
1737       else {
1738         gpl->flag |= GP_LAYER_LOCKED;
1739       }
1740     }
1741   }
1742   else {
1743     /* If disable is better unlock all layers by default or it looks there is
1744      * a problem in the UI because the user expects all layers will be unlocked
1745      */
1746     if (unlock) {
1747       LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1748         gpl->flag &= ~GP_LAYER_LOCKED;
1749       }
1750     }
1751   }
1752 }
1753
1754 /**
1755  * Delete grease pencil layer.
1756  * \param gpd: Grease pencil data-block
1757  * \param gpl: Grease pencil layer
1758  */
1759 void BKE_gpencil_layer_delete(bGPdata *gpd, bGPDlayer *gpl)
1760 {
1761   /* error checking */
1762   if (ELEM(NULL, gpd, gpl)) {
1763     return;
1764   }
1765
1766   /* free layer */
1767   BKE_gpencil_free_frames(gpl);
1768
1769   /* Free Masks. */
1770   BKE_gpencil_free_layer_masks(gpl);
1771
1772   /* Remove any reference to that layer in masking lists. */
1773   BKE_gpencil_layer_mask_remove_ref(gpd, gpl->info);
1774
1775   /* free icon providing preview of icon color */
1776   BKE_icon_delete(gpl->runtime.icon_id);
1777
1778   BLI_freelinkN(&gpd->layers, gpl);
1779 }
1780
1781 /**
1782  * Get grease pencil material from brush.
1783  * \param brush: Brush
1784  * \return Pointer to material
1785  */
1786 Material *BKE_gpencil_brush_material_get(Brush *brush)
1787 {
1788   Material *ma = NULL;
1789
1790   if ((brush != NULL) && (brush->gpencil_settings != NULL) &&
1791       (brush->gpencil_settings->material != NULL)) {
1792     ma = brush->gpencil_settings->material;
1793   }
1794
1795   return ma;
1796 }
1797
1798 /**
1799  * Set grease pencil brush material.
1800  * \param brush: Brush
1801  * \param ma: Material
1802  */
1803 void BKE_gpencil_brush_material_set(Brush *brush, Material *ma)
1804 {
1805   BLI_assert(brush);
1806   BLI_assert(brush->gpencil_settings);
1807   if (brush->gpencil_settings->material != ma) {
1808     if (brush->gpencil_settings->material) {
1809       id_us_min(&brush->gpencil_settings->material->id);
1810     }
1811     if (ma) {
1812       id_us_plus(&ma->id);
1813     }
1814     brush->gpencil_settings->material = ma;
1815   }
1816 }
1817
1818 /**
1819  * Adds the pinned material to the object if necessary.
1820  * \param bmain: Main pointer
1821  * \param ob: Grease pencil object
1822  * \param brush: Brush
1823  * \return Pointer to material
1824  */
1825 Material *BKE_gpencil_object_material_ensure_from_brush(Main *bmain, Object *ob, Brush *brush)
1826 {
1827   if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
1828     Material *ma = BKE_gpencil_brush_material_get(brush);
1829
1830     /* check if the material is already on object material slots and add it if missing */
1831     if (ma && BKE_gpencil_object_material_index_get(ob, ma) < 0) {
1832       BKE_object_material_slot_add(bmain, ob);
1833       BKE_object_material_assign(bmain, ob, ma, ob->totcol, BKE_MAT_ASSIGN_USERPREF);
1834     }
1835
1836     return ma;
1837   }
1838
1839   /* using active material instead */
1840   return BKE_object_material_get(ob, ob->actcol);
1841 }
1842
1843 /**
1844  * Assigns the material to object (if not already present) and returns its index (mat_nr).
1845  * \param bmain: Main pointer
1846  * \param ob: Grease pencil object
1847  * \param material: Material
1848  * \return Index of the material
1849  */
1850 int BKE_gpencil_object_material_ensure(Main *bmain, Object *ob, Material *material)
1851 {
1852   if (!material) {
1853     return -1;
1854   }
1855   int index = BKE_gpencil_object_material_index_get(ob, material);
1856   if (index < 0) {
1857     BKE_object_material_slot_add(bmain, ob);
1858     BKE_object_material_assign(bmain, ob, material, ob->totcol, BKE_MAT_ASSIGN_USERPREF);
1859     return ob->totcol - 1;
1860   }
1861   return index;
1862 }
1863
1864 /**
1865  * Creates a new grease-pencil material and assigns it to object.
1866  * \param bmain: Main pointer
1867  * \param ob: Grease pencil object
1868  * \param name: Material name
1869  * \param r_index: value is set to zero based index of the new material if \a r_index is not NULL.
1870  * \return Material pointer.
1871  */
1872 Material *BKE_gpencil_object_material_new(Main *bmain, Object *ob, const char *name, int *r_index)
1873 {
1874   Material *ma = BKE_gpencil_material_add(bmain, name);
1875   id_us_min(&ma->id); /* no users yet */
1876
1877   BKE_object_material_slot_add(bmain, ob);
1878   BKE_object_material_assign(bmain, ob, ma, ob->totcol, BKE_MAT_ASSIGN_USERPREF);
1879
1880   if (r_index) {
1881     *r_index = ob->actcol - 1;
1882   }
1883   return ma;
1884 }
1885
1886 /**
1887  * Returns the material for a brush with respect to its pinned state.
1888  * \param ob: Grease pencil object
1889  * \param brush: Brush
1890  * \return Material pointer
1891  */
1892 Material *BKE_gpencil_object_material_from_brush_get(Object *ob, Brush *brush)
1893 {
1894   if ((brush) && (brush->gpencil_settings) &&
1895       (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED)) {
1896     Material *ma = BKE_gpencil_brush_material_get(brush);
1897     return ma;
1898   }
1899
1900   return BKE_object_material_get(ob, ob->actcol);
1901 }
1902
1903 /**
1904  * Returns the material index for a brush with respect to its pinned state.
1905  * \param ob: Grease pencil object
1906  * \param brush: Brush
1907  * \return Material index.
1908  */
1909 int BKE_gpencil_object_material_get_index_from_brush(Object *ob, Brush *brush)
1910 {
1911   if ((brush) && (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED)) {
1912     return BKE_gpencil_object_material_index_get(ob, brush->gpencil_settings->material);
1913   }
1914
1915   return ob->actcol - 1;
1916 }
1917
1918 /**
1919  * Guaranteed to return a material assigned to object. Returns never NULL.
1920  * \param bmain: Main pointer
1921  * \param ob: Grease pencil object
1922  * \return Material pointer.
1923  */
1924 Material *BKE_gpencil_object_material_ensure_from_active_input_toolsettings(Main *bmain,
1925                                                                             Object *ob,
1926                                                                             ToolSettings *ts)
1927 {
1928   if (ts && ts->gp_paint && ts->gp_paint->paint.brush) {
1929     return BKE_gpencil_object_material_ensure_from_active_input_brush(
1930         bmain, ob, ts->gp_paint->paint.brush);
1931   }
1932
1933   return BKE_gpencil_object_material_ensure_from_active_input_brush(bmain, ob, NULL);
1934 }
1935
1936 /**
1937  * Guaranteed to return a material assigned to object. Returns never NULL.
1938  * \param bmain: Main pointer
1939  * \param ob: Grease pencil object.
1940  * \param brush: Brush
1941  * \return Material pointer
1942  */
1943 Material *BKE_gpencil_object_material_ensure_from_active_input_brush(Main *bmain,
1944                                                                      Object *ob,
1945                                                                      Brush *brush)
1946 {
1947   if (brush) {
1948     Material *ma = BKE_gpencil_object_material_ensure_from_brush(bmain, ob, brush);
1949     if (ma) {
1950       return ma;
1951     }
1952     if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
1953       /* it is easier to just unpin a NULL material, instead of setting a new one */
1954       brush->gpencil_settings->flag &= ~GP_BRUSH_MATERIAL_PINNED;
1955     }
1956   }
1957   return BKE_gpencil_object_material_ensure_from_active_input_material(ob);
1958 }
1959
1960 /**
1961  * Guaranteed to return a material assigned to object. Returns never NULL.
1962  * Only use this for materials unrelated to user input.
1963  * \param ob: Grease pencil object
1964  * \return Material pointer
1965  */
1966 Material *BKE_gpencil_object_material_ensure_from_active_input_material(Object *ob)
1967 {
1968   Material *ma = BKE_object_material_get(ob, ob->actcol);
1969   if (ma) {
1970     return ma;
1971   }
1972
1973   return BKE_material_default_gpencil();
1974 }
1975
1976 /**
1977  * Get active color, and add all default settings if we don't find anything.
1978  * \param ob: Grease pencil object
1979  * \return Material pointer
1980  */
1981 Material *BKE_gpencil_object_material_ensure_active(Object *ob)
1982 {
1983   Material *ma = NULL;
1984
1985   /* sanity checks */
1986   if (ob == NULL) {
1987     return NULL;
1988   }
1989
1990   ma = BKE_gpencil_object_material_ensure_from_active_input_material(ob);
1991   if (ma->gp_style == NULL) {
1992     BKE_gpencil_material_attr_init(ma);
1993   }
1994
1995   return ma;
1996 }
1997
1998 /* ************************************************** */
1999 /**
2000  * Check if stroke has any point selected
2001  * \param gps: Grease pencil stroke
2002  * \return True if selected
2003  */
2004 bool BKE_gpencil_stroke_select_check(const bGPDstroke *gps)
2005 {
2006   const bGPDspoint *pt;
2007   int i;
2008   for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
2009     if (pt->flag & GP_SPOINT_SELECT) {
2010       return true;
2011     }
2012   }
2013   return false;
2014 }
2015
2016 /* ************************************************** */
2017 /* GP Object - Vertex Groups */
2018
2019 /**
2020  * Remove a vertex group.
2021  * \param ob: Grease pencil object
2022  * \param defgroup: deform group
2023  */
2024 void BKE_gpencil_vgroup_remove(Object *ob, bDeformGroup *defgroup)
2025 {
2026   bGPdata *gpd = ob->data;
2027   MDeformVert *dvert = NULL;
2028   const int def_nr = BLI_findindex(&ob->defbase, defgroup);
2029   const int totgrp = BLI_listbase_count(&ob->defbase);
2030
2031   /* Remove points data */
2032   if (gpd) {
2033     LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2034       LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2035         LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2036           if (gps->dvert != NULL) {
2037             for (int i = 0; i < gps->totpoints; i++) {
2038               dvert = &gps->dvert[i];
2039               MDeformWeight *dw = BKE_defvert_find_index(dvert, def_nr);
2040               if (dw != NULL) {
2041                 BKE_defvert_remove_group(dvert, dw);
2042               }
2043               /* Reorganize weights for other groups after deleted one. */
2044               for (int g = 0; g < totgrp; g++) {
2045                 dw = BKE_defvert_find_index(dvert, g);
2046                 if ((dw != NULL) && (dw->def_nr > def_nr)) {
2047                   dw->def_nr--;
2048                 }
2049               }
2050             }
2051           }
2052         }
2053       }
2054     }
2055   }
2056
2057   /* Remove the group */
2058   BLI_freelinkN(&ob->defbase, defgroup);
2059   DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
2060 }
2061
2062 /**
2063  * Ensure stroke has vertex group.
2064  * \param gps: Grease pencil stroke
2065  */
2066 void BKE_gpencil_dvert_ensure(bGPDstroke *gps)
2067 {
2068   if (gps->dvert == NULL) {
2069     gps->dvert = MEM_callocN(sizeof(MDeformVert) * gps->totpoints, "gp_stroke_weights");
2070   }
2071 }
2072
2073 /* ************************************************** */
2074
2075 /**
2076  * Get range of selected frames in layer.
2077  * Always the active frame is considered as selected, so if no more selected the range
2078  * will be equal to the current active frame.
2079  * \param gpl: Layer.
2080  * \param r_initframe: Number of first selected frame.
2081  * \param r_endframe: Number of last selected frame.
2082  */
2083 void BKE_gpencil_frame_range_selected(bGPDlayer *gpl, int *r_initframe, int *r_endframe)
2084 {
2085   *r_initframe = gpl->actframe->framenum;
2086   *r_endframe = gpl->actframe->framenum;
2087
2088   LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2089     if (gpf->flag & GP_FRAME_SELECT) {
2090       if (gpf->framenum < *r_initframe) {
2091         *r_initframe = gpf->framenum;
2092       }
2093       if (gpf->framenum > *r_endframe) {
2094         *r_endframe = gpf->framenum;
2095       }
2096     }
2097   }
2098 }
2099
2100 /**
2101  * Get Falloff factor base on frame range
2102  * \param gpf: Frame.
2103  * \param actnum: Number of active frame in layer.
2104  * \param f_init: Number of first selected frame.
2105  * \param f_end: Number of last selected frame.
2106  * \param cur_falloff: Curve with falloff factors.
2107  */
2108 float BKE_gpencil_multiframe_falloff_calc(
2109     bGPDframe *gpf, int actnum, int f_init, int f_end, CurveMapping *cur_falloff)
2110 {
2111   float fnum = 0.5f; /* default mid curve */
2112   float value;
2113
2114   /* check curve is available */
2115   if (cur_falloff == NULL) {
2116     return 1.0f;
2117   }
2118
2119   /* frames to the right of the active frame */
2120   if (gpf->framenum < actnum) {
2121     fnum = (float)(gpf->framenum - f_init) / (actnum - f_init);
2122     fnum *= 0.5f;
2123     value = BKE_curvemapping_evaluateF(cur_falloff, 0, fnum);
2124   }
2125   /* frames to the left of the active frame */
2126   else if (gpf->framenum > actnum) {
2127     fnum = (float)(gpf->framenum - actnum) / (f_end - actnum);
2128     fnum *= 0.5f;
2129     value = BKE_curvemapping_evaluateF(cur_falloff, 0, fnum + 0.5f);
2130   }
2131   else {
2132     /* Center of the curve. */
2133     value = BKE_curvemapping_evaluateF(cur_falloff, 0, 0.5f);
2134   }
2135
2136   return value;
2137 }
2138
2139 /**
2140  * Reassign strokes using a material.
2141  * \param gpd: Grease pencil data-block
2142  * \param totcol: Total materials
2143  * \param index: Index of the material
2144  */
2145 void BKE_gpencil_material_index_reassign(bGPdata *gpd, int totcol, int index)
2146 {
2147   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2148     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2149       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2150         /* reassign strokes */
2151         if ((gps->mat_nr > index) || (gps->mat_nr > totcol - 1)) {
2152           gps->mat_nr--;
2153           CLAMP_MIN(gps->mat_nr, 0);
2154         }
2155       }
2156     }
2157   }
2158 }
2159
2160 /**
2161  * Remove strokes using a material.
2162  * \param gpd: Grease pencil data-block
2163  * \param index: Index of the material
2164  * \return True if removed
2165  */
2166 bool BKE_gpencil_material_index_used(bGPdata *gpd, int index)
2167 {
2168   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2169     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2170       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2171         if (gps->mat_nr == index) {
2172           return true;
2173         }
2174       }
2175     }
2176   }
2177
2178   return false;
2179 }
2180
2181 /**
2182  * Remap material
2183  * \param gpd: Grease pencil data-block
2184  * \param remap: Remap index
2185  * \param remap_len: Remap length
2186  */
2187 void BKE_gpencil_material_remap(struct bGPdata *gpd,
2188                                 const unsigned int *remap,
2189                                 unsigned int remap_len)
2190 {
2191   const short remap_len_short = (short)remap_len;
2192
2193 #define MAT_NR_REMAP(n) \
2194   if (n < remap_len_short) { \
2195     BLI_assert(n >= 0 && remap[n] < remap_len_short); \
2196     n = remap[n]; \
2197   } \
2198   ((void)0)
2199
2200   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2201     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2202       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2203         /* reassign strokes */
2204         MAT_NR_REMAP(gps->mat_nr);
2205       }
2206     }
2207   }
2208
2209 #undef MAT_NR_REMAP
2210 }
2211
2212 /**
2213  * Load a table with material conversion index for merged materials.
2214  * \param ob: Grease pencil object.
2215  * \param hue_threshold: Threshold for Hue.
2216  * \param sat_threshold: Threshold for Saturation.
2217  * \param val_threshold: Threshold for Value.
2218  * \param r_mat_table: return material table.
2219  * \return True if done.
2220  */
2221 bool BKE_gpencil_merge_materials_table_get(Object *ob,
2222                                            const float hue_threshold,
2223                                            const float sat_threshold,
2224                                            const float val_threshold,
2225                                            GHash *r_mat_table)
2226 {
2227   bool changed = false;
2228
2229   Material *ma_primary = NULL;
2230   Material *ma_secondary = NULL;
2231   MaterialGPencilStyle *gp_style_primary = NULL;
2232   MaterialGPencilStyle *gp_style_secondary = NULL;
2233   GHash *mat_used = BLI_ghash_int_new(__func__);
2234
2235   short *totcol = BKE_object_material_len_p(ob);
2236   if (totcol == 0) {
2237     return changed;
2238   }
2239
2240   for (int idx_primary = 0; idx_primary < *totcol; idx_primary++) {
2241     /* Read primary material to compare. */
2242     ma_primary = BKE_gpencil_material(ob, idx_primary + 1);
2243     if (ma_primary == NULL) {
2244       continue;
2245     }
2246     for (int idx_secondary = 0; idx_secondary < *totcol; idx_secondary++) {
2247       if ((idx_secondary == idx_primary) ||
2248           BLI_ghash_haskey(r_mat_table, POINTER_FROM_INT(idx_secondary))) {
2249         continue;
2250       }
2251       if (BLI_ghash_haskey(mat_used, POINTER_FROM_INT(idx_secondary))) {
2252         continue;
2253       }
2254
2255       /* Read secondary material to compare with primary material. */
2256       ma_secondary = BKE_gpencil_material(ob, idx_secondary + 1);
2257       if ((ma_secondary == NULL) ||
2258           (BLI_ghash_haskey(r_mat_table, POINTER_FROM_INT(idx_secondary)))) {
2259         continue;
2260       }
2261       gp_style_primary = ma_primary->gp_style;
2262       gp_style_secondary = ma_secondary->gp_style;
2263
2264       if ((gp_style_primary == NULL) || (gp_style_secondary == NULL) ||
2265           (gp_style_secondary->flag & GP_MATERIAL_LOCKED)) {
2266         continue;
2267       }
2268
2269       /* Check materials have the same mode. */
2270       if (gp_style_primary->mode != gp_style_secondary->mode) {
2271         continue;
2272       }
2273
2274       /* Check materials have same stroke and fill attributes. */
2275       if ((gp_style_primary->flag & GP_MATERIAL_STROKE_SHOW) !=
2276           (gp_style_secondary->flag & GP_MATERIAL_STROKE_SHOW)) {
2277         continue;
2278       }
2279
2280       if ((gp_style_primary->flag & GP_MATERIAL_FILL_SHOW) !=
2281           (gp_style_secondary->flag & GP_MATERIAL_FILL_SHOW)) {
2282         continue;
2283       }
2284
2285       /* Check materials have the same type. */
2286       if ((gp_style_primary->stroke_style != gp_style_secondary->stroke_style) ||
2287           (gp_style_primary->fill_style != gp_style_secondary->fill_style)) {
2288         continue;
2289       }
2290
2291       float s_hsv_a[3], s_hsv_b[3], f_hsv_a[3], f_hsv_b[3], col[3];
2292       zero_v3(s_hsv_a);
2293       zero_v3(s_hsv_b);
2294       zero_v3(f_hsv_a);
2295       zero_v3(f_hsv_b);
2296
2297       copy_v3_v3(col, gp_style_primary->stroke_rgba);
2298       rgb_to_hsv_compat_v(col, s_hsv_a);
2299       copy_v3_v3(col, gp_style_secondary->stroke_rgba);
2300       rgb_to_hsv_compat_v(col, s_hsv_b);
2301
2302       copy_v3_v3(col, gp_style_primary->fill_rgba);
2303       rgb_to_hsv_compat_v(col, f_hsv_a);
2304       copy_v3_v3(col, gp_style_secondary->fill_rgba);
2305       rgb_to_hsv_compat_v(col, f_hsv_b);
2306
2307       /* Check stroke and fill color. */
2308       if ((!compare_ff(s_hsv_a[0], s_hsv_b[0], hue_threshold)) ||
2309           (!compare_ff(s_hsv_a[1], s_hsv_b[1], sat_threshold)) ||
2310           (!compare_ff(s_hsv_a[2], s_hsv_b[2], val_threshold)) ||
2311           (!compare_ff(f_hsv_a[0], f_hsv_b[0], hue_threshold)) ||
2312           (!compare_ff(f_hsv_a[1], f_hsv_b[1], sat_threshold)) ||
2313           (!compare_ff(f_hsv_a[2], f_hsv_b[2], val_threshold)) ||
2314           (!compare_ff(gp_style_primary->stroke_rgba[3],
2315                        gp_style_secondary->stroke_rgba[3],
2316                        val_threshold)) ||
2317           (!compare_ff(
2318               gp_style_primary->fill_rgba[3], gp_style_secondary->fill_rgba[3], val_threshold))) {
2319         continue;
2320       }
2321
2322       /* Save conversion indexes. */
2323       if (!BLI_ghash_haskey(r_mat_table, POINTER_FROM_INT(idx_secondary))) {
2324         BLI_ghash_insert(
2325             r_mat_table, POINTER_FROM_INT(idx_secondary), POINTER_FROM_INT(idx_primary));
2326         changed = true;
2327
2328         if (!BLI_ghash_haskey(mat_used, POINTER_FROM_INT(idx_primary))) {
2329           BLI_ghash_insert(mat_used, POINTER_FROM_INT(idx_primary), POINTER_FROM_INT(idx_primary));
2330         }
2331       }
2332     }
2333   }
2334   /* Free hash memory. */
2335   BLI_ghash_free(mat_used, NULL, NULL);
2336
2337   return changed;
2338 }
2339
2340 /**
2341  * Merge similar materials
2342  * \param ob: Grease pencil object
2343  * \param hue_threshold: Threshold for Hue
2344  * \param sat_threshold: Threshold for Saturation
2345  * \param val_threshold: Threshold for Value
2346  * \param r_removed: Number of materials removed
2347  * \return True if done
2348  */
2349 bool BKE_gpencil_merge_materials(Object *ob,
2350                                  const float hue_threshold,
2351                                  const float sat_threshold,
2352                                  const float val_threshold,
2353                                  int *r_removed)
2354 {
2355   bGPdata *gpd = ob->data;
2356
2357   short *totcol = BKE_object_material_len_p(ob);
2358   if (totcol == 0) {
2359     *r_removed = 0;
2360     return 0;
2361   }
2362
2363   /* Review materials. */
2364   GHash *mat_table = BLI_ghash_int_new(__func__);
2365
2366   bool changed = BKE_gpencil_merge_materials_table_get(
2367       ob, hue_threshold, sat_threshold, val_threshold, mat_table);
2368
2369   *r_removed = BLI_ghash_len(mat_table);
2370
2371   /* Update stroke material index. */
2372   if (changed) {
2373     LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2374       if (gpl->flag & GP_LAYER_HIDE) {
2375         continue;
2376       }
2377
2378       LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2379         LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2380           /* Check if the color is editable. */
2381           MaterialGPencilStyle *gp_style = BKE_gpencil_material_settings(ob, gps->mat_nr + 1);
2382           if (gp_style != NULL) {
2383             if (gp_style->flag & GP_MATERIAL_HIDE) {
2384               continue;
2385             }
2386             if (((gpl->flag & GP_LAYER_UNLOCK_COLOR) == 0) &&
2387                 (gp_style->flag & GP_MATERIAL_LOCKED)) {
2388               continue;
2389             }
2390           }
2391
2392           if (BLI_ghash_haskey(mat_table, POINTER_FROM_INT(gps->mat_nr))) {
2393             int *idx = BLI_ghash_lookup(mat_table, POINTER_FROM_INT(gps->mat_nr));
2394             gps->mat_nr = POINTER_AS_INT(idx);
2395           }
2396         }
2397       }
2398     }
2399   }
2400
2401   /* Free hash memory. */
2402   BLI_ghash_free(mat_table, NULL, NULL);
2403
2404   return changed;
2405 }
2406
2407 /**
2408  * Calc grease pencil statistics functions.
2409  * \param gpd: Grease pencil data-block
2410  */
2411 void BKE_gpencil_stats_update(bGPdata *gpd)
2412 {
2413   gpd->totlayer = 0;
2414   gpd->totframe = 0;
2415   gpd->totstroke = 0;
2416   gpd->totpoint = 0;
2417
2418   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2419     gpd->totlayer++;
2420     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2421       gpd->totframe++;
2422       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2423         gpd->totstroke++;
2424         gpd->totpoint += gps->totpoints;
2425       }
2426     }
2427   }
2428 }
2429
2430 /**
2431  * Get material index (0-based like mat_nr not actcol).
2432  * \param ob: Grease pencil object
2433  * \param ma: Material
2434  * \return Index of the material
2435  */
2436 int BKE_gpencil_object_material_index_get(Object *ob, Material *ma)
2437 {
2438   short *totcol = BKE_object_material_len_p(ob);
2439   Material *read_ma = NULL;
2440   for (short i = 0; i < *totcol; i++) {
2441     read_ma = BKE_object_material_get(ob, i + 1);
2442     if (ma == read_ma) {
2443       return i;
2444     }
2445   }
2446
2447   return -1;
2448 }
2449
2450 int BKE_gpencil_object_material_index_get_by_name(Object *ob, const char *name)
2451 {
2452   short *totcol = BKE_object_material_len_p(ob);
2453   Material *read_ma = NULL;
2454   for (short i = 0; i < *totcol; i++) {
2455     read_ma = BKE_object_material_get(ob, i + 1);
2456     /* Material names are like "MAMaterial.001" */
2457     if (STREQ(name, &read_ma->id.name[2])) {
2458       return i;
2459     }
2460   }
2461
2462   return -1;
2463 }
2464
2465 Material *BKE_gpencil_object_material_ensure_by_name(Main *bmain,
2466                                                      Object *ob,
2467                                                      const char *name,
2468                                                      int *r_index)
2469 {
2470   int index = BKE_gpencil_object_material_index_get_by_name(ob, name);
2471   if (index != -1) {
2472     *r_index = index;
2473     return BKE_object_material_get(ob, index + 1);
2474   }
2475   return BKE_gpencil_object_material_new(bmain, ob, name, r_index);
2476 }
2477
2478 /**
2479  * Create a default palette.
2480  * \param bmain: Main pointer
2481  * \param scene: Scene
2482  */
2483 void BKE_gpencil_palette_ensure(Main *bmain, Scene *scene)
2484 {
2485   const char *hexcol[] = {
2486       "FFFFFF", "F2F2F2", "E6E6E6", "D9D9D9", "CCCCCC", "BFBFBF", "B2B2B2", "A6A6A6", "999999",
2487       "8C8C8C", "808080", "737373", "666666", "595959", "4C4C4C", "404040", "333333", "262626",
2488       "1A1A1A", "000000", "F2FC24", "FFEA00", "FEA711", "FE8B68", "FB3B02", "FE3521", "D00000",
2489       "A81F3D", "780422", "2B0000", "F1E2C5", "FEE4B3", "FEDABB", "FEC28E", "D88F57", "BD6340",
2490       "A2402B", "63352D", "6B2833", "34120C", "E7CB8F", "D1B38B", "C1B17F", "D7980B", "FFB100",
2491       "FE8B00", "FF6A00", "B74100", "5F3E1D", "3B2300", "FECADA", "FE65CB", "FE1392", "DD3062",
2492       "C04A6D", "891688", "4D2689", "441521", "2C1139", "241422", "FFFF7D", "FFFF00", "FF7F00",
2493       "FF7D7D", "FF7DFF", "FF00FE", "FF007F", "FF0000", "7F0000", "0A0A00", "F6FDFF", "E9F7FF",
2494       "CFE6FE", "AAC7FE", "77B3FE", "1E74FD", "0046AA", "2F4476", "003052", "0E0E25", "EEF5F0",
2495       "D6E5DE", "ACD8B9", "6CADC6", "42A9AF", "007F7F", "49675C", "2E4E4E", "1D3239", "0F1C21",
2496       "D8FFF4", "B8F4F5", "AECCB5", "76C578", "358757", "409B68", "468768", "1F512B", "2A3C37",
2497       "122E1D", "EFFFC9", "E6F385", "BCF51C", "D4DC18", "82D322", "5C7F00", "59932B", "297F00",
2498       "004320", "1C3322", "00FF7F", "00FF00", "7DFF7D", "7DFFFF", "00FFFF", "7D7DFF", "7F00FF",
2499       "0000FF", "3F007F", "00007F"};
2500
2501   ToolSettings *ts = scene->toolsettings;
2502   if (ts->gp_paint->paint.palette != NULL) {
2503     return;
2504   }
2505
2506   /* Try to find the default palette. */
2507   const char *palette_id = "Palette";
2508   struct Palette *palette = BLI_findstring(&bmain->palettes, palette_id, offsetof(ID, name) + 2);
2509
2510   if (palette == NULL) {
2511     /* Fall back to the first palette. */
2512     palette = bmain->palettes.first;
2513   }
2514
2515   if (palette == NULL) {
2516     /* Fall back to creating a palette. */
2517     palette = BKE_palette_add(bmain, palette_id);
2518     id_us_min(&palette->id);
2519
2520     /* Create Colors. */
2521     for (int i = 0; i < ARRAY_SIZE(hexcol); i++) {
2522       PaletteColor *palcol = BKE_palette_color_add(palette);
2523       hex_to_rgb(hexcol[i], palcol->rgb, palcol->rgb + 1, palcol->rgb + 2);
2524     }
2525   }
2526
2527   BLI_assert(palette != NULL);
2528   BKE_paint_palette_set(&ts->gp_paint->paint, palette);
2529   BKE_paint_palette_set(&ts->gp_vertexpaint->paint, palette);
2530 }
2531
2532 /**
2533  * Create grease pencil strokes from image
2534  * \param sima: Image
2535  * \param gpd: Grease pencil data-block
2536  * \param gpf: Grease pencil frame
2537  * \param size: Size
2538  * \param mask: Mask
2539  * \return  True if done
2540  */
2541 bool BKE_gpencil_from_image(
2542     SpaceImage *sima, bGPdata *gpd, bGPDframe *gpf, const float size, const bool mask)
2543 {
2544   Image *image = sima->image;
2545   bool done = false;
2546
2547   if (image == NULL) {
2548     return false;
2549   }
2550
2551   ImageUser iuser = sima->iuser;
2552   void *lock;
2553   ImBuf *ibuf;
2554
2555   ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
2556
2557   if (ibuf && ibuf->rect) {
2558     int img_x = ibuf->x;
2559     int img_y = ibuf->y;
2560
2561     float color[4];
2562     bGPDspoint *pt;
2563     for (int row = 0; row < img_y; row++) {
2564       /* Create new stroke */
2565       bGPDstroke *gps = BKE_gpencil_stroke_add(gpf, 0, img_x, size * 1000, false);
2566       done = true;
2567       for (int col = 0; col < img_x; col++) {
2568         IMB_sampleImageAtLocation(ibuf, col, row, true, color);
2569         pt = &gps->points[col];
2570         pt->pressure = 1.0f;
2571         pt->x = col * size;
2572         pt->z = row * size;
2573         if (!mask) {
2574           copy_v3_v3(pt->vert_color, color);
2575           pt->vert_color[3] = 1.0f;
2576           pt->strength = color[3];
2577         }
2578         else {
2579           zero_v3(pt->vert_color);
2580           pt->vert_color[3] = 1.0f;
2581           pt->strength = 1.0f - color[3];
2582         }
2583
2584         /* Selet Alpha points. */
2585         if (pt->strength < 0.03f) {
2586           gps->flag |= GP_STROKE_SELECT;
2587           pt->flag |= GP_SPOINT_SELECT;
2588         }
2589       }
2590
2591       if (gps->flag & GP_STROKE_SELECT) {
2592         BKE_gpencil_stroke_select_index_set(gpd, gps);
2593       }
2594
2595       BKE_gpencil_stroke_geometry_update(gpd, gps);
2596     }
2597   }
2598
2599   /* Free memory. */
2600   BKE_image_release_ibuf(image, ibuf, lock);
2601
2602   return done;
2603 }
2604
2605 /**
2606  * Helper to check if a layers is used as mask
2607  * \param view_layer: Actual view layer.
2608  * \param gpd: Grease pencil data-block.
2609  * \param gpl_mask: Actual Layer.
2610  * \return True if the layer is used as mask.
2611  */
2612 static bool gpencil_is_layer_mask(ViewLayer *view_layer, bGPdata *gpd, bGPDlayer *gpl_mask)
2613 {
2614   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2615     if ((gpl->viewlayername[0] != '\0') && (!STREQ(view_layer->name, gpl->viewlayername))) {
2616       continue;
2617     }
2618
2619     LISTBASE_FOREACH (bGPDlayer_Mask *, mask, &gpl->mask_layers) {
2620       if (STREQ(gpl_mask->info, mask->name)) {
2621         return true;
2622       }
2623     }
2624   }
2625
2626   return false;
2627 }
2628
2629 /* -------------------------------------------------------------------- */
2630 /** \name Iterators
2631  *
2632  * Iterate over all visible stroke of all visible layers inside a gpObject.
2633  * Also take into account onion-skinning.
2634  * \{ */
2635
2636 void BKE_gpencil_visible_stroke_iter(ViewLayer *view_layer,
2637                                      Object *ob,
2638                                      gpIterCb layer_cb,
2639                                      gpIterCb stroke_cb,
2640                                      void *thunk,
2641                                      bool do_onion,
2642                                      int cfra)
2643 {
2644   bGPdata *gpd = (bGPdata *)ob->data;
2645   const bool is_multiedit = ((GPENCIL_MULTIEDIT_SESSIONS_ON(gpd)) && (!GPENCIL_PLAY_ON(gpd)));
2646   const bool is_onion = do_onion && ((gpd->flag & GP_DATA_STROKE_WEIGHTMODE) == 0);
2647   const bool is_drawing = (gpd->runtime.sbuffer_used > 0);
2648
2649   /* Onion skinning. */
2650   const bool onion_mode_abs = (gpd->onion_mode == GP_ONION_MODE_ABSOLUTE);
2651   const bool onion_mode_sel = (gpd->onion_mode == GP_ONION_MODE_SELECTED);
2652   const bool onion_loop = (gpd->onion_flag & GP_ONION_LOOP) != 0;
2653   const short onion_keytype = gpd->onion_keytype;
2654
2655   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2656     /* Reset by layer. */
2657     bool is_before_first = false;
2658
2659     bGPDframe *act_gpf = gpl->actframe;
2660     bGPDframe *sta_gpf = act_gpf;
2661     bGPDframe *end_gpf = act_gpf ? act_gpf->next : NULL;
2662     float prev_opacity = gpl->opacity;
2663
2664     if (gpl->flag & GP_LAYER_HIDE) {
2665       continue;
2666     }
2667
2668     /* If scale to 0 the layer must be invisible. */
2669     if (is_zero_v3(gpl->scale)) {
2670       continue;
2671     }
2672
2673     /* Hide the layer if it's defined a view layer filter. This is used to
2674      * generate renders, putting only selected GP layers for each View Layer.
2675      * This is used only in final render and never in Viewport. */
2676     if ((view_layer != NULL) && (gpl->viewlayername[0] != '\0') &&
2677         (!STREQ(view_layer->name, gpl->viewlayername))) {
2678       /* Do not skip masks when rendering the viewlayer so that it can still be used to clip
2679        * other layers. Instead set their opacity to zero. */
2680       if (gpencil_is_layer_mask(view_layer, gpd, gpl)) {
2681         gpl->opacity = 0.0f;
2682       }
2683       else {
2684         continue;
2685       }
2686     }
2687
2688     if (is_multiedit) {
2689       sta_gpf = end_gpf = NULL;
2690       /* Check the whole range and tag the editable frames. */
2691       LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2692         if (act_gpf != NULL && (gpf == act_gpf || (gpf->flag & GP_FRAME_SELECT))) {
2693           gpf->runtime.onion_id = 0;
2694           if (do_onion) {
2695             if (gpf->framenum < act_gpf->framenum) {
2696               gpf->runtime.onion_id = -1;
2697             }
2698             else {
2699               gpf->runtime.onion_id = 1;
2700             }
2701           }
2702
2703           if (sta_gpf == NULL) {
2704             sta_gpf = gpf;
2705           }
2706           end_gpf = gpf->next;
2707         }
2708         else {
2709           gpf->runtime.onion_id = INT_MAX;
2710         }
2711       }
2712     }
2713     else if (is_onion && (gpl->onion_flag & GP_LAYER_ONIONSKIN)) {
2714       /* Special cases when cframe is before first frame. */
2715       bGPDframe *gpf_first = gpl->frames.first;
2716       if ((gpf_first != NULL) && (act_gpf != NULL) && (gpf_first->framenum > act_gpf->framenum)) {
2717         is_before_first = true;
2718       }
2719       if ((gpf_first != NULL) && (act_gpf == NULL)) {
2720         act_gpf = gpf_first;
2721         is_before_first = true;
2722       }
2723
2724       if (act_gpf) {
2725         bGPDframe *last_gpf = gpl->frames.last;
2726
2727         int frame_len = 0;
2728         LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2729           gpf->runtime.frameid = frame_len++;
2730         }
2731
2732         LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2733           bool is_wrong_keytype = (onion_keytype > -1) && (gpf->key_type != onion_keytype);
2734           bool is_in_range;
2735           int delta = (onion_mode_abs) ? (gpf->framenum - cfra) :
2736                                          (gpf->runtime.frameid - act_gpf->runtime.frameid);
2737
2738           if (is_before_first) {
2739             delta++;
2740           }
2741
2742           if (onion_mode_sel) {
2743             is_in_range = (gpf->flag & GP_FRAME_SELECT) != 0;
2744           }
2745           else {
2746             is_in_range = (-delta <= gpd->gstep) && (delta <= gpd->gstep_next);
2747
2748             if (onion_loop && !is_in_range) {
2749               /* We wrap the value using the last frame and 0 as reference. */
2750               /* FIXME: This might not be good for animations not starting at 0. */
2751               int shift = (onion_mode_abs) ? last_gpf->framenum : last_gpf->runtime.frameid;
2752               delta += (delta < 0) ? (shift + 1) : -(shift + 1);
2753               /* Test again with wrapped value. */
2754               is_in_range = (-delta <= gpd->gstep) && (delta <= gpd->gstep_next);
2755             }
2756           }
2757           /* Mask frames that have wrong keytype of are not in range. */
2758           gpf->runtime.onion_id = (is_wrong_keytype || !is_in_range) ? INT_MAX : delta;
2759         }
2760         /* Active frame is always shown. */
2761         if (!is_before_first || is_drawing) {
2762           act_gpf->runtime.onion_id = 0;
2763         }
2764       }
2765
2766       sta_gpf = gpl->frames.first;
2767       end_gpf = NULL;
2768     }
2769     else {
2770       /* Bypass multiedit/onion skinning. */
2771       end_gpf = sta_gpf = NULL;
2772     }
2773
2774     if (sta_gpf == NULL && act_gpf == NULL) {
2775       if (layer_cb) {
2776         layer_cb(gpl, act_gpf, NULL, thunk);
2777       }
2778       gpl->opacity = prev_opacity;
2779       continue;
2780     }
2781
2782     /* Draw multiedit/onion skinning first */
2783     for (bGPDframe *gpf = sta_gpf; gpf && gpf != end_gpf; gpf = gpf->next) {
2784       if ((gpf->runtime.onion_id == INT_MAX || gpf == act_gpf) && (!is_before_first)) {
2785         continue;
2786       }
2787
2788       /* Only do once for frame before first. */
2789       if (is_before_first && gpf == act_gpf) {
2790         is_before_first = false;
2791       }
2792
2793       if (layer_cb) {
2794         layer_cb(gpl, gpf, NULL, thunk);
2795       }
2796
2797       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2798         if (gps->totpoints == 0) {
2799           continue;
2800         }
2801         stroke_cb(gpl, gpf, gps, thunk);
2802       }
2803     }
2804     /* Draw Active frame on top. */
2805     /* Use evaluated frame (with modifiers for active stroke)/ */
2806     act_gpf = gpl->actframe;
2807     if (act_gpf) {
2808       act_gpf->runtime.onion_id = 0;
2809       if (layer_cb) {
2810         layer_cb(gpl, act_gpf, NULL, thunk);
2811       }
2812
2813       /* If layer solo mode and Paint mode, only keyframes with data are displayed. */
2814       if (GPENCIL_PAINT_MODE(gpd) && (gpl->flag & GP_LAYER_SOLO_MODE) &&
2815           (act_gpf->framenum != cfra)) {
2816         gpl->opacity = prev_opacity;
2817         continue;
2818       }
2819
2820       LISTBASE_FOREACH (bGPDstroke *, gps, &act_gpf->strokes) {
2821         if (gps->totpoints == 0) {
2822           continue;
2823         }
2824         stroke_cb(gpl, act_gpf, gps, thunk);
2825       }
2826     }
2827
2828     /* Restore the opacity in case it was overwritten (used to hide masks in render). */
2829     gpl->opacity = prev_opacity;
2830   }
2831 }
2832
2833 /**
2834  * Update original pointers in evaluated frame.
2835  * \param gpf_orig: Original grease-pencil frame.
2836  * \param gpf_eval: Evaluated grease pencil frame.
2837  */
2838 void BKE_gpencil_frame_original_pointers_update(const struct bGPDframe *gpf_orig,
2839                                                 const struct bGPDframe *gpf_eval)
2840 {
2841   bGPDstroke *gps_eval = gpf_eval->strokes.first;
2842   LISTBASE_FOREACH (bGPDstroke *, gps_orig, &gpf_orig->strokes) {
2843
2844     /* Assign original stroke pointer. */
2845     if (gps_eval != NULL) {
2846       gps_eval->runtime.gps_orig = gps_orig;
2847
2848       /* Assign original point pointer. */
2849       for (int i = 0; i < gps_orig->totpoints; i++) {
2850         if (i > gps_eval->totpoints - 1) {
2851           break;
2852         }
2853         bGPDspoint *pt_orig = &gps_orig->points[i];
2854         bGPDspoint *pt_eval = &gps_eval->points[i];
2855         pt_orig->runtime.pt_orig = NULL;
2856         pt_orig->runtime.idx_orig = i;
2857         pt_eval->runtime.pt_orig = pt_orig;
2858         pt_eval->runtime.idx_orig = i;
2859       }
2860       /* Increase pointer. */
2861       gps_eval = gps_eval->next;
2862     }
2863   }
2864 }
2865
2866 /**
2867  * Update pointers of eval data to original data to keep references.
2868  * \param ob_orig: Original grease pencil object
2869  * \param ob_eval: Evaluated grease pencil object
2870  */
2871 void BKE_gpencil_update_orig_pointers(const Object *ob_orig, const Object *ob_eval)
2872 {
2873   bGPdata *gpd_eval = (bGPdata *)ob_eval->data;
2874   bGPdata *gpd_orig = (bGPdata *)ob_orig->data;
2875
2876   /* Assign pointers to the original stroke and points to the evaluated data. This must
2877    * be done before applying any modifier because at this moment the structure is equals,
2878    * so we can assume the layer index is the same in both data-blocks.
2879    * This data will be used by operators. */
2880
2881   bGPDlayer *gpl_eval = gpd_eval->layers.first;
2882   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd_orig->layers) {
2883     if (gpl_eval != NULL) {
2884       /* Update layer reference pointers. */
2885       gpl_eval->runtime.gpl_orig = (bGPDlayer *)gpl;
2886
2887       bGPDframe *gpf_eval = gpl_eval->frames.first;
2888       LISTBASE_FOREACH (bGPDframe *, gpf_orig, &gpl->frames) {
2889         if (gpf_eval != NULL) {
2890           /* Update frame reference pointers. */
2891           gpf_eval->runtime.gpf_orig = (bGPDframe *)gpf_orig;
2892           BKE_gpencil_frame_original_pointers_update(gpf_orig, gpf_eval);
2893           gpf_eval = gpf_eval->next;
2894         }
2895       }
2896       gpl_eval = gpl_eval->next;
2897     }
2898   }
2899 }
2900
2901 /**
2902  * Get parent matrix, including layer parenting.
2903  * \param depsgraph: Depsgraph
2904  * \param obact: Grease pencil object
2905  * \param gpl: Grease pencil layer
2906  * \param diff_mat: Result parent matrix
2907  */
2908 void BKE_gpencil_layer_transform_matrix_get(const Depsgraph *depsgraph,
2909                                             Object *obact,
2910                                             bGPDlayer *gpl,
2911                                             float diff_mat[4][4])
2912 {
2913   Object *ob_eval = depsgraph != NULL ? DEG_get_evaluated_object(depsgraph, obact) : obact;
2914   Object *obparent = gpl->parent;
2915   Object *obparent_eval = depsgraph != NULL ? DEG_get_evaluated_object(depsgraph, obparent) :
2916                                               obparent;
2917
2918   /* if not layer parented, try with object parented */
2919   if (obparent_eval == NULL) {
2920     if ((ob_eval != NULL) && (ob_eval->type == OB_GPENCIL)) {
2921       copy_m4_m4(diff_mat, ob_eval->obmat);
2922       mul_m4_m4m4(diff_mat, diff_mat, gpl->layer_mat);
2923       return;
2924     }
2925     /* not gpencil object */
2926     unit_m4(diff_mat);
2927     return;
2928   }
2929
2930   if (ELEM(gpl->partype, PAROBJECT, PARSKEL)) {
2931     mul_m4_m4m4(diff_mat, obparent_eval->obmat, gpl->inverse);
2932     add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
2933     mul_m4_m4m4(diff_mat, diff_mat, gpl->layer_mat);
2934     return;
2935   }
2936   if (gpl->partype == PARBONE) {
2937     bPoseChannel *pchan = BKE_pose_channel_find_name(obparent_eval->pose, gpl->parsubstr);
2938     if (pchan) {
2939       float tmp_mat[4][4];
2940       mul_m4_m4m4(tmp_mat, obparent_eval->obmat, pchan->pose_mat);
2941       mul_m4_m4m4(diff_mat, tmp_mat, gpl->inverse);
2942       add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
2943     }
2944     else {
2945       /* if bone not found use object (armature) */
2946       mul_m4_m4m4(diff_mat, obparent_eval->obmat, gpl->inverse);
2947       add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
2948     }
2949     mul_m4_m4m4(diff_mat, diff_mat, gpl->layer_mat);
2950     return;
2951   }
2952
2953   unit_m4(diff_mat); /* not defined type */
2954 }
2955
2956 /**
2957  * Update parent matrix and local transforms.
2958  * \param depsgraph: Depsgraph
2959  * \param ob: Grease pencil object
2960  */
2961 void BKE_gpencil_update_layer_transforms(const Depsgraph *depsgraph, Object *ob)
2962 {
2963   if (ob->type != OB_GPENCIL) {
2964     return;
2965   }
2966
2967   bGPdata *gpd = (bGPdata *)ob->data;
2968   float cur_mat[4][4];
2969
2970   bool changed = false;
2971   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2972     unit_m4(cur_mat);
2973     if (gpl->actframe != NULL) {
2974       if (gpl->parent != NULL) {
2975         Object *ob_parent = DEG_get_evaluated_object(depsgraph, gpl->parent);
2976         /* calculate new matrix */
2977         if (ELEM(gpl->partype, PAROBJECT, PARSKEL)) {
2978           copy_m4_m4(cur_mat, ob_parent->obmat);
2979         }
2980         else if (gpl->partype == PARBONE) {
2981           bPoseChannel *pchan = BKE_pose_channel_find_name(ob_parent->pose, gpl->parsubstr);
2982           if (pchan != NULL) {
2983             copy_m4_m4(cur_mat, ob->imat);
2984             mul_m4_m4m4(cur_mat, ob_parent->obmat, pchan->pose_mat);
2985           }
2986           else {
2987             unit_m4(cur_mat);
2988           }
2989         }
2990         changed = !equals_m4m4(gpl->inverse, cur_mat);
2991       }
2992
2993       /* Calc local layer transform. */
2994       bool transformed = ((!is_zero_v3(gpl->location)) || (!is_zero_v3(gpl->rotation)) ||
2995                           (!is_one_v3(gpl->scale)));
2996       if (transformed) {
2997         loc_eul_size_to_mat4(gpl->layer_mat, gpl->location, gpl->rotation, gpl->scale);
2998       }
2999
3000       /* only redo if any change */
3001       if (changed || transformed) {
3002         LISTBASE_FOREACH (bGPDstroke *, gps, &gpl->actframe->strokes) {
3003           bGPDspoint *pt;
3004           int i;
3005           for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
3006             if (changed) {
3007               mul_m4_v3(gpl->inverse, &pt->x);
3008               mul_m4_v3(cur_mat, &pt->x);
3009             }
3010
3011             if (transformed) {
3012               mul_m4_v3(gpl->layer_mat, &pt->x);
3013             }
3014           }
3015         }
3016       }
3017     }
3018   }
3019 }
3020
3021 /**
3022  * Find material by name prefix.
3023  * \param ob: Object pointer
3024  * \param name_prefix: Prefix name of the material
3025  * \return  Index
3026  */
3027 int BKE_gpencil_material_find_index_by_name_prefix(Object *ob, const char *name_prefix)
3028 {
3029   const int name_prefix_len = strlen(name_prefix);
3030   for (int i = 0; i < ob->totcol; i++) {
3031     Material *ma = BKE_object_material_get(ob, i + 1);
3032     if ((ma != NULL) && (ma->gp_style != NULL) &&
3033         (STREQLEN(ma->id.name + 2, name_prefix, name_prefix_len))) {
3034       return i;
3035     }
3036   }
3037
3038   return -1;
3039 }
3040
3041 /* Create a hash with the list of selected frame number. */
3042 void BKE_gpencil_frame_selected_hash(bGPdata *gpd, struct GHash *r_list)
3043 {
3044   const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
3045   bGPDlayer *gpl = BKE_gpencil_layer_active_get(gpd);
3046
3047   LISTBASE_FOREACH (bGPDlayer *, gpl_iter, &gpd->layers) {
3048     if ((gpl != NULL) && (!is_multiedit) && (gpl != gpl_iter)) {
3049       continue;
3050     }
3051
3052     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl_iter->frames) {
3053       if (((gpf == gpl->actframe) && (!is_multiedit)) ||
3054           ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
3055         if (!BLI_ghash_lookup(r_list, POINTER_FROM_INT(gpf->framenum))) {
3056           BLI_ghash_insert(r_list, POINTER_FROM_INT(gpf->framenum), gpf);
3057         }
3058       }
3059     }
3060   }
3061 }
3062
3063 /** \} */