Merge branch 'blender-v2.93-release'
[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  * \param add_to_header: Used to force the layer added at header
657  * \return Pointer to new layer
658  */
659 bGPDlayer *BKE_gpencil_layer_addnew(bGPdata *gpd,
660                                     const char *name,
661                                     const bool setactive,
662                                     const bool add_to_header)
663 {
664   bGPDlayer *gpl = NULL;
665   bGPDlayer *gpl_active = NULL;
666
667   /* check that list is ok */
668   if (gpd == NULL) {
669     return NULL;
670   }
671
672   /* allocate memory for frame and add to end of list */
673   gpl = MEM_callocN(sizeof(bGPDlayer), "bGPDlayer");
674
675   gpl_active = BKE_gpencil_layer_active_get(gpd);
676
677   /* Add to data-block. */
678   if (add_to_header) {
679     BLI_addhead(&gpd->layers, gpl);
680   }
681   else {
682     if (gpl_active == NULL) {
683       BLI_addtail(&gpd->layers, gpl);
684     }
685     else {
686       /* if active layer, add after that layer */
687       BLI_insertlinkafter(&gpd->layers, gpl_active, gpl);
688     }
689   }
690   /* annotation vs GP Object behavior is slightly different */
691   if (gpd->flag & GP_DATA_ANNOTATIONS) {
692     /* set default color of new strokes for this layer */
693     copy_v4_v4(gpl->color, U.gpencil_new_layer_col);
694     gpl->opacity = 1.0f;
695
696     /* set default thickness of new strokes for this layer */
697     gpl->thickness = 3;
698
699     /* Onion colors */
700     ARRAY_SET_ITEMS(gpl->gcolor_prev, 0.302f, 0.851f, 0.302f);
701     ARRAY_SET_ITEMS(gpl->gcolor_next, 0.250f, 0.1f, 1.0f);
702   }
703   else {
704     /* thickness parameter represents "thickness change", not absolute thickness */
705     gpl->thickness = 0;
706     gpl->opacity = 1.0f;
707     /* default channel color */
708     ARRAY_SET_ITEMS(gpl->color, 0.2f, 0.2f, 0.2f);
709     /* Default vertex mix. */
710     gpl->vertex_paint_opacity = 1.0f;
711     /* Enable onion skin. */
712     gpl->onion_flag |= GP_LAYER_ONIONSKIN;
713   }
714
715   /* auto-name */
716   BLI_strncpy(gpl->info, name, sizeof(gpl->info));
717   BLI_uniquename(&gpd->layers,
718                  gpl,
719                  (gpd->flag & GP_DATA_ANNOTATIONS) ? DATA_("Note") : DATA_("GP_Layer"),
720                  '.',
721                  offsetof(bGPDlayer, info),
722                  sizeof(gpl->info));
723
724   /* Enable always affected by scene lights. */
725   gpl->flag |= GP_LAYER_USE_LIGHTS;
726
727   /* Init transform. */
728   zero_v3(gpl->location);
729   zero_v3(gpl->rotation);
730   copy_v3_fl(gpl->scale, 1.0f);
731   loc_eul_size_to_mat4(gpl->layer_mat, gpl->location, gpl->rotation, gpl->scale);
732   invert_m4_m4(gpl->layer_invmat, gpl->layer_mat);
733
734   /* make this one the active one */
735   if (setactive) {
736     BKE_gpencil_layer_active_set(gpd, gpl);
737   }
738
739   /* return layer */
740   return gpl;
741 }
742
743 /**
744  * Add a new grease pencil data-block.
745  * \param bmain: Main pointer
746  * \param name: Name of the datablock
747  * \return Pointer to new data-block
748  */
749 bGPdata *BKE_gpencil_data_addnew(Main *bmain, const char name[])
750 {
751   bGPdata *gpd;
752
753   /* allocate memory for a new block */
754   gpd = BKE_libblock_alloc(bmain, ID_GD, name, 0);
755
756   /* initial settings */
757   gpd->flag = (GP_DATA_DISPINFO | GP_DATA_EXPAND);
758
759   /* general flags */
760   gpd->flag |= GP_DATA_VIEWALIGN;
761   /* always enable object onion skin switch */
762   gpd->flag |= GP_DATA_SHOW_ONIONSKINS;
763   /* GP object specific settings */
764   ARRAY_SET_ITEMS(gpd->line_color, 0.6f, 0.6f, 0.6f, 0.5f);
765
766   gpd->pixfactor = GP_DEFAULT_PIX_FACTOR;
767
768   gpd->curve_edit_resolution = GP_DEFAULT_CURVE_RESOLUTION;
769   gpd->curve_edit_threshold = GP_DEFAULT_CURVE_ERROR;
770   gpd->curve_edit_corner_angle = GP_DEFAULT_CURVE_EDIT_CORNER_ANGLE;
771
772   /* use adaptive curve resolution by default */
773   gpd->flag |= GP_DATA_CURVE_ADAPTIVE_RESOLUTION;
774
775   gpd->zdepth_offset = 0.150f;
776
777   /* grid settings */
778   ARRAY_SET_ITEMS(gpd->grid.color, 0.5f, 0.5f, 0.5f); /* Color */
779   ARRAY_SET_ITEMS(gpd->grid.scale, 1.0f, 1.0f);       /* Scale */
780   gpd->grid.lines = GP_DEFAULT_GRID_LINES;            /* Number of lines */
781
782   /* Onion-skinning settings (data-block level) */
783   gpd->onion_keytype = -1; /* All by default. */
784   gpd->onion_flag |= (GP_ONION_GHOST_PREVCOL | GP_ONION_GHOST_NEXTCOL);
785   gpd->onion_flag |= GP_ONION_FADE;
786   gpd->onion_mode = GP_ONION_MODE_RELATIVE;
787   gpd->onion_factor = 0.5f;
788   ARRAY_SET_ITEMS(gpd->gcolor_prev, 0.145098f, 0.419608f, 0.137255f); /* green */
789   ARRAY_SET_ITEMS(gpd->gcolor_next, 0.125490f, 0.082353f, 0.529412f); /* blue */
790   gpd->gstep = 1;
791   gpd->gstep_next = 1;
792
793   return gpd;
794 }
795
796 /* ************************************************** */
797 /* Primitive Creation */
798 /* Utilities for easier bulk-creation of geometry */
799
800 /**
801  * Populate stroke with point data from data buffers.
802  * \param gps: Grease pencil stroke
803  * \param array: Flat array of point data values. Each entry has #GP_PRIM_DATABUF_SIZE values.
804  * \param totpoints: Total of points
805  * \param mat: 4x4 transform matrix to transform points into the right coordinate space.
806  */
807 void BKE_gpencil_stroke_add_points(bGPDstroke *gps,
808                                    const float *array,
809                                    const int totpoints,
810                                    const float mat[4][4])
811 {
812   for (int i = 0; i < totpoints; i++) {
813     bGPDspoint *pt = &gps->points[i];
814     const int x = GP_PRIM_DATABUF_SIZE * i;
815
816     pt->x = array[x];
817     pt->y = array[x + 1];
818     pt->z = array[x + 2];
819     mul_m4_v3(mat, &pt->x);
820
821     pt->pressure = array[x + 3];
822     pt->strength = array[x + 4];
823   }
824 }
825
826 /**
827  * Create a new stroke, with pre-allocated data buffers.
828  * \param mat_idx: Index of the material
829  * \param totpoints: Total points
830  * \param thickness: Stroke thickness
831  * \return Pointer to new stroke
832  */
833 bGPDstroke *BKE_gpencil_stroke_new(int mat_idx, int totpoints, short thickness)
834 {
835   /* allocate memory for a new stroke */
836   bGPDstroke *gps = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
837
838   gps->thickness = thickness;
839   gps->fill_opacity_fac = 1.0f;
840   gps->hardeness = 1.0f;
841   copy_v2_fl(gps->aspect_ratio, 1.0f);
842
843   gps->uv_scale = 1.0f;
844
845   gps->inittime = 0;
846
847   gps->flag = GP_STROKE_3DSPACE;
848
849   gps->totpoints = totpoints;
850   if (gps->totpoints > 0) {
851     gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
852   }
853   else {
854     gps->points = NULL;
855   }
856
857   /* initialize triangle memory to dummy data */
858   gps->triangles = NULL;
859   gps->tot_triangles = 0;
860
861   gps->mat_nr = mat_idx;
862
863   gps->dvert = NULL;
864   gps->editcurve = NULL;
865
866   return gps;
867 }
868
869 /**
870  * Create a new stroke and add to frame.
871  * \param gpf: Grease pencil frame
872  * \param mat_idx: Material index
873  * \param totpoints: Total points
874  * \param thickness: Stroke thickness
875  * \param insert_at_head: Add to the head of the strokes list
876  * \return Pointer to new stroke
877  */
878 bGPDstroke *BKE_gpencil_stroke_add(
879     bGPDframe *gpf, int mat_idx, int totpoints, short thickness, const bool insert_at_head)
880 {
881   bGPDstroke *gps = BKE_gpencil_stroke_new(mat_idx, totpoints, thickness);
882
883   /* Add to frame. */
884   if ((gps != NULL) && (gpf != NULL)) {
885     if (!insert_at_head) {
886       BLI_addtail(&gpf->strokes, gps);
887     }
888     else {
889       BLI_addhead(&gpf->strokes, gps);
890     }
891   }
892
893   return gps;
894 }
895
896 /**
897  * Add a stroke and copy the temporary drawing color value
898  * from one of the existing stroke.
899  * \param gpf: Grease pencil frame
900  * \param existing: Stroke with the style to copy
901  * \param mat_idx: Material index
902  * \param totpoints: Total points
903  * \param thickness: Stroke thickness
904  * \return Pointer to new stroke
905  */
906 bGPDstroke *BKE_gpencil_stroke_add_existing_style(
907     bGPDframe *gpf, bGPDstroke *existing, int mat_idx, int totpoints, short thickness)
908 {
909   bGPDstroke *gps = BKE_gpencil_stroke_add(gpf, mat_idx, totpoints, thickness, false);
910   /* Copy run-time color data so that strokes added in the modifier has the style.
911    * There are depsgraph reference pointers inside,
912    * change the copy function if interfere with future drawing implementation. */
913   memcpy(&gps->runtime, &existing->runtime, sizeof(bGPDstroke_Runtime));
914   return gps;
915 }
916
917 bGPDcurve *BKE_gpencil_stroke_editcurve_new(const int tot_curve_points)
918 {
919   bGPDcurve *new_gp_curve = (bGPDcurve *)MEM_callocN(sizeof(bGPDcurve), __func__);
920   new_gp_curve->tot_curve_points = tot_curve_points;
921   new_gp_curve->curve_points = (bGPDcurve_point *)MEM_callocN(
922       sizeof(bGPDcurve_point) * tot_curve_points, __func__);
923
924   return new_gp_curve;
925 }
926
927 /* ************************************************** */
928 /* Data Duplication */
929
930 /**
931  * Make a copy of a given gpencil weights.
932  * \param gps_src: Source grease pencil stroke
933  * \param gps_dst: Destination grease pencil stroke
934  */
935 void BKE_gpencil_stroke_weights_duplicate(bGPDstroke *gps_src, bGPDstroke *gps_dst)
936 {
937   if (gps_src == NULL) {
938     return;
939   }
940   BLI_assert(gps_src->totpoints == gps_dst->totpoints);
941
942   BKE_defvert_array_copy(gps_dst->dvert, gps_src->dvert, gps_src->totpoints);
943 }
944
945 /* Make a copy of a given gpencil stroke editcurve */
946 bGPDcurve *BKE_gpencil_stroke_curve_duplicate(bGPDcurve *gpc_src)
947 {
948   bGPDcurve *gpc_dst = MEM_dupallocN(gpc_src);
949
950   if (gpc_src->curve_points != NULL) {
951     gpc_dst->curve_points = MEM_dupallocN(gpc_src->curve_points);
952   }
953
954   return gpc_dst;
955 }
956
957 /**
958  * Make a copy of a given grease-pencil stroke.
959  * \param gps_src: Source grease pencil strokes.
960  * \param dup_points: Duplicate points data.
961  * \param dup_curve: Duplicate curve data.
962  * \return Pointer to new stroke.
963  */
964 bGPDstroke *BKE_gpencil_stroke_duplicate(bGPDstroke *gps_src,
965                                          const bool dup_points,
966                                          const bool dup_curve)
967 {
968   bGPDstroke *gps_dst = NULL;
969
970   gps_dst = MEM_dupallocN(gps_src);
971   gps_dst->prev = gps_dst->next = NULL;
972   gps_dst->triangles = MEM_dupallocN(gps_src->triangles);
973
974   if (dup_points) {
975     gps_dst->points = MEM_dupallocN(gps_src->points);
976
977     if (gps_src->dvert != NULL) {
978       gps_dst->dvert = MEM_dupallocN(gps_src->dvert);
979       BKE_gpencil_stroke_weights_duplicate(gps_src, gps_dst);
980     }
981     else {
982       gps_dst->dvert = NULL;
983     }
984   }
985   else {
986     gps_dst->points = NULL;
987     gps_dst->dvert = NULL;
988   }
989
990   if (dup_curve && gps_src->editcurve != NULL) {
991     gps_dst->editcurve = BKE_gpencil_stroke_curve_duplicate(gps_src->editcurve);
992   }
993   else {
994     gps_dst->editcurve = NULL;
995   }
996
997   /* return new stroke */
998   return gps_dst;
999 }
1000
1001 /**
1002  * Make a copy of a given gpencil frame.
1003  * \param gpf_src: Source grease pencil frame
1004  * \return Pointer to new frame
1005  */
1006 bGPDframe *BKE_gpencil_frame_duplicate(const bGPDframe *gpf_src, const bool dup_strokes)
1007 {
1008   bGPDstroke *gps_dst = NULL;
1009   bGPDframe *gpf_dst;
1010
1011   /* error checking */
1012   if (gpf_src == NULL) {
1013     return NULL;
1014   }
1015
1016   /* make a copy of the source frame */
1017   gpf_dst = MEM_dupallocN(gpf_src);
1018   gpf_dst->prev = gpf_dst->next = NULL;
1019
1020   /* Copy strokes. */
1021   BLI_listbase_clear(&gpf_dst->strokes);
1022   if (dup_strokes) {
1023     LISTBASE_FOREACH (bGPDstroke *, gps_src, &gpf_src->strokes) {
1024       /* make copy of source stroke */
1025       gps_dst = BKE_gpencil_stroke_duplicate(gps_src, true, true);
1026       BLI_addtail(&gpf_dst->strokes, gps_dst);
1027     }
1028   }
1029
1030   /* return new frame */
1031   return gpf_dst;
1032 }
1033
1034 /**
1035  * Make a copy of strokes between gpencil frames.
1036  * \param gpf_src: Source grease pencil frame
1037  * \param gpf_dst: Destination grease pencil frame
1038  */
1039 void BKE_gpencil_frame_copy_strokes(bGPDframe *gpf_src, struct bGPDframe *gpf_dst)
1040 {
1041   bGPDstroke *gps_dst = NULL;
1042   /* error checking */
1043   if ((gpf_src == NULL) || (gpf_dst == NULL)) {
1044     return;
1045   }
1046
1047   /* copy strokes */
1048   BLI_listbase_clear(&gpf_dst->strokes);
1049   LISTBASE_FOREACH (bGPDstroke *, gps_src, &gpf_src->strokes) {
1050     /* make copy of source stroke */
1051     gps_dst = BKE_gpencil_stroke_duplicate(gps_src, true, true);
1052     BLI_addtail(&gpf_dst->strokes, gps_dst);
1053   }
1054 }
1055
1056 /**
1057  * Make a copy of a given gpencil layer.
1058  * \param gpl_src: Source grease pencil layer
1059  * \return Pointer to new layer
1060  */
1061 bGPDlayer *BKE_gpencil_layer_duplicate(const bGPDlayer *gpl_src,
1062                                        const bool dup_frames,
1063                                        const bool dup_strokes)
1064 {
1065   const bGPDframe *gpf_src;
1066   bGPDframe *gpf_dst;
1067   bGPDlayer *gpl_dst;
1068
1069   /* error checking */
1070   if (gpl_src == NULL) {
1071     return NULL;
1072   }
1073
1074   /* make a copy of source layer */
1075   gpl_dst = MEM_dupallocN(gpl_src);
1076   gpl_dst->prev = gpl_dst->next = NULL;
1077
1078   /* Copy masks. */
1079   BLI_listbase_clear(&gpl_dst->mask_layers);
1080   LISTBASE_FOREACH (bGPDlayer_Mask *, mask_src, &gpl_src->mask_layers) {
1081     bGPDlayer_Mask *mask_dst = MEM_dupallocN(mask_src);
1082     mask_dst->prev = mask_dst->next = NULL;
1083     BLI_addtail(&gpl_dst->mask_layers, mask_dst);
1084   }
1085
1086   /* copy frames */
1087   BLI_listbase_clear(&gpl_dst->frames);
1088   if (dup_frames) {
1089     for (gpf_src = gpl_src->frames.first; gpf_src; gpf_src = gpf_src->next) {
1090       /* make a copy of source frame */
1091       gpf_dst = BKE_gpencil_frame_duplicate(gpf_src, dup_strokes);
1092       BLI_addtail(&gpl_dst->frames, gpf_dst);
1093
1094       /* if source frame was the current layer's 'active' frame, reassign that too */
1095       if (gpf_src == gpl_dst->actframe) {
1096         gpl_dst->actframe = gpf_dst;
1097       }
1098     }
1099   }
1100
1101   /* return new layer */
1102   return gpl_dst;
1103 }
1104
1105 /**
1106  * Make a copy of a given gpencil data-block.
1107  *
1108  * XXX: Should this be deprecated?
1109  */
1110 bGPdata *BKE_gpencil_data_duplicate(Main *bmain, const bGPdata *gpd_src, bool internal_copy)
1111 {
1112   bGPdata *gpd_dst;
1113
1114   /* Yuck and super-uber-hyper yuck!!!
1115    * Should be replaceable with a no-main copy (LIB_ID_COPY_NO_MAIN etc.), but not sure about it,
1116    * so for now keep old code for that one. */
1117
1118   /* error checking */
1119   if (gpd_src == NULL) {
1120     return NULL;
1121   }
1122
1123   if (internal_copy) {
1124     /* make a straight copy for undo buffers used during stroke drawing */
1125     gpd_dst = MEM_dupallocN(gpd_src);
1126   }
1127   else {
1128     BLI_assert(bmain != NULL);
1129     gpd_dst = (bGPdata *)BKE_id_copy(bmain, &gpd_src->id);
1130   }
1131
1132   /* Copy internal data (layers, etc.) */
1133   greasepencil_copy_data(bmain, &gpd_dst->id, &gpd_src->id, 0);
1134
1135   /* return new */
1136   return gpd_dst;
1137 }
1138
1139 /* ************************************************** */
1140 /* GP Stroke API */
1141
1142 /**
1143  * Ensure selection status of stroke is in sync with its points.
1144  * \param gps: Grease pencil stroke
1145  */
1146 void BKE_gpencil_stroke_sync_selection(bGPdata *gpd, bGPDstroke *gps)
1147 {
1148   bGPDspoint *pt;
1149   int i;
1150
1151   /* error checking */
1152   if (gps == NULL) {
1153     return;
1154   }
1155
1156   /* we'll stop when we find the first selected point,
1157    * so initially, we must deselect
1158    */
1159   gps->flag &= ~GP_STROKE_SELECT;
1160   BKE_gpencil_stroke_select_index_reset(gps);
1161
1162   for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1163     if (pt->flag & GP_SPOINT_SELECT) {
1164       gps->flag |= GP_STROKE_SELECT;
1165       break;
1166     }
1167   }
1168
1169   if (gps->flag & GP_STROKE_SELECT) {
1170     BKE_gpencil_stroke_select_index_set(gpd, gps);
1171   }
1172 }
1173
1174 void BKE_gpencil_curve_sync_selection(bGPdata *gpd, bGPDstroke *gps)
1175 {
1176   bGPDcurve *gpc = gps->editcurve;
1177   if (gpc == NULL) {
1178     return;
1179   }
1180
1181   gps->flag &= ~GP_STROKE_SELECT;
1182   BKE_gpencil_stroke_select_index_reset(gps);
1183   gpc->flag &= ~GP_CURVE_SELECT;
1184
1185   bool is_selected = false;
1186   for (int i = 0; i < gpc->tot_curve_points; i++) {
1187     bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
1188     BezTriple *bezt = &gpc_pt->bezt;
1189
1190     if (BEZT_ISSEL_ANY(bezt)) {
1191       gpc_pt->flag |= GP_SPOINT_SELECT;
1192     }
1193     else {
1194       gpc_pt->flag &= ~GP_SPOINT_SELECT;
1195     }
1196
1197     if (gpc_pt->flag & GP_SPOINT_SELECT) {
1198       is_selected = true;
1199     }
1200   }
1201
1202   if (is_selected) {
1203     gpc->flag |= GP_CURVE_SELECT;
1204     gps->flag |= GP_STROKE_SELECT;
1205     BKE_gpencil_stroke_select_index_set(gpd, gps);
1206   }
1207 }
1208
1209 /* Assign unique stroke ID for selection. */
1210 void BKE_gpencil_stroke_select_index_set(bGPdata *gpd, bGPDstroke *gps)
1211 {
1212   gpd->select_last_index++;
1213   gps->select_index = gpd->select_last_index;
1214 }
1215
1216 /* Reset unique stroke ID for selection. */
1217 void BKE_gpencil_stroke_select_index_reset(bGPDstroke *gps)
1218 {
1219   gps->select_index = 0;
1220 }
1221
1222 /* ************************************************** */
1223 /* GP Frame API */
1224
1225 /**
1226  * Delete the last stroke of the given frame.
1227  * \param gpl: Grease pencil layer
1228  * \param gpf: Grease pencil frame
1229  */
1230 void BKE_gpencil_frame_delete_laststroke(bGPDlayer *gpl, bGPDframe *gpf)
1231 {
1232   bGPDstroke *gps = (gpf) ? gpf->strokes.last : NULL;
1233   int cfra = (gpf) ? gpf->framenum : 0; /* assume that the current frame was not locked */
1234
1235   /* error checking */
1236   if (ELEM(NULL, gpf, gps)) {
1237     return;
1238   }
1239
1240   /* free the stroke and its data */
1241   if (gps->points) {
1242     MEM_freeN(gps->points);
1243   }
1244   if (gps->dvert) {
1245     BKE_gpencil_free_stroke_weights(gps);
1246     MEM_freeN(gps->dvert);
1247   }
1248   MEM_freeN(gps->triangles);
1249   BLI_freelinkN(&gpf->strokes, gps);
1250
1251   /* if frame has no strokes after this, delete it */
1252   if (BLI_listbase_is_empty(&gpf->strokes)) {
1253     BKE_gpencil_layer_frame_delete(gpl, gpf);
1254     BKE_gpencil_layer_frame_get(gpl, cfra, GP_GETFRAME_USE_PREV);
1255   }
1256 }
1257
1258 /* ************************************************** */
1259 /* GP Layer API */
1260
1261 /**
1262  * Check if the given layer is able to be edited or not.
1263  * \param gpl: Grease pencil layer
1264  * \return True if layer is editable
1265  */
1266 bool BKE_gpencil_layer_is_editable(const bGPDlayer *gpl)
1267 {
1268   /* Sanity check */
1269   if (gpl == NULL) {
1270     return false;
1271   }
1272
1273   /* Layer must be: Visible + Editable */
1274   if ((gpl->flag & (GP_LAYER_HIDE | GP_LAYER_LOCKED)) == 0) {
1275     return true;
1276   }
1277
1278   /* Something failed */
1279   return false;
1280 }
1281
1282 /**
1283  * Look up the gp-frame on the requested frame number, but don't add a new one.
1284  * \param gpl: Grease pencil layer
1285  * \param cframe: Frame number
1286  * \return Pointer to frame
1287  */
1288 bGPDframe *BKE_gpencil_layer_frame_find(bGPDlayer *gpl, int cframe)
1289 {
1290   bGPDframe *gpf;
1291
1292   /* Search in reverse order, since this is often used for playback/adding,
1293    * where it's less likely that we're interested in the earlier frames
1294    */
1295   for (gpf = gpl->frames.last; gpf; gpf = gpf->prev) {
1296     if (gpf->framenum == cframe) {
1297       return gpf;
1298     }
1299   }
1300
1301   return NULL;
1302 }
1303
1304 /**
1305  * Get the appropriate gp-frame from a given layer
1306  * - this sets the layer's actframe var (if allowed to)
1307  * - extension beyond range (if first gp-frame is after all frame in interest and cannot add)
1308  *
1309  * \param gpl: Grease pencil layer
1310  * \param cframe: Frame number
1311  * \param addnew: Add option
1312  * \return Pointer to new frame
1313  */
1314 bGPDframe *BKE_gpencil_layer_frame_get(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
1315 {
1316   bGPDframe *gpf = NULL;
1317   bool found = false;
1318
1319   /* error checking */
1320   if (gpl == NULL) {
1321     return NULL;
1322   }
1323
1324   /* check if there is already an active frame */
1325   if (gpl->actframe) {
1326     gpf = gpl->actframe;
1327
1328     /* do not allow any changes to layer's active frame if layer is locked from changes
1329      * or if the layer has been set to stay on the current frame
1330      */
1331     if (gpl->flag & GP_LAYER_FRAMELOCK) {
1332       return gpf;
1333     }
1334     /* do not allow any changes to actframe if frame has painting tag attached to it */
1335     if (gpf->flag & GP_FRAME_PAINT) {
1336       return gpf;
1337     }
1338
1339     /* try to find matching frame */
1340     if (gpf->framenum < cframe) {
1341       for (; gpf; gpf = gpf->next) {
1342         if (gpf->framenum == cframe) {
1343           found = true;
1344           break;
1345         }
1346         if ((gpf->next) && (gpf->next->framenum > cframe)) {
1347           found = true;
1348           break;
1349         }
1350       }
1351
1352       /* set the appropriate frame */
1353       if (addnew) {
1354         if ((found) && (gpf->framenum == cframe)) {
1355           gpl->actframe = gpf;
1356         }
1357         else if (addnew == GP_GETFRAME_ADD_COPY) {
1358           gpl->actframe = BKE_gpencil_frame_addcopy(gpl, cframe);
1359         }
1360         else {
1361           gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
1362         }
1363       }
1364       else if (found) {
1365         gpl->actframe = gpf;
1366       }
1367       else {
1368         gpl->actframe = gpl->frames.last;
1369       }
1370     }
1371     else {
1372       for (; gpf; gpf = gpf->prev) {
1373         if (gpf->framenum <= cframe) {
1374           found = true;
1375           break;
1376         }
1377       }
1378
1379       /* set the appropriate frame */
1380       if (addnew) {
1381         if ((found) && (gpf->framenum == cframe)) {
1382           gpl->actframe = gpf;
1383         }
1384         else if (addnew == GP_GETFRAME_ADD_COPY) {
1385           gpl->actframe = BKE_gpencil_frame_addcopy(gpl, cframe);
1386         }
1387         else {
1388           gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
1389         }
1390       }
1391       else if (found) {
1392         gpl->actframe = gpf;
1393       }
1394       else {
1395         gpl->actframe = gpl->frames.first;
1396       }
1397     }
1398   }
1399   else if (gpl->frames.first) {
1400     /* check which of the ends to start checking from */
1401     const int first = ((bGPDframe *)(gpl->frames.first))->framenum;
1402     const int last = ((bGPDframe *)(gpl->frames.last))->framenum;
1403
1404     if (abs(cframe - first) > abs(cframe - last)) {
1405       /* find gp-frame which is less than or equal to cframe */
1406       for (gpf = gpl->frames.last; gpf; gpf = gpf->prev) {
1407         if (gpf->framenum <= cframe) {
1408           found = true;
1409           break;
1410         }
1411       }
1412     }
1413     else {
1414       /* find gp-frame which is less than or equal to cframe */
1415       for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1416         if (gpf->framenum <= cframe) {
1417           found = true;
1418           break;
1419         }
1420       }
1421     }
1422
1423     /* set the appropriate frame */
1424     if (addnew) {
1425       if ((found) && (gpf->framenum == cframe)) {
1426         gpl->actframe = gpf;
1427       }
1428       else {
1429         gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
1430       }
1431     }
1432     else if (found) {
1433       gpl->actframe = gpf;
1434     }
1435     else {
1436       /* If delete first frame, need to find one. */
1437       if (gpl->frames.first != NULL) {
1438         gpl->actframe = gpl->frames.first;
1439       }
1440       else {
1441         /* unresolved errogenous situation! */
1442         CLOG_STR_ERROR(&LOG, "cannot find appropriate gp-frame");
1443         /* gpl->actframe should still be NULL */
1444       }
1445     }
1446   }
1447   else {
1448     /* currently no frames (add if allowed to) */
1449     if (addnew) {
1450       gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
1451     }
1452     else {
1453       /* don't do anything... this may be when no frames yet! */
1454       /* gpl->actframe should still be NULL */
1455     }
1456   }
1457
1458   /* Don't select first frame if greater than current frame. */
1459   if ((gpl->actframe != NULL) && (gpl->actframe == gpl->frames.first) &&
1460       (gpl->actframe->framenum > cframe)) {
1461     gpl->actframe = NULL;
1462   }
1463
1464   /* return */
1465   return gpl->actframe;
1466 }
1467
1468 /**
1469  * Delete the given frame from a layer.
1470  * \param gpl: Grease pencil layer
1471  * \param gpf: Grease pencil frame
1472  * \return True if delete was done
1473  */
1474 bool BKE_gpencil_layer_frame_delete(bGPDlayer *gpl, bGPDframe *gpf)
1475 {
1476   bool changed = false;
1477
1478   /* error checking */
1479   if (ELEM(NULL, gpl, gpf)) {
1480     return false;
1481   }
1482
1483   /* if this frame was active, make the previous frame active instead
1484    * since it's tricky to set active frame otherwise
1485    */
1486   if (gpl->actframe == gpf) {
1487     gpl->actframe = gpf->prev;
1488   }
1489
1490   /* free the frame and its data */
1491   changed = BKE_gpencil_free_strokes(gpf);
1492   BLI_freelinkN(&gpl->frames, gpf);
1493
1494   return changed;
1495 }
1496
1497 /**
1498  * Get layer by name
1499  * \param gpd: Grease pencil data-block
1500  * \param name: Layer name
1501  * \return Pointer to layer
1502  */
1503 bGPDlayer *BKE_gpencil_layer_named_get(bGPdata *gpd, const char *name)
1504 {
1505   if (name[0] == '\0') {
1506     return NULL;
1507   }
1508   return BLI_findstring(&gpd->layers, name, offsetof(bGPDlayer, info));
1509 }
1510
1511 /**
1512  * Get mask layer by name.
1513  * \param gpl: Grease pencil layer
1514  * \param name: Mask name
1515  * \return Pointer to mask layer
1516  */
1517 bGPDlayer_Mask *BKE_gpencil_layer_mask_named_get(bGPDlayer *gpl, const char *name)
1518 {
1519   if (name[0] == '\0') {
1520     return NULL;
1521   }
1522   return BLI_findstring(&gpl->mask_layers, name, offsetof(bGPDlayer_Mask, name));
1523 }
1524
1525 /**
1526  * Add grease pencil mask layer.
1527  * \param gpl: Grease pencil layer
1528  * \param name: Name of the mask
1529  * \return Pointer to new mask layer
1530  */
1531 bGPDlayer_Mask *BKE_gpencil_layer_mask_add(bGPDlayer *gpl, const char *name)
1532 {
1533
1534   bGPDlayer_Mask *mask = MEM_callocN(sizeof(bGPDlayer_Mask), "bGPDlayer_Mask");
1535   BLI_addtail(&gpl->mask_layers, mask);
1536   BLI_strncpy(mask->name, name, sizeof(mask->name));
1537   gpl->act_mask++;
1538
1539   return mask;
1540 }
1541
1542 /**
1543  * Remove grease pencil mask layer.
1544  * \param gpl: Grease pencil layer
1545  * \param mask: Grease pencil mask layer
1546  */
1547 void BKE_gpencil_layer_mask_remove(bGPDlayer *gpl, bGPDlayer_Mask *mask)
1548 {
1549   BLI_freelinkN(&gpl->mask_layers, mask);
1550   gpl->act_mask--;
1551   CLAMP_MIN(gpl->act_mask, 0);
1552 }
1553
1554 /**
1555  * Remove any reference to mask layer.
1556  * \param gpd: Grease pencil data-block
1557  * \param name: Name of the mask layer
1558  */
1559 void BKE_gpencil_layer_mask_remove_ref(bGPdata *gpd, const char *name)
1560 {
1561   bGPDlayer_Mask *mask_next;
1562
1563   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1564     for (bGPDlayer_Mask *mask = gpl->mask_layers.first; mask; mask = mask_next) {
1565       mask_next = mask->next;
1566       if (STREQ(mask->name, name)) {
1567         BKE_gpencil_layer_mask_remove(gpl, mask);
1568       }
1569     }
1570   }
1571 }
1572
1573 static int gpencil_cb_sort_masks(const void *arg1, const void *arg2)
1574 {
1575   /* sort is inverted as layer list. */
1576   const struct bGPDlayer_Mask *mask1 = arg1;
1577   const struct bGPDlayer_Mask *mask2 = arg2;
1578   int val = 0;
1579
1580   if (mask1->sort_index < mask2->sort_index) {
1581     val = 1;
1582   }
1583   else if (mask1->sort_index > mask2->sort_index) {
1584     val = -1;
1585   }
1586
1587   return val;
1588 }
1589
1590 /**
1591  * Sort grease pencil mask layers.
1592  * \param gpd: Grease pencil data-block
1593  * \param gpl: Grease pencil layer
1594  */
1595 void BKE_gpencil_layer_mask_sort(bGPdata *gpd, bGPDlayer *gpl)
1596 {
1597   /* Update sort index. */
1598   LISTBASE_FOREACH (bGPDlayer_Mask *, mask, &gpl->mask_layers) {
1599     bGPDlayer *gpl_mask = BKE_gpencil_layer_named_get(gpd, mask->name);
1600     if (gpl_mask != NULL) {
1601       mask->sort_index = BLI_findindex(&gpd->layers, gpl_mask);
1602     }
1603     else {
1604       mask->sort_index = 0;
1605     }
1606   }
1607   BLI_listbase_sort(&gpl->mask_layers, gpencil_cb_sort_masks);
1608 }
1609
1610 /**
1611  * Sort all grease pencil mask layer.
1612  * \param gpd: Grease pencil data-block
1613  */
1614 void BKE_gpencil_layer_mask_sort_all(bGPdata *gpd)
1615 {
1616   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1617     BKE_gpencil_layer_mask_sort(gpd, gpl);
1618   }
1619 }
1620
1621 static int gpencil_cb_cmp_frame(void *thunk, const void *a, const void *b)
1622 {
1623   const bGPDframe *frame_a = a;
1624   const bGPDframe *frame_b = b;
1625
1626   if (frame_a->framenum < frame_b->framenum) {
1627     return -1;
1628   }
1629   if (frame_a->framenum > frame_b->framenum) {
1630     return 1;
1631   }
1632   if (thunk != NULL) {
1633     *((bool *)thunk) = true;
1634   }
1635   /* Sort selected last. */
1636   if ((frame_a->flag & GP_FRAME_SELECT) && ((frame_b->flag & GP_FRAME_SELECT) == 0)) {
1637     return 1;
1638   }
1639   return 0;
1640 }
1641
1642 /**
1643  * Sort grease pencil frames.
1644  * \param gpl: Grease pencil layer
1645  * \param r_has_duplicate_frames: Duplicated frames flag
1646  */
1647 void BKE_gpencil_layer_frames_sort(struct bGPDlayer *gpl, bool *r_has_duplicate_frames)
1648 {
1649   BLI_listbase_sort_r(&gpl->frames, gpencil_cb_cmp_frame, r_has_duplicate_frames);
1650 }
1651
1652 /**
1653  * Get the active grease pencil layer for editing.
1654  * \param gpd: Grease pencil data-block
1655  * \return Pointer to layer
1656  */
1657 bGPDlayer *BKE_gpencil_layer_active_get(bGPdata *gpd)
1658 {
1659   /* error checking */
1660   if (ELEM(NULL, gpd, gpd->layers.first)) {
1661     return NULL;
1662   }
1663
1664   /* loop over layers until found (assume only one active) */
1665   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1666     if (gpl->flag & GP_LAYER_ACTIVE) {
1667       return gpl;
1668     }
1669   }
1670
1671   /* no active layer found */
1672   return NULL;
1673 }
1674
1675 bGPDlayer *BKE_gpencil_layer_get_by_name(bGPdata *gpd, char *name, int first_if_not_found)
1676 {
1677   bGPDlayer *gpl;
1678   int i = 0;
1679
1680   /* error checking */
1681   if (ELEM(NULL, gpd, gpd->layers.first)) {
1682     return NULL;
1683   }
1684
1685   /* loop over layers until found (assume only one active) */
1686   for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1687     if (STREQ(name, gpl->info)) {
1688       return gpl;
1689     }
1690     i++;
1691   }
1692
1693   /* no such layer */
1694   if (first_if_not_found) {
1695     return gpd->layers.first;
1696   }
1697   return NULL;
1698 }
1699
1700 /**
1701  * Set active grease pencil layer.
1702  * \param gpd: Grease pencil data-block
1703  * \param active: Grease pencil layer to set as active
1704  */
1705 void BKE_gpencil_layer_active_set(bGPdata *gpd, bGPDlayer *active)
1706 {
1707   /* error checking */
1708   if (ELEM(NULL, gpd, gpd->layers.first, active)) {
1709     return;
1710   }
1711
1712   /* loop over layers deactivating all */
1713   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1714     gpl->flag &= ~GP_LAYER_ACTIVE;
1715     if (gpd->flag & GP_DATA_AUTOLOCK_LAYERS) {
1716       gpl->flag |= GP_LAYER_LOCKED;
1717     }
1718   }
1719
1720   /* set as active one */
1721   active->flag |= GP_LAYER_ACTIVE;
1722   if (gpd->flag & GP_DATA_AUTOLOCK_LAYERS) {
1723     active->flag &= ~GP_LAYER_LOCKED;
1724   }
1725 }
1726
1727 /**
1728  * Set locked layers for autolock mode.
1729  * \param gpd: Grease pencil data-block
1730  * \param unlock: Unlock flag
1731  */
1732 void BKE_gpencil_layer_autolock_set(bGPdata *gpd, const bool unlock)
1733 {
1734   BLI_assert(gpd != NULL);
1735
1736   if (gpd->flag & GP_DATA_AUTOLOCK_LAYERS) {
1737     bGPDlayer *layer_active = BKE_gpencil_layer_active_get(gpd);
1738
1739     /* Lock all other layers */
1740     LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1741       /* unlock active layer */
1742       if (gpl == layer_active) {
1743         gpl->flag &= ~GP_LAYER_LOCKED;
1744       }
1745       else {
1746         gpl->flag |= GP_LAYER_LOCKED;
1747       }
1748     }
1749   }
1750   else {
1751     /* If disable is better unlock all layers by default or it looks there is
1752      * a problem in the UI because the user expects all layers will be unlocked
1753      */
1754     if (unlock) {
1755       LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1756         gpl->flag &= ~GP_LAYER_LOCKED;
1757       }
1758     }
1759   }
1760 }
1761
1762 /**
1763  * Delete grease pencil layer.
1764  * \param gpd: Grease pencil data-block
1765  * \param gpl: Grease pencil layer
1766  */
1767 void BKE_gpencil_layer_delete(bGPdata *gpd, bGPDlayer *gpl)
1768 {
1769   /* error checking */
1770   if (ELEM(NULL, gpd, gpl)) {
1771     return;
1772   }
1773
1774   /* free layer */
1775   BKE_gpencil_free_frames(gpl);
1776
1777   /* Free Masks. */
1778   BKE_gpencil_free_layer_masks(gpl);
1779
1780   /* Remove any reference to that layer in masking lists. */
1781   BKE_gpencil_layer_mask_remove_ref(gpd, gpl->info);
1782
1783   /* free icon providing preview of icon color */
1784   BKE_icon_delete(gpl->runtime.icon_id);
1785
1786   BLI_freelinkN(&gpd->layers, gpl);
1787 }
1788
1789 /**
1790  * Get grease pencil material from brush.
1791  * \param brush: Brush
1792  * \return Pointer to material
1793  */
1794 Material *BKE_gpencil_brush_material_get(Brush *brush)
1795 {
1796   Material *ma = NULL;
1797
1798   if ((brush != NULL) && (brush->gpencil_settings != NULL) &&
1799       (brush->gpencil_settings->material != NULL)) {
1800     ma = brush->gpencil_settings->material;
1801   }
1802
1803   return ma;
1804 }
1805
1806 /**
1807  * Set grease pencil brush material.
1808  * \param brush: Brush
1809  * \param ma: Material
1810  */
1811 void BKE_gpencil_brush_material_set(Brush *brush, Material *ma)
1812 {
1813   BLI_assert(brush);
1814   BLI_assert(brush->gpencil_settings);
1815   if (brush->gpencil_settings->material != ma) {
1816     if (brush->gpencil_settings->material) {
1817       id_us_min(&brush->gpencil_settings->material->id);
1818     }
1819     if (ma) {
1820       id_us_plus(&ma->id);
1821     }
1822     brush->gpencil_settings->material = ma;
1823   }
1824 }
1825
1826 /**
1827  * Adds the pinned material to the object if necessary.
1828  * \param bmain: Main pointer
1829  * \param ob: Grease pencil object
1830  * \param brush: Brush
1831  * \return Pointer to material
1832  */
1833 Material *BKE_gpencil_object_material_ensure_from_brush(Main *bmain, Object *ob, Brush *brush)
1834 {
1835   if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
1836     Material *ma = BKE_gpencil_brush_material_get(brush);
1837
1838     /* check if the material is already on object material slots and add it if missing */
1839     if (ma && BKE_gpencil_object_material_index_get(ob, ma) < 0) {
1840       BKE_object_material_slot_add(bmain, ob);
1841       BKE_object_material_assign(bmain, ob, ma, ob->totcol, BKE_MAT_ASSIGN_USERPREF);
1842     }
1843
1844     return ma;
1845   }
1846
1847   /* using active material instead */
1848   return BKE_object_material_get(ob, ob->actcol);
1849 }
1850
1851 /**
1852  * Assigns the material to object (if not already present) and returns its index (mat_nr).
1853  * \param bmain: Main pointer
1854  * \param ob: Grease pencil object
1855  * \param material: Material
1856  * \return Index of the material
1857  */
1858 int BKE_gpencil_object_material_ensure(Main *bmain, Object *ob, Material *material)
1859 {
1860   if (!material) {
1861     return -1;
1862   }
1863   int index = BKE_gpencil_object_material_index_get(ob, material);
1864   if (index < 0) {
1865     BKE_object_material_slot_add(bmain, ob);
1866     BKE_object_material_assign(bmain, ob, material, ob->totcol, BKE_MAT_ASSIGN_USERPREF);
1867     return ob->totcol - 1;
1868   }
1869   return index;
1870 }
1871
1872 /**
1873  * Creates a new grease-pencil material and assigns it to object.
1874  * \param bmain: Main pointer
1875  * \param ob: Grease pencil object
1876  * \param name: Material name
1877  * \param r_index: value is set to zero based index of the new material if \a r_index is not NULL.
1878  * \return Material pointer.
1879  */
1880 Material *BKE_gpencil_object_material_new(Main *bmain, Object *ob, const char *name, int *r_index)
1881 {
1882   Material *ma = BKE_gpencil_material_add(bmain, name);
1883   id_us_min(&ma->id); /* no users yet */
1884
1885   BKE_object_material_slot_add(bmain, ob);
1886   BKE_object_material_assign(bmain, ob, ma, ob->totcol, BKE_MAT_ASSIGN_USERPREF);
1887
1888   if (r_index) {
1889     *r_index = ob->actcol - 1;
1890   }
1891   return ma;
1892 }
1893
1894 /**
1895  * Returns the material for a brush with respect to its pinned state.
1896  * \param ob: Grease pencil object
1897  * \param brush: Brush
1898  * \return Material pointer
1899  */
1900 Material *BKE_gpencil_object_material_from_brush_get(Object *ob, Brush *brush)
1901 {
1902   if ((brush) && (brush->gpencil_settings) &&
1903       (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED)) {
1904     Material *ma = BKE_gpencil_brush_material_get(brush);
1905     return ma;
1906   }
1907
1908   return BKE_object_material_get(ob, ob->actcol);
1909 }
1910
1911 /**
1912  * Returns the material index for a brush with respect to its pinned state.
1913  * \param ob: Grease pencil object
1914  * \param brush: Brush
1915  * \return Material index.
1916  */
1917 int BKE_gpencil_object_material_get_index_from_brush(Object *ob, Brush *brush)
1918 {
1919   if ((brush) && (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED)) {
1920     return BKE_gpencil_object_material_index_get(ob, brush->gpencil_settings->material);
1921   }
1922
1923   return ob->actcol - 1;
1924 }
1925
1926 /**
1927  * Guaranteed to return a material assigned to object. Returns never NULL.
1928  * \param bmain: Main pointer
1929  * \param ob: Grease pencil object
1930  * \return Material pointer.
1931  */
1932 Material *BKE_gpencil_object_material_ensure_from_active_input_toolsettings(Main *bmain,
1933                                                                             Object *ob,
1934                                                                             ToolSettings *ts)
1935 {
1936   if (ts && ts->gp_paint && ts->gp_paint->paint.brush) {
1937     return BKE_gpencil_object_material_ensure_from_active_input_brush(
1938         bmain, ob, ts->gp_paint->paint.brush);
1939   }
1940
1941   return BKE_gpencil_object_material_ensure_from_active_input_brush(bmain, ob, NULL);
1942 }
1943
1944 /**
1945  * Guaranteed to return a material assigned to object. Returns never NULL.
1946  * \param bmain: Main pointer
1947  * \param ob: Grease pencil object.
1948  * \param brush: Brush
1949  * \return Material pointer
1950  */
1951 Material *BKE_gpencil_object_material_ensure_from_active_input_brush(Main *bmain,
1952                                                                      Object *ob,
1953                                                                      Brush *brush)
1954 {
1955   if (brush) {
1956     Material *ma = BKE_gpencil_object_material_ensure_from_brush(bmain, ob, brush);
1957     if (ma) {
1958       return ma;
1959     }
1960     if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
1961       /* it is easier to just unpin a NULL material, instead of setting a new one */
1962       brush->gpencil_settings->flag &= ~GP_BRUSH_MATERIAL_PINNED;
1963     }
1964   }
1965   return BKE_gpencil_object_material_ensure_from_active_input_material(ob);
1966 }
1967
1968 /**
1969  * Guaranteed to return a material assigned to object. Returns never NULL.
1970  * Only use this for materials unrelated to user input.
1971  * \param ob: Grease pencil object
1972  * \return Material pointer
1973  */
1974 Material *BKE_gpencil_object_material_ensure_from_active_input_material(Object *ob)
1975 {
1976   Material *ma = BKE_object_material_get(ob, ob->actcol);
1977   if (ma) {
1978     return ma;
1979   }
1980
1981   return BKE_material_default_gpencil();
1982 }
1983
1984 /**
1985  * Get active color, and add all default settings if we don't find anything.
1986  * \param ob: Grease pencil object
1987  * \return Material pointer
1988  */
1989 Material *BKE_gpencil_object_material_ensure_active(Object *ob)
1990 {
1991   Material *ma = NULL;
1992
1993   /* sanity checks */
1994   if (ob == NULL) {
1995     return NULL;
1996   }
1997
1998   ma = BKE_gpencil_object_material_ensure_from_active_input_material(ob);
1999   if (ma->gp_style == NULL) {
2000     BKE_gpencil_material_attr_init(ma);
2001   }
2002
2003   return ma;
2004 }
2005
2006 /* ************************************************** */
2007 /**
2008  * Check if stroke has any point selected
2009  * \param gps: Grease pencil stroke
2010  * \return True if selected
2011  */
2012 bool BKE_gpencil_stroke_select_check(const bGPDstroke *gps)
2013 {
2014   const bGPDspoint *pt;
2015   int i;
2016   for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
2017     if (pt->flag & GP_SPOINT_SELECT) {
2018       return true;
2019     }
2020   }
2021   return false;
2022 }
2023
2024 /* ************************************************** */
2025 /* GP Object - Vertex Groups */
2026
2027 /**
2028  * Remove a vertex group.
2029  * \param ob: Grease pencil object
2030  * \param defgroup: deform group
2031  */
2032 void BKE_gpencil_vgroup_remove(Object *ob, bDeformGroup *defgroup)
2033 {
2034   bGPdata *gpd = ob->data;
2035   MDeformVert *dvert = NULL;
2036   const int def_nr = BLI_findindex(&ob->defbase, defgroup);
2037   const int totgrp = BLI_listbase_count(&ob->defbase);
2038
2039   /* Remove points data */
2040   if (gpd) {
2041     LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2042       LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2043         LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2044           if (gps->dvert != NULL) {
2045             for (int i = 0; i < gps->totpoints; i++) {
2046               dvert = &gps->dvert[i];
2047               MDeformWeight *dw = BKE_defvert_find_index(dvert, def_nr);
2048               if (dw != NULL) {
2049                 BKE_defvert_remove_group(dvert, dw);
2050               }
2051               /* Reorganize weights for other groups after deleted one. */
2052               for (int g = 0; g < totgrp; g++) {
2053                 dw = BKE_defvert_find_index(dvert, g);
2054                 if ((dw != NULL) && (dw->def_nr > def_nr)) {
2055                   dw->def_nr--;
2056                 }
2057               }
2058             }
2059           }
2060         }
2061       }
2062     }
2063   }
2064
2065   /* Remove the group */
2066   BLI_freelinkN(&ob->defbase, defgroup);
2067   DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
2068 }
2069
2070 /**
2071  * Ensure stroke has vertex group.
2072  * \param gps: Grease pencil stroke
2073  */
2074 void BKE_gpencil_dvert_ensure(bGPDstroke *gps)
2075 {
2076   if (gps->dvert == NULL) {
2077     gps->dvert = MEM_callocN(sizeof(MDeformVert) * gps->totpoints, "gp_stroke_weights");
2078   }
2079 }
2080
2081 /* ************************************************** */
2082
2083 /**
2084  * Get range of selected frames in layer.
2085  * Always the active frame is considered as selected, so if no more selected the range
2086  * will be equal to the current active frame.
2087  * \param gpl: Layer.
2088  * \param r_initframe: Number of first selected frame.
2089  * \param r_endframe: Number of last selected frame.
2090  */
2091 void BKE_gpencil_frame_range_selected(bGPDlayer *gpl, int *r_initframe, int *r_endframe)
2092 {
2093   *r_initframe = gpl->actframe->framenum;
2094   *r_endframe = gpl->actframe->framenum;
2095
2096   LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2097     if (gpf->flag & GP_FRAME_SELECT) {
2098       if (gpf->framenum < *r_initframe) {
2099         *r_initframe = gpf->framenum;
2100       }
2101       if (gpf->framenum > *r_endframe) {
2102         *r_endframe = gpf->framenum;
2103       }
2104     }
2105   }
2106 }
2107
2108 /**
2109  * Get Falloff factor base on frame range
2110  * \param gpf: Frame.
2111  * \param actnum: Number of active frame in layer.
2112  * \param f_init: Number of first selected frame.
2113  * \param f_end: Number of last selected frame.
2114  * \param cur_falloff: Curve with falloff factors.
2115  */
2116 float BKE_gpencil_multiframe_falloff_calc(
2117     bGPDframe *gpf, int actnum, int f_init, int f_end, CurveMapping *cur_falloff)
2118 {
2119   float fnum = 0.5f; /* default mid curve */
2120   float value;
2121
2122   /* check curve is available */
2123   if (cur_falloff == NULL) {
2124     return 1.0f;
2125   }
2126
2127   /* frames to the right of the active frame */
2128   if (gpf->framenum < actnum) {
2129     fnum = (float)(gpf->framenum - f_init) / (actnum - f_init);
2130     fnum *= 0.5f;
2131     value = BKE_curvemapping_evaluateF(cur_falloff, 0, fnum);
2132   }
2133   /* frames to the left of the active frame */
2134   else if (gpf->framenum > actnum) {
2135     fnum = (float)(gpf->framenum - actnum) / (f_end - actnum);
2136     fnum *= 0.5f;
2137     value = BKE_curvemapping_evaluateF(cur_falloff, 0, fnum + 0.5f);
2138   }
2139   else {
2140     /* Center of the curve. */
2141     value = BKE_curvemapping_evaluateF(cur_falloff, 0, 0.5f);
2142   }
2143
2144   return value;
2145 }
2146
2147 /**
2148  * Reassign strokes using a material.
2149  * \param gpd: Grease pencil data-block
2150  * \param totcol: Total materials
2151  * \param index: Index of the material
2152  */
2153 void BKE_gpencil_material_index_reassign(bGPdata *gpd, int totcol, int index)
2154 {
2155   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2156     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2157       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2158         /* reassign strokes */
2159         if ((gps->mat_nr > index) || (gps->mat_nr > totcol - 1)) {
2160           gps->mat_nr--;
2161           CLAMP_MIN(gps->mat_nr, 0);
2162         }
2163       }
2164     }
2165   }
2166 }
2167
2168 /**
2169  * Remove strokes using a material.
2170  * \param gpd: Grease pencil data-block
2171  * \param index: Index of the material
2172  * \return True if removed
2173  */
2174 bool BKE_gpencil_material_index_used(bGPdata *gpd, int index)
2175 {
2176   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2177     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2178       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2179         if (gps->mat_nr == index) {
2180           return true;
2181         }
2182       }
2183     }
2184   }
2185
2186   return false;
2187 }
2188
2189 /**
2190  * Remap material
2191  * \param gpd: Grease pencil data-block
2192  * \param remap: Remap index
2193  * \param remap_len: Remap length
2194  */
2195 void BKE_gpencil_material_remap(struct bGPdata *gpd,
2196                                 const unsigned int *remap,
2197                                 unsigned int remap_len)
2198 {
2199   const short remap_len_short = (short)remap_len;
2200
2201 #define MAT_NR_REMAP(n) \
2202   if (n < remap_len_short) { \
2203     BLI_assert(n >= 0 && remap[n] < remap_len_short); \
2204     n = remap[n]; \
2205   } \
2206   ((void)0)
2207
2208   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2209     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2210       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2211         /* reassign strokes */
2212         MAT_NR_REMAP(gps->mat_nr);
2213       }
2214     }
2215   }
2216
2217 #undef MAT_NR_REMAP
2218 }
2219
2220 /**
2221  * Load a table with material conversion index for merged materials.
2222  * \param ob: Grease pencil object.
2223  * \param hue_threshold: Threshold for Hue.
2224  * \param sat_threshold: Threshold for Saturation.
2225  * \param val_threshold: Threshold for Value.
2226  * \param r_mat_table: return material table.
2227  * \return True if done.
2228  */
2229 bool BKE_gpencil_merge_materials_table_get(Object *ob,
2230                                            const float hue_threshold,
2231                                            const float sat_threshold,
2232                                            const float val_threshold,
2233                                            GHash *r_mat_table)
2234 {
2235   bool changed = false;
2236
2237   Material *ma_primary = NULL;
2238   Material *ma_secondary = NULL;
2239   MaterialGPencilStyle *gp_style_primary = NULL;
2240   MaterialGPencilStyle *gp_style_secondary = NULL;
2241   GHash *mat_used = BLI_ghash_int_new(__func__);
2242
2243   short *totcol = BKE_object_material_len_p(ob);
2244   if (totcol == 0) {
2245     return changed;
2246   }
2247
2248   for (int idx_primary = 0; idx_primary < *totcol; idx_primary++) {
2249     /* Read primary material to compare. */
2250     ma_primary = BKE_gpencil_material(ob, idx_primary + 1);
2251     if (ma_primary == NULL) {
2252       continue;
2253     }
2254     for (int idx_secondary = 0; idx_secondary < *totcol; idx_secondary++) {
2255       if ((idx_secondary == idx_primary) ||
2256           BLI_ghash_haskey(r_mat_table, POINTER_FROM_INT(idx_secondary))) {
2257         continue;
2258       }
2259       if (BLI_ghash_haskey(mat_used, POINTER_FROM_INT(idx_secondary))) {
2260         continue;
2261       }
2262
2263       /* Read secondary material to compare with primary material. */
2264       ma_secondary = BKE_gpencil_material(ob, idx_secondary + 1);
2265       if ((ma_secondary == NULL) ||
2266           (BLI_ghash_haskey(r_mat_table, POINTER_FROM_INT(idx_secondary)))) {
2267         continue;
2268       }
2269       gp_style_primary = ma_primary->gp_style;
2270       gp_style_secondary = ma_secondary->gp_style;
2271
2272       if ((gp_style_primary == NULL) || (gp_style_secondary == NULL) ||
2273           (gp_style_secondary->flag & GP_MATERIAL_LOCKED)) {
2274         continue;
2275       }
2276
2277       /* Check materials have the same mode. */
2278       if (gp_style_primary->mode != gp_style_secondary->mode) {
2279         continue;
2280       }
2281
2282       /* Check materials have same stroke and fill attributes. */
2283       if ((gp_style_primary->flag & GP_MATERIAL_STROKE_SHOW) !=
2284           (gp_style_secondary->flag & GP_MATERIAL_STROKE_SHOW)) {
2285         continue;
2286       }
2287
2288       if ((gp_style_primary->flag & GP_MATERIAL_FILL_SHOW) !=
2289           (gp_style_secondary->flag & GP_MATERIAL_FILL_SHOW)) {
2290         continue;
2291       }
2292
2293       /* Check materials have the same type. */
2294       if ((gp_style_primary->stroke_style != gp_style_secondary->stroke_style) ||
2295           (gp_style_primary->fill_style != gp_style_secondary->fill_style)) {
2296         continue;
2297       }
2298
2299       float s_hsv_a[3], s_hsv_b[3], f_hsv_a[3], f_hsv_b[3], col[3];
2300       zero_v3(s_hsv_a);
2301       zero_v3(s_hsv_b);
2302       zero_v3(f_hsv_a);
2303       zero_v3(f_hsv_b);
2304
2305       copy_v3_v3(col, gp_style_primary->stroke_rgba);
2306       rgb_to_hsv_compat_v(col, s_hsv_a);
2307       copy_v3_v3(col, gp_style_secondary->stroke_rgba);
2308       rgb_to_hsv_compat_v(col, s_hsv_b);
2309
2310       copy_v3_v3(col, gp_style_primary->fill_rgba);
2311       rgb_to_hsv_compat_v(col, f_hsv_a);
2312       copy_v3_v3(col, gp_style_secondary->fill_rgba);
2313       rgb_to_hsv_compat_v(col, f_hsv_b);
2314
2315       /* Check stroke and fill color. */
2316       if ((!compare_ff(s_hsv_a[0], s_hsv_b[0], hue_threshold)) ||
2317           (!compare_ff(s_hsv_a[1], s_hsv_b[1], sat_threshold)) ||
2318           (!compare_ff(s_hsv_a[2], s_hsv_b[2], val_threshold)) ||
2319           (!compare_ff(f_hsv_a[0], f_hsv_b[0], hue_threshold)) ||
2320           (!compare_ff(f_hsv_a[1], f_hsv_b[1], sat_threshold)) ||
2321           (!compare_ff(f_hsv_a[2], f_hsv_b[2], val_threshold)) ||
2322           (!compare_ff(gp_style_primary->stroke_rgba[3],
2323                        gp_style_secondary->stroke_rgba[3],
2324                        val_threshold)) ||
2325           (!compare_ff(
2326               gp_style_primary->fill_rgba[3], gp_style_secondary->fill_rgba[3], val_threshold))) {
2327         continue;
2328       }
2329
2330       /* Save conversion indexes. */
2331       if (!BLI_ghash_haskey(r_mat_table, POINTER_FROM_INT(idx_secondary))) {
2332         BLI_ghash_insert(
2333             r_mat_table, POINTER_FROM_INT(idx_secondary), POINTER_FROM_INT(idx_primary));
2334         changed = true;
2335
2336         if (!BLI_ghash_haskey(mat_used, POINTER_FROM_INT(idx_primary))) {
2337           BLI_ghash_insert(mat_used, POINTER_FROM_INT(idx_primary), POINTER_FROM_INT(idx_primary));
2338         }
2339       }
2340     }
2341   }
2342   /* Free hash memory. */
2343   BLI_ghash_free(mat_used, NULL, NULL);
2344
2345   return changed;
2346 }
2347
2348 /**
2349  * Merge similar materials
2350  * \param ob: Grease pencil object
2351  * \param hue_threshold: Threshold for Hue
2352  * \param sat_threshold: Threshold for Saturation
2353  * \param val_threshold: Threshold for Value
2354  * \param r_removed: Number of materials removed
2355  * \return True if done
2356  */
2357 bool BKE_gpencil_merge_materials(Object *ob,
2358                                  const float hue_threshold,
2359                                  const float sat_threshold,
2360                                  const float val_threshold,
2361                                  int *r_removed)
2362 {
2363   bGPdata *gpd = ob->data;
2364
2365   short *totcol = BKE_object_material_len_p(ob);
2366   if (totcol == 0) {
2367     *r_removed = 0;
2368     return 0;
2369   }
2370
2371   /* Review materials. */
2372   GHash *mat_table = BLI_ghash_int_new(__func__);
2373
2374   bool changed = BKE_gpencil_merge_materials_table_get(
2375       ob, hue_threshold, sat_threshold, val_threshold, mat_table);
2376
2377   *r_removed = BLI_ghash_len(mat_table);
2378
2379   /* Update stroke material index. */
2380   if (changed) {
2381     LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2382       if (gpl->flag & GP_LAYER_HIDE) {
2383         continue;
2384       }
2385
2386       LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2387         LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2388           /* Check if the color is editable. */
2389           MaterialGPencilStyle *gp_style = BKE_gpencil_material_settings(ob, gps->mat_nr + 1);
2390           if (gp_style != NULL) {
2391             if (gp_style->flag & GP_MATERIAL_HIDE) {
2392               continue;
2393             }
2394             if (((gpl->flag & GP_LAYER_UNLOCK_COLOR) == 0) &&
2395                 (gp_style->flag & GP_MATERIAL_LOCKED)) {
2396               continue;
2397             }
2398           }
2399
2400           if (BLI_ghash_haskey(mat_table, POINTER_FROM_INT(gps->mat_nr))) {
2401             int *idx = BLI_ghash_lookup(mat_table, POINTER_FROM_INT(gps->mat_nr));
2402             gps->mat_nr = POINTER_AS_INT(idx);
2403           }
2404         }
2405       }
2406     }
2407   }
2408
2409   /* Free hash memory. */
2410   BLI_ghash_free(mat_table, NULL, NULL);
2411
2412   return changed;
2413 }
2414
2415 /**
2416  * Calc grease pencil statistics functions.
2417  * \param gpd: Grease pencil data-block
2418  */
2419 void BKE_gpencil_stats_update(bGPdata *gpd)
2420 {
2421   gpd->totlayer = 0;
2422   gpd->totframe = 0;
2423   gpd->totstroke = 0;
2424   gpd->totpoint = 0;
2425
2426   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2427     gpd->totlayer++;
2428     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2429       gpd->totframe++;
2430       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2431         gpd->totstroke++;
2432         gpd->totpoint += gps->totpoints;
2433       }
2434     }
2435   }
2436 }
2437
2438 /**
2439  * Get material index (0-based like mat_nr not actcol).
2440  * \param ob: Grease pencil object
2441  * \param ma: Material
2442  * \return Index of the material
2443  */
2444 int BKE_gpencil_object_material_index_get(Object *ob, Material *ma)
2445 {
2446   short *totcol = BKE_object_material_len_p(ob);
2447   Material *read_ma = NULL;
2448   for (short i = 0; i < *totcol; i++) {
2449     read_ma = BKE_object_material_get(ob, i + 1);
2450     if (ma == read_ma) {
2451       return i;
2452     }
2453   }
2454
2455   return -1;
2456 }
2457
2458 int BKE_gpencil_object_material_index_get_by_name(Object *ob, const char *name)
2459 {
2460   short *totcol = BKE_object_material_len_p(ob);
2461   Material *read_ma = NULL;
2462   for (short i = 0; i < *totcol; i++) {
2463     read_ma = BKE_object_material_get(ob, i + 1);
2464     /* Material names are like "MAMaterial.001" */
2465     if (STREQ(name, &read_ma->id.name[2])) {
2466       return i;
2467     }
2468   }
2469
2470   return -1;
2471 }
2472
2473 Material *BKE_gpencil_object_material_ensure_by_name(Main *bmain,
2474                                                      Object *ob,
2475                                                      const char *name,
2476                                                      int *r_index)
2477 {
2478   int index = BKE_gpencil_object_material_index_get_by_name(ob, name);
2479   if (index != -1) {
2480     *r_index = index;
2481     return BKE_object_material_get(ob, index + 1);
2482   }
2483   return BKE_gpencil_object_material_new(bmain, ob, name, r_index);
2484 }
2485
2486 /**
2487  * Create a default palette.
2488  * \param bmain: Main pointer
2489  * \param scene: Scene
2490  */
2491 void BKE_gpencil_palette_ensure(Main *bmain, Scene *scene)
2492 {
2493   const char *hexcol[] = {
2494       "FFFFFF", "F2F2F2", "E6E6E6", "D9D9D9", "CCCCCC", "BFBFBF", "B2B2B2", "A6A6A6", "999999",
2495       "8C8C8C", "808080", "737373", "666666", "595959", "4C4C4C", "404040", "333333", "262626",
2496       "1A1A1A", "000000", "F2FC24", "FFEA00", "FEA711", "FE8B68", "FB3B02", "FE3521", "D00000",
2497       "A81F3D", "780422", "2B0000", "F1E2C5", "FEE4B3", "FEDABB", "FEC28E", "D88F57", "BD6340",
2498       "A2402B", "63352D", "6B2833", "34120C", "E7CB8F", "D1B38B", "C1B17F", "D7980B", "FFB100",
2499       "FE8B00", "FF6A00", "B74100", "5F3E1D", "3B2300", "FECADA", "FE65CB", "FE1392", "DD3062",
2500       "C04A6D", "891688", "4D2689", "441521", "2C1139", "241422", "FFFF7D", "FFFF00", "FF7F00",
2501       "FF7D7D", "FF7DFF", "FF00FE", "FF007F", "FF0000", "7F0000", "0A0A00", "F6FDFF", "E9F7FF",
2502       "CFE6FE", "AAC7FE", "77B3FE", "1E74FD", "0046AA", "2F4476", "003052", "0E0E25", "EEF5F0",
2503       "D6E5DE", "ACD8B9", "6CADC6", "42A9AF", "007F7F", "49675C", "2E4E4E", "1D3239", "0F1C21",
2504       "D8FFF4", "B8F4F5", "AECCB5", "76C578", "358757", "409B68", "468768", "1F512B", "2A3C37",
2505       "122E1D", "EFFFC9", "E6F385", "BCF51C", "D4DC18", "82D322", "5C7F00", "59932B", "297F00",
2506       "004320", "1C3322", "00FF7F", "00FF00", "7DFF7D", "7DFFFF", "00FFFF", "7D7DFF", "7F00FF",
2507       "0000FF", "3F007F", "00007F"};
2508
2509   ToolSettings *ts = scene->toolsettings;
2510   if (ts->gp_paint->paint.palette != NULL) {
2511     return;
2512   }
2513
2514   /* Try to find the default palette. */
2515   const char *palette_id = "Palette";
2516   struct Palette *palette = BLI_findstring(&bmain->palettes, palette_id, offsetof(ID, name) + 2);
2517
2518   if (palette == NULL) {
2519     /* Fall back to the first palette. */
2520     palette = bmain->palettes.first;
2521   }
2522
2523   if (palette == NULL) {
2524     /* Fall back to creating a palette. */
2525     palette = BKE_palette_add(bmain, palette_id);
2526     id_us_min(&palette->id);
2527
2528     /* Create Colors. */
2529     for (int i = 0; i < ARRAY_SIZE(hexcol); i++) {
2530       PaletteColor *palcol = BKE_palette_color_add(palette);
2531       hex_to_rgb(hexcol[i], palcol->rgb, palcol->rgb + 1, palcol->rgb + 2);
2532     }
2533   }
2534
2535   BLI_assert(palette != NULL);
2536   BKE_paint_palette_set(&ts->gp_paint->paint, palette);
2537   BKE_paint_palette_set(&ts->gp_vertexpaint->paint, palette);
2538 }
2539
2540 /**
2541  * Create grease pencil strokes from image
2542  * \param sima: Image
2543  * \param gpd: Grease pencil data-block
2544  * \param gpf: Grease pencil frame
2545  * \param size: Size
2546  * \param mask: Mask
2547  * \return  True if done
2548  */
2549 bool BKE_gpencil_from_image(
2550     SpaceImage *sima, bGPdata *gpd, bGPDframe *gpf, const float size, const bool mask)
2551 {
2552   Image *image = sima->image;
2553   bool done = false;
2554
2555   if (image == NULL) {
2556     return false;
2557   }
2558
2559   ImageUser iuser = sima->iuser;
2560   void *lock;
2561   ImBuf *ibuf;
2562
2563   ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
2564
2565   if (ibuf && ibuf->rect) {
2566     int img_x = ibuf->x;
2567     int img_y = ibuf->y;
2568
2569     float color[4];
2570     bGPDspoint *pt;
2571     for (int row = 0; row < img_y; row++) {
2572       /* Create new stroke */
2573       bGPDstroke *gps = BKE_gpencil_stroke_add(gpf, 0, img_x, size * 1000, false);
2574       done = true;
2575       for (int col = 0; col < img_x; col++) {
2576         IMB_sampleImageAtLocation(ibuf, col, row, true, color);
2577         pt = &gps->points[col];
2578         pt->pressure = 1.0f;
2579         pt->x = col * size;
2580         pt->z = row * size;
2581         if (!mask) {
2582           copy_v3_v3(pt->vert_color, color);
2583           pt->vert_color[3] = 1.0f;
2584           pt->strength = color[3];
2585         }
2586         else {
2587           zero_v3(pt->vert_color);
2588           pt->vert_color[3] = 1.0f;
2589           pt->strength = 1.0f - color[3];
2590         }
2591
2592         /* Selet Alpha points. */
2593         if (pt->strength < 0.03f) {
2594           gps->flag |= GP_STROKE_SELECT;
2595           pt->flag |= GP_SPOINT_SELECT;
2596         }
2597       }
2598
2599       if (gps->flag & GP_STROKE_SELECT) {
2600         BKE_gpencil_stroke_select_index_set(gpd, gps);
2601       }
2602
2603       BKE_gpencil_stroke_geometry_update(gpd, gps);
2604     }
2605   }
2606
2607   /* Free memory. */
2608   BKE_image_release_ibuf(image, ibuf, lock);
2609
2610   return done;
2611 }
2612
2613 /**
2614  * Helper to check if a layers is used as mask
2615  * \param view_layer: Actual view layer.
2616  * \param gpd: Grease pencil data-block.
2617  * \param gpl_mask: Actual Layer.
2618  * \return True if the layer is used as mask.
2619  */
2620 static bool gpencil_is_layer_mask(ViewLayer *view_layer, bGPdata *gpd, bGPDlayer *gpl_mask)
2621 {
2622   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2623     if ((gpl->viewlayername[0] != '\0') && (!STREQ(view_layer->name, gpl->viewlayername))) {
2624       continue;
2625     }
2626
2627     LISTBASE_FOREACH (bGPDlayer_Mask *, mask, &gpl->mask_layers) {
2628       if (STREQ(gpl_mask->info, mask->name)) {
2629         return true;
2630       }
2631     }
2632   }
2633
2634   return false;
2635 }
2636
2637 /* -------------------------------------------------------------------- */
2638 /** \name Iterators
2639  *
2640  * Iterate over all visible stroke of all visible layers inside a gpObject.
2641  * Also take into account onion-skinning.
2642  * \{ */
2643
2644 void BKE_gpencil_visible_stroke_iter(ViewLayer *view_layer,
2645                                      Object *ob,
2646                                      gpIterCb layer_cb,
2647                                      gpIterCb stroke_cb,
2648                                      void *thunk,
2649                                      bool do_onion,
2650                                      int cfra)
2651 {
2652   bGPdata *gpd = (bGPdata *)ob->data;
2653   const bool is_multiedit = ((GPENCIL_MULTIEDIT_SESSIONS_ON(gpd)) && (!GPENCIL_PLAY_ON(gpd)));
2654   const bool is_onion = do_onion && ((gpd->flag & GP_DATA_STROKE_WEIGHTMODE) == 0);
2655   const bool is_drawing = (gpd->runtime.sbuffer_used > 0);
2656
2657   /* Onion skinning. */
2658   const bool onion_mode_abs = (gpd->onion_mode == GP_ONION_MODE_ABSOLUTE);
2659   const bool onion_mode_sel = (gpd->onion_mode == GP_ONION_MODE_SELECTED);
2660   const bool onion_loop = (gpd->onion_flag & GP_ONION_LOOP) != 0;
2661   const short onion_keytype = gpd->onion_keytype;
2662
2663   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2664     /* Reset by layer. */
2665     bool is_before_first = false;
2666
2667     bGPDframe *act_gpf = gpl->actframe;
2668     bGPDframe *sta_gpf = act_gpf;
2669     bGPDframe *end_gpf = act_gpf ? act_gpf->next : NULL;
2670     float prev_opacity = gpl->opacity;
2671
2672     if (gpl->flag & GP_LAYER_HIDE) {
2673       continue;
2674     }
2675
2676     /* If scale to 0 the layer must be invisible. */
2677     if (is_zero_v3(gpl->scale)) {
2678       continue;
2679     }
2680
2681     /* Hide the layer if it's defined a view layer filter. This is used to
2682      * generate renders, putting only selected GP layers for each View Layer.
2683      * This is used only in final render and never in Viewport. */
2684     if ((view_layer != NULL) && (gpl->viewlayername[0] != '\0') &&
2685         (!STREQ(view_layer->name, gpl->viewlayername))) {
2686       /* Do not skip masks when rendering the viewlayer so that it can still be used to clip
2687        * other layers. Instead set their opacity to zero. */
2688       if (gpencil_is_layer_mask(view_layer, gpd, gpl)) {
2689         gpl->opacity = 0.0f;
2690       }
2691       else {
2692         continue;
2693       }
2694     }
2695
2696     if (is_multiedit) {
2697       sta_gpf = end_gpf = NULL;
2698       /* Check the whole range and tag the editable frames. */
2699       LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2700         if (act_gpf != NULL && (gpf == act_gpf || (gpf->flag & GP_FRAME_SELECT))) {
2701           gpf->runtime.onion_id = 0;
2702           if (do_onion) {
2703             if (gpf->framenum < act_gpf->framenum) {
2704               gpf->runtime.onion_id = -1;
2705             }
2706             else {
2707               gpf->runtime.onion_id = 1;
2708             }
2709           }
2710
2711           if (sta_gpf == NULL) {
2712             sta_gpf = gpf;
2713           }
2714           end_gpf = gpf->next;
2715         }
2716         else {
2717           gpf->runtime.onion_id = INT_MAX;
2718         }
2719       }
2720     }
2721     else if (is_onion && (gpl->onion_flag & GP_LAYER_ONIONSKIN)) {
2722       /* Special cases when cframe is before first frame. */
2723       bGPDframe *gpf_first = gpl->frames.first;
2724       if ((gpf_first != NULL) && (act_gpf != NULL) && (gpf_first->framenum > act_gpf->framenum)) {
2725         is_before_first = true;
2726       }
2727       if ((gpf_first != NULL) && (act_gpf == NULL)) {
2728         act_gpf = gpf_first;
2729         is_before_first = true;
2730       }
2731
2732       if (act_gpf) {
2733         bGPDframe *last_gpf = gpl->frames.last;
2734
2735         int frame_len = 0;
2736         LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2737           gpf->runtime.frameid = frame_len++;
2738         }
2739
2740         LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
2741           bool is_wrong_keytype = (onion_keytype > -1) && (gpf->key_type != onion_keytype);
2742           bool is_in_range;
2743           int delta = (onion_mode_abs) ? (gpf->framenum - cfra) :
2744                                          (gpf->runtime.frameid - act_gpf->runtime.frameid);
2745
2746           if (is_before_first) {
2747             delta++;
2748           }
2749
2750           if (onion_mode_sel) {
2751             is_in_range = (gpf->flag & GP_FRAME_SELECT) != 0;
2752           }
2753           else {
2754             is_in_range = (-delta <= gpd->gstep) && (delta <= gpd->gstep_next);
2755
2756             if (onion_loop && !is_in_range) {
2757               /* We wrap the value using the last frame and 0 as reference. */
2758               /* FIXME: This might not be good for animations not starting at 0. */
2759               int shift = (onion_mode_abs) ? last_gpf->framenum : last_gpf->runtime.frameid;
2760               delta += (delta < 0) ? (shift + 1) : -(shift + 1);
2761               /* Test again with wrapped value. */
2762               is_in_range = (-delta <= gpd->gstep) && (delta <= gpd->gstep_next);
2763             }
2764           }
2765           /* Mask frames that have wrong keytype of are not in range. */
2766           gpf->runtime.onion_id = (is_wrong_keytype || !is_in_range) ? INT_MAX : delta;
2767         }
2768         /* Active frame is always shown. */
2769         if (!is_before_first || is_drawing) {
2770           act_gpf->runtime.onion_id = 0;
2771         }
2772       }
2773
2774       sta_gpf = gpl->frames.first;
2775       end_gpf = NULL;
2776     }
2777     else {
2778       /* Bypass multiedit/onion skinning. */
2779       end_gpf = sta_gpf = NULL;
2780     }
2781
2782     if (sta_gpf == NULL && act_gpf == NULL) {
2783       if (layer_cb) {
2784         layer_cb(gpl, act_gpf, NULL, thunk);
2785       }
2786       gpl->opacity = prev_opacity;
2787       continue;
2788     }
2789
2790     /* Draw multiedit/onion skinning first */
2791     for (bGPDframe *gpf = sta_gpf; gpf && gpf != end_gpf; gpf = gpf->next) {
2792       if ((gpf->runtime.onion_id == INT_MAX || gpf == act_gpf) && (!is_before_first)) {
2793         continue;
2794       }
2795
2796       /* Only do once for frame before first. */
2797       if (is_before_first && gpf == act_gpf) {
2798         is_before_first = false;
2799       }
2800
2801       if (layer_cb) {
2802         layer_cb(gpl, gpf, NULL, thunk);
2803       }
2804
2805       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
2806         if (gps->totpoints == 0) {
2807           continue;
2808         }
2809         stroke_cb(gpl, gpf, gps, thunk);
2810       }
2811     }
2812     /* Draw Active frame on top. */
2813     /* Use evaluated frame (with modifiers for active stroke)/ */
2814     act_gpf = gpl->actframe;
2815     if (act_gpf) {
2816       act_gpf->runtime.onion_id = 0;
2817       if (layer_cb) {
2818         layer_cb(gpl, act_gpf, NULL, thunk);
2819       }
2820
2821       /* If layer solo mode and Paint mode, only keyframes with data are displayed. */
2822       if (GPENCIL_PAINT_MODE(gpd) && (gpl->flag & GP_LAYER_SOLO_MODE) &&
2823           (act_gpf->framenum != cfra)) {
2824         gpl->opacity = prev_opacity;
2825         continue;
2826       }
2827
2828       LISTBASE_FOREACH (bGPDstroke *, gps, &act_gpf->strokes) {
2829         if (gps->totpoints == 0) {
2830           continue;
2831         }
2832         stroke_cb(gpl, act_gpf, gps, thunk);
2833       }
2834     }
2835
2836     /* Restore the opacity in case it was overwritten (used to hide masks in render). */
2837     gpl->opacity = prev_opacity;
2838   }
2839 }
2840
2841 /**
2842  * Update original pointers in evaluated frame.
2843  * \param gpf_orig: Original grease-pencil frame.
2844  * \param gpf_eval: Evaluated grease pencil frame.
2845  */
2846 void BKE_gpencil_frame_original_pointers_update(const struct bGPDframe *gpf_orig,
2847                                                 const struct bGPDframe *gpf_eval)
2848 {
2849   bGPDstroke *gps_eval = gpf_eval->strokes.first;
2850   LISTBASE_FOREACH (bGPDstroke *, gps_orig, &gpf_orig->strokes) {
2851
2852     /* Assign original stroke pointer. */
2853     if (gps_eval != NULL) {
2854       gps_eval->runtime.gps_orig = gps_orig;
2855
2856       /* Assign original point pointer. */
2857       for (int i = 0; i < gps_orig->totpoints; i++) {
2858         if (i > gps_eval->totpoints - 1) {
2859           break;
2860         }
2861         bGPDspoint *pt_orig = &gps_orig->points[i];
2862         bGPDspoint *pt_eval = &gps_eval->points[i];
2863         pt_orig->runtime.pt_orig = NULL;
2864         pt_orig->runtime.idx_orig = i;
2865         pt_eval->runtime.pt_orig = pt_orig;
2866         pt_eval->runtime.idx_orig = i;
2867       }
2868       /* Increase pointer. */
2869       gps_eval = gps_eval->next;
2870     }
2871   }
2872 }
2873
2874 /**
2875  * Update pointers of eval data to original data to keep references.
2876  * \param ob_orig: Original grease pencil object
2877  * \param ob_eval: Evaluated grease pencil object
2878  */
2879 void BKE_gpencil_update_orig_pointers(const Object *ob_orig, const Object *ob_eval)
2880 {
2881   bGPdata *gpd_eval = (bGPdata *)ob_eval->data;
2882   bGPdata *gpd_orig = (bGPdata *)ob_orig->data;
2883
2884   /* Assign pointers to the original stroke and points to the evaluated data. This must
2885    * be done before applying any modifier because at this moment the structure is equals,
2886    * so we can assume the layer index is the same in both data-blocks.
2887    * This data will be used by operators. */
2888
2889   bGPDlayer *gpl_eval = gpd_eval->layers.first;
2890   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd_orig->layers) {
2891     if (gpl_eval != NULL) {
2892       /* Update layer reference pointers. */
2893       gpl_eval->runtime.gpl_orig = (bGPDlayer *)gpl;
2894
2895       bGPDframe *gpf_eval = gpl_eval->frames.first;
2896       LISTBASE_FOREACH (bGPDframe *, gpf_orig, &gpl->frames) {
2897         if (gpf_eval != NULL) {
2898           /* Update frame reference pointers. */
2899           gpf_eval->runtime.gpf_orig = (bGPDframe *)gpf_orig;
2900           BKE_gpencil_frame_original_pointers_update(gpf_orig, gpf_eval);
2901           gpf_eval = gpf_eval->next;
2902         }
2903       }
2904       gpl_eval = gpl_eval->next;
2905     }
2906   }
2907 }
2908
2909 /**
2910  * Get parent matrix, including layer parenting.
2911  * \param depsgraph: Depsgraph
2912  * \param obact: Grease pencil object
2913  * \param gpl: Grease pencil layer
2914  * \param diff_mat: Result parent matrix
2915  */
2916 void BKE_gpencil_layer_transform_matrix_get(const Depsgraph *depsgraph,
2917                                             Object *obact,
2918                                             bGPDlayer *gpl,
2919                                             float diff_mat[4][4])
2920 {
2921   Object *ob_eval = depsgraph != NULL ? DEG_get_evaluated_object(depsgraph, obact) : obact;
2922   Object *obparent = gpl->parent;
2923   Object *obparent_eval = depsgraph != NULL ? DEG_get_evaluated_object(depsgraph, obparent) :
2924                                               obparent;
2925
2926   /* if not layer parented, try with object parented */
2927   if (obparent_eval == NULL) {
2928     if ((ob_eval != NULL) && (ob_eval->type == OB_GPENCIL)) {
2929       copy_m4_m4(diff_mat, ob_eval->obmat);
2930       mul_m4_m4m4(diff_mat, diff_mat, gpl->layer_mat);
2931       return;
2932     }
2933     /* not gpencil object */
2934     unit_m4(diff_mat);
2935     return;
2936   }
2937
2938   if (ELEM(gpl->partype, PAROBJECT, PARSKEL)) {
2939     mul_m4_m4m4(diff_mat, obparent_eval->obmat, gpl->inverse);
2940     add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
2941     mul_m4_m4m4(diff_mat, diff_mat, gpl->layer_mat);
2942     return;
2943   }
2944   if (gpl->partype == PARBONE) {
2945     bPoseChannel *pchan = BKE_pose_channel_find_name(obparent_eval->pose, gpl->parsubstr);
2946     if (pchan) {
2947       float tmp_mat[4][4];
2948       mul_m4_m4m4(tmp_mat, obparent_eval->obmat, pchan->pose_mat);
2949       mul_m4_m4m4(diff_mat, tmp_mat, gpl->inverse);
2950       add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
2951     }
2952     else {
2953       /* if bone not found use object (armature) */
2954       mul_m4_m4m4(diff_mat, obparent_eval->obmat, gpl->inverse);
2955       add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
2956     }
2957     mul_m4_m4m4(diff_mat, diff_mat, gpl->layer_mat);
2958     return;
2959   }
2960
2961   unit_m4(diff_mat); /* not defined type */
2962 }
2963
2964 /**
2965  * Update parent matrix and local transforms.
2966  * \param depsgraph: Depsgraph
2967  * \param ob: Grease pencil object
2968  */
2969 void BKE_gpencil_update_layer_transforms(const Depsgraph *depsgraph, Object *ob)
2970 {
2971   if (ob->type != OB_GPENCIL) {
2972     return;
2973   }
2974
2975   bGPdata *gpd = (bGPdata *)ob->data;
2976   float cur_mat[4][4];
2977
2978   bool changed = false;
2979   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2980     unit_m4(cur_mat);
2981     if (gpl->actframe != NULL) {
2982       if (gpl->parent != NULL) {
2983         Object *ob_parent = DEG_get_evaluated_object(depsgraph, gpl->parent);
2984         /* calculate new matrix */
2985         if (ELEM(gpl->partype, PAROBJECT, PARSKEL)) {
2986           copy_m4_m4(cur_mat, ob_parent->obmat);
2987         }
2988         else if (gpl->partype == PARBONE) {
2989           bPoseChannel *pchan = BKE_pose_channel_find_name(ob_parent->pose, gpl->parsubstr);
2990           if (pchan != NULL) {
2991             copy_m4_m4(cur_mat, ob->imat);
2992             mul_m4_m4m4(cur_mat, ob_parent->obmat, pchan->pose_mat);
2993           }
2994           else {
2995             unit_m4(cur_mat);
2996           }
2997         }
2998         changed = !equals_m4m4(gpl->inverse, cur_mat);
2999       }
3000
3001       /* Calc local layer transform. */
3002       bool transformed = ((!is_zero_v3(gpl->location)) || (!is_zero_v3(gpl->rotation)) ||
3003                           (!is_one_v3(gpl->scale)));
3004       if (transformed) {
3005         loc_eul_size_to_mat4(gpl->layer_mat, gpl->location, gpl->rotation, gpl->scale);
3006       }
3007
3008       /* only redo if any change */
3009       if (changed || transformed) {
3010         LISTBASE_FOREACH (bGPDstroke *, gps, &gpl->actframe->strokes) {
3011           bGPDspoint *pt;
3012           int i;
3013           for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
3014             if (changed) {
3015               mul_m4_v3(gpl->inverse, &pt->x);
3016               mul_m4_v3(cur_mat, &pt->x);
3017             }
3018
3019             if (transformed) {
3020               mul_m4_v3(gpl->layer_mat, &pt->x);
3021             }
3022           }
3023         }
3024       }
3025     }
3026   }
3027 }
3028
3029 /**
3030  * Find material by name prefix.
3031  * \param ob: Object pointer
3032  * \param name_prefix: Prefix name of the material
3033  * \return  Index
3034  */
3035 int BKE_gpencil_material_find_index_by_name_prefix(Object *ob, const char *name_prefix)
3036 {
3037   const int name_prefix_len = strlen(name_prefix);
3038   for (int i = 0; i < ob->totcol; i++) {
3039     Material *ma = BKE_object_material_get(ob, i + 1);
3040     if ((ma != NULL) && (ma->gp_style != NULL) &&
3041         (STREQLEN(ma->id.name + 2, name_prefix, name_prefix_len))) {
3042       return i;
3043     }
3044   }
3045
3046   return -1;
3047 }
3048
3049 /* Create a hash with the list of selected frame number. */
3050 void BKE_gpencil_frame_selected_hash(bGPdata *gpd, struct GHash *r_list)
3051 {
3052   const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
3053   bGPDlayer *gpl = BKE_gpencil_layer_active_get(gpd);
3054
3055   LISTBASE_FOREACH (bGPDlayer *, gpl_iter, &gpd->layers) {
3056     if ((gpl != NULL) && (!is_multiedit) && (gpl != gpl_iter)) {
3057       continue;
3058     }
3059
3060     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl_iter->frames) {
3061       if (((gpf == gpl->actframe) && (!is_multiedit)) ||
3062           ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
3063         if (!BLI_ghash_lookup(r_list, POINTER_FROM_INT(gpf->framenum))) {
3064           BLI_ghash_insert(r_list, POINTER_FROM_INT(gpf->framenum), gpf);
3065         }
3066       }
3067     }
3068   }
3069 }
3070
3071 /** \} */