Grease Pencil v2 Branch
[blender-staging.git] / source / blender / blenkernel / intern / gpencil.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2008, Blender Foundation
19  * This is a new part of Blender
20  *
21  * Contributor(s): Joshua Leung, Antonio Vazquez
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/blenkernel/intern/gpencil.c
27  *  \ingroup bke
28  */
29
30  
31 #include <stdio.h>
32 #include <string.h>
33 #include <stdlib.h>
34 #include <stddef.h>
35 #include <math.h>
36
37 #include "MEM_guardedalloc.h"
38
39 #include "BLI_blenlib.h"
40 #include "BLI_utildefines.h"
41 #include "BLI_math_vector.h"
42
43 #include "BLT_translation.h"
44
45 #include "DNA_gpencil_types.h"
46 #include "DNA_userdef_types.h"
47 #include "DNA_scene_types.h"
48
49 #include "BKE_animsys.h"
50 #include "BKE_global.h"
51 #include "BKE_gpencil.h"
52 #include "BKE_colortools.h"
53 #include "BKE_library.h"
54 #include "BKE_main.h"
55
56
57 /* ************************************************** */
58 /* GENERAL STUFF */
59
60 /* --------- Memory Management ------------ */
61
62 /* free stroke, doesn't unlink from any listbase */
63 void free_gpencil_stroke(bGPDstroke *gps)
64 {
65         if (gps == NULL) {
66                 return;
67         }
68
69         /* free stroke memory arrays, then stroke itself */
70         if (gps->points)
71                 MEM_freeN(gps->points);
72         if (gps->triangles)
73                 MEM_freeN(gps->triangles);
74
75         MEM_freeN(gps);
76 }
77
78 /* Free strokes belonging to a gp-frame */
79 bool free_gpencil_strokes(bGPDframe *gpf)
80 {
81         bGPDstroke *gps_next;
82         bool changed = (BLI_listbase_is_empty(&gpf->strokes) == false);
83
84         /* free strokes */
85         for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps_next) {
86                 gps_next = gps->next;
87                 free_gpencil_stroke(gps);
88         }
89         BLI_listbase_clear(&gpf->strokes);
90
91         return changed;
92 }
93
94 /* Free all of a gp-layer's frames */
95 void free_gpencil_frames(bGPDlayer *gpl)
96 {
97         bGPDframe *gpf_next;
98         
99         /* error checking */
100         if (gpl == NULL) return;
101         
102         /* free frames */
103         for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf_next) {
104                 gpf_next = gpf->next;
105                 
106                 /* free strokes and their associated memory */
107                 free_gpencil_strokes(gpf);
108                 BLI_freelinkN(&gpl->frames, gpf);
109         }
110         gpl->actframe = NULL;
111 }
112
113 /* Free all of a gp-colors */
114 static void free_gpencil_colors(bGPDpalette *palette)
115 {
116         /* error checking */
117         if (palette == NULL) {
118                 return;
119         }
120
121         /* free colors */
122         BLI_freelistN(&palette->colors);
123 }
124
125 /* Free all of the gp-palettes and colors */
126 void free_gpencil_palettes(ListBase *list)
127 {
128         bGPDpalette *palette_next;
129
130         /* error checking */
131         if (list == NULL) {
132                 return;
133         }
134
135         /* delete palettes */
136         for (bGPDpalette *palette = list->first; palette; palette = palette_next) {
137                 palette_next = palette->next;
138                 /* free palette colors */
139                 free_gpencil_colors(palette);
140
141                 MEM_freeN(palette);
142         }
143         BLI_listbase_clear(list);
144 }
145
146 /* Free all of the gp-brushes for a viewport (list should be &gpd->brushes or so) */
147 void free_gpencil_brushes(ListBase *list)
148 {
149         bGPDbrush *brush_next;
150
151         /* error checking */
152         if (list == NULL) {
153                 return;
154         }
155
156         /* delete brushes */
157         for (bGPDbrush *brush = list->first; brush; brush = brush_next) {
158                 brush_next = brush->next;
159                 /* free curves */
160                 if (brush->cur_sensitivity) {
161                         curvemapping_free(brush->cur_sensitivity);
162                 }
163                 if (brush->cur_strength) {
164                         curvemapping_free(brush->cur_strength);
165                 }
166                 if (brush->cur_jitter) {
167                         curvemapping_free(brush->cur_jitter);
168                 }
169
170                 MEM_freeN(brush);
171         }
172         BLI_listbase_clear(list);
173 }
174
175 /* Free all of the gp-layers for a viewport (list should be &gpd->layers or so) */
176 void free_gpencil_layers(ListBase *list)
177 {
178         bGPDlayer *gpl_next;
179         
180         /* error checking */
181         if (list == NULL) return;
182         
183         /* delete layers */
184         for (bGPDlayer *gpl = list->first; gpl; gpl = gpl_next) {
185                 gpl_next = gpl->next;
186                 
187                 /* free layers and their data */
188                 free_gpencil_frames(gpl);
189                 BLI_freelinkN(list, gpl);
190         }
191 }
192
193 /** Free (or release) any data used by this grease pencil (does not free the gpencil itself). */
194 void BKE_gpencil_free(bGPdata *gpd, bool free_palettes)
195 {
196         BKE_animdata_free(&gpd->id, false);
197
198         /* free layers */
199         free_gpencil_layers(&gpd->layers);
200
201         /* free palettes */
202         if (free_palettes) {
203                 free_gpencil_palettes(&gpd->palettes);
204         }
205 }
206
207 /* -------- Container Creation ---------- */
208
209 /* add a new gp-frame to the given layer */
210 bGPDframe *gpencil_frame_addnew(bGPDlayer *gpl, int cframe)
211 {
212         bGPDframe *gpf = NULL, *gf = NULL;
213         short state = 0;
214         
215         /* error checking */
216         if (gpl == NULL)
217                 return NULL;
218                 
219         /* allocate memory for this frame */
220         gpf = MEM_callocN(sizeof(bGPDframe), "bGPDframe");
221         gpf->framenum = cframe;
222         
223         /* find appropriate place to add frame */
224         if (gpl->frames.first) {
225                 for (gf = gpl->frames.first; gf; gf = gf->next) {
226                         /* check if frame matches one that is supposed to be added */
227                         if (gf->framenum == cframe) {
228                                 state = -1;
229                                 break;
230                         }
231                         
232                         /* if current frame has already exceeded the frame to add, add before */
233                         if (gf->framenum > cframe) {
234                                 BLI_insertlinkbefore(&gpl->frames, gf, gpf);
235                                 state = 1;
236                                 break;
237                         }
238                 }
239         }
240         
241         /* check whether frame was added successfully */
242         if (state == -1) {
243                 printf("Error: Frame (%d) existed already for this layer. Using existing frame\n", cframe);
244                 
245                 /* free the newly created one, and use the old one instead */
246                 MEM_freeN(gpf);
247                 
248                 /* return existing frame instead... */
249                 BLI_assert(gf != NULL);
250                 gpf = gf;
251         }
252         else if (state == 0) {
253                 /* add to end then! */
254                 BLI_addtail(&gpl->frames, gpf);
255         }
256         
257         /* return frame */
258         return gpf;
259 }
260
261 /* add a copy of the active gp-frame to the given layer */
262 bGPDframe *gpencil_frame_addcopy(bGPDlayer *gpl, int cframe)
263 {
264         bGPDframe *new_frame;
265         bool found = false;
266         
267         /* Error checking/handling */
268         if (gpl == NULL) {
269                 /* no layer */
270                 return NULL;
271         }
272         else if (gpl->actframe == NULL) {
273                 /* no active frame, so just create a new one from scratch */
274                 return gpencil_frame_addnew(gpl, cframe);
275         }
276         
277         /* Create a copy of the frame */
278         new_frame = gpencil_frame_duplicate(gpl->actframe);
279         
280         /* Find frame to insert it before */
281         for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
282                 if (gpf->framenum > cframe) {
283                         /* Add it here */
284                         BLI_insertlinkbefore(&gpl->frames, gpf, new_frame);
285                         
286                         found = true;
287                         break;
288                 }
289                 else if (gpf->framenum == cframe) {
290                         /* This only happens when we're editing with framelock on...
291                          * - Delete the new frame and don't do anything else here...
292                          */
293                         free_gpencil_strokes(new_frame);
294                         MEM_freeN(new_frame);
295                         new_frame = NULL;
296                         
297                         found = true;
298                         break;
299                 }
300         }
301         
302         if (found == false) {
303                 /* Add new frame to the end */
304                 BLI_addtail(&gpl->frames, new_frame);
305         }
306         
307         /* Ensure that frame is set up correctly, and return it */
308         if (new_frame) {
309                 new_frame->framenum = cframe;
310                 gpl->actframe = new_frame;
311         }
312         
313         return new_frame;
314 }
315
316 /* add a new gp-layer and make it the active layer */
317 bGPDlayer *gpencil_layer_addnew(bGPdata *gpd, const char *name, bool setactive)
318 {
319         bGPDlayer *gpl;
320         
321         /* check that list is ok */
322         if (gpd == NULL)
323                 return NULL;
324                 
325         /* allocate memory for frame and add to end of list */
326         gpl = MEM_callocN(sizeof(bGPDlayer), "bGPDlayer");
327         
328         /* add to datablock */
329         BLI_addtail(&gpd->layers, gpl);
330         
331         /* set basic settings */
332         copy_v4_v4(gpl->color, U.gpencil_new_layer_col);
333         /* Since GPv2 thickness must be 0 */
334         gpl->thickness = 0;
335
336         gpl->opacity = 1.0f;
337
338         /* onion-skinning settings */
339         if (gpd->flag & GP_DATA_SHOW_ONIONSKINS)
340                 gpl->flag |= GP_LAYER_ONIONSKIN;
341         
342         gpl->flag |= (GP_LAYER_GHOST_PREVCOL | GP_LAYER_GHOST_NEXTCOL);
343         
344         ARRAY_SET_ITEMS(gpl->gcolor_prev, 0.145098f, 0.419608f, 0.137255f); /* green */
345         ARRAY_SET_ITEMS(gpl->gcolor_next, 0.125490f, 0.082353f, 0.529412f); /* blue */
346         
347         /* high quality fill by default */
348         gpl->flag |= GP_LAYER_HQ_FILL;
349         
350         /* auto-name */
351         BLI_strncpy(gpl->info, name, sizeof(gpl->info));
352         BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info));
353         
354         /* make this one the active one */
355         if (setactive)
356                 gpencil_layer_setactive(gpd, gpl);
357         
358         /* return layer */
359         return gpl;
360 }
361
362 /* add a new gp-palette and make it the active */
363 bGPDpalette *gpencil_palette_addnew(bGPdata *gpd, const char *name, bool setactive)
364 {
365         bGPDpalette *palette;
366
367         /* check that list is ok */
368         if (gpd == NULL) {
369                 return NULL;
370         }
371
372         /* allocate memory and add to end of list */
373         palette = MEM_callocN(sizeof(bGPDpalette), "bGPDpalette");
374
375         /* add to datablock */
376         BLI_addtail(&gpd->palettes, palette);
377
378         /* set basic settings */
379         /* auto-name */
380         BLI_strncpy(palette->info, name, sizeof(palette->info));
381         BLI_uniquename(&gpd->palettes, palette, DATA_("GP_Palette"), '.', offsetof(bGPDpalette, info),
382                        sizeof(palette->info));
383
384         /* make this one the active one */
385         if (setactive) {
386                 gpencil_palette_setactive(gpd, palette);
387         }
388
389         /* return palette */
390         return palette;
391 }
392
393 /* create a set of default drawing brushes with predefined presets */
394 void gpencil_brush_init_presets(ToolSettings *ts)
395 {
396         bGPDbrush *brush;
397         /* Basic brush */
398         brush = gpencil_brush_addnew(ts, "Basic", true);
399         brush->thickness = 3.0f;
400         brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
401         brush->draw_sensitivity = 1.0f;
402         brush->flag |= GP_BRUSH_USE_PRESSURE;
403
404         brush->flag &= ~GP_BRUSH_USE_RANDOM_STRENGTH;
405         brush->draw_strength = 1.0f;
406         brush->flag |= ~GP_BRUSH_USE_STENGTH_PRESSURE;
407
408         brush->draw_random_press = 0.0f;
409
410         brush->draw_jitter = 0.0f;
411         brush->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
412
413         brush->draw_angle = 0.0f;
414         brush->draw_angle_factor = 0.0f;
415
416         brush->draw_smoothfac = 0.0f;
417         brush->draw_smoothlvl = 1;
418         brush->sublevel = 0;
419         brush->draw_random_sub = 0.0f;
420
421         /* Pencil brush */
422         brush = gpencil_brush_addnew(ts, "Pencil", false);
423         brush->thickness = 7.0f;
424         brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
425         brush->draw_sensitivity = 1.0f;
426         brush->flag |= GP_BRUSH_USE_PRESSURE;
427
428         brush->flag &= ~GP_BRUSH_USE_RANDOM_STRENGTH;
429         brush->draw_strength = 0.7f;
430         brush->flag |= GP_BRUSH_USE_STENGTH_PRESSURE;
431
432         brush->draw_random_press = 0.0f;
433
434         brush->draw_jitter = 0.0f;
435         brush->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
436
437         brush->draw_angle = 0.0f;
438         brush->draw_angle_factor = 0.0f;
439
440         brush->draw_smoothfac = 1.0f;
441         brush->draw_smoothlvl = 2;
442         brush->sublevel = 2;
443         brush->draw_random_sub = 0.0f;
444
445         /* Ink brush */
446         brush = gpencil_brush_addnew(ts, "Ink", false);
447         brush->thickness = 7.0f;
448         brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
449         brush->draw_sensitivity = 1.6f;
450         brush->flag |= GP_BRUSH_USE_PRESSURE;
451
452         brush->flag &= ~GP_BRUSH_USE_RANDOM_STRENGTH;
453         brush->draw_strength = 1.0f;
454         brush->flag &= ~GP_BRUSH_USE_STENGTH_PRESSURE;
455
456         brush->draw_random_press = 0.0f;
457
458         brush->draw_jitter = 0.0f;
459         brush->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
460
461         brush->draw_angle = 0.0f;
462         brush->draw_angle_factor = 0.0f;
463
464         brush->draw_smoothfac = 1.1f;
465         brush->draw_smoothlvl = 2;
466         brush->sublevel = 2;
467         brush->draw_random_sub = 0.0f;
468
469         /* Ink Noise brush */
470         brush = gpencil_brush_addnew(ts, "Ink noise", false);
471         brush->thickness = 6.0f;
472         brush->flag |= GP_BRUSH_USE_RANDOM_PRESSURE;
473         brush->draw_sensitivity = 1.611f;
474         brush->flag |= GP_BRUSH_USE_PRESSURE;
475
476         brush->flag &= ~GP_BRUSH_USE_RANDOM_STRENGTH;
477         brush->draw_strength = 1.0f;
478         brush->flag |= GP_BRUSH_USE_STENGTH_PRESSURE;
479
480         brush->draw_random_press = 1.0f;
481
482         brush->draw_jitter = 0.0f;
483         brush->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
484
485         brush->draw_angle = 0.0f;
486         brush->draw_angle_factor = 0.0f;
487
488         brush->draw_smoothfac = 1.1f;
489         brush->draw_smoothlvl = 2;
490         brush->sublevel = 2;
491         brush->draw_random_sub = 0.0f;
492
493         /* Marker brush */
494         brush = gpencil_brush_addnew(ts, "Marker", false);
495         brush->thickness = 10.0f;
496         brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
497         brush->draw_sensitivity = 2.0f;
498         brush->flag &= ~GP_BRUSH_USE_PRESSURE;
499
500         brush->flag &= ~GP_BRUSH_USE_RANDOM_STRENGTH;
501         brush->draw_strength = 1.0f;
502         brush->flag &= ~GP_BRUSH_USE_STENGTH_PRESSURE;
503
504         brush->draw_random_press = 0.0f;
505
506         brush->draw_jitter = 0.0f;
507         brush->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
508
509         brush->draw_angle = M_PI_4; /* 45 degrees */
510         brush->draw_angle_factor = 1.0f;
511
512         brush->draw_smoothfac = 1.0f;
513         brush->draw_smoothlvl = 2;
514         brush->sublevel = 2;
515         brush->draw_random_sub = 0.0f;
516
517         /* Crayon brush */
518         brush = gpencil_brush_addnew(ts, "Crayon", false);
519         brush->thickness = 10.0f;
520         brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
521         brush->draw_sensitivity = 3.0f;
522         brush->flag &= ~GP_BRUSH_USE_PRESSURE;
523
524         brush->flag &= ~GP_BRUSH_USE_RANDOM_STRENGTH;
525         brush->draw_strength = 0.140f;
526         brush->flag |= GP_BRUSH_USE_STENGTH_PRESSURE;
527
528         brush->draw_random_press = 0.0f;
529
530         brush->draw_jitter = 0.0f;
531         brush->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
532
533         brush->draw_angle = 0.0f;
534         brush->draw_angle_factor = 0.0f;
535
536         brush->draw_smoothfac = 0.0f;
537         brush->draw_smoothlvl = 1;
538         brush->sublevel = 2;
539         brush->draw_random_sub = 0.5f;
540
541 }
542
543 /* add a new gp-brush and make it the active */
544 bGPDbrush *gpencil_brush_addnew(ToolSettings *ts, const char *name, bool setactive)
545 {
546         bGPDbrush *brush;
547
548         /* check that list is ok */
549         if (ts == NULL) {
550                 return NULL;
551         }
552
553         /* allocate memory and add to end of list */
554         brush = MEM_callocN(sizeof(bGPDbrush), "bGPDbrush");
555
556         /* add to datablock */
557         BLI_addtail(&ts->gp_brushes, brush);
558
559         /* set basic settings */
560         brush->thickness = 3;
561         brush->draw_smoothlvl = 1;
562         brush->flag |= GP_BRUSH_USE_PRESSURE;
563         brush->draw_sensitivity = 1.0f;
564         brush->draw_strength = 1.0f;
565         brush->flag |= GP_BRUSH_USE_STENGTH_PRESSURE;
566         brush->draw_jitter = 0.0f;
567         brush->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
568
569         /* curves */
570         brush->cur_sensitivity = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
571         brush->cur_strength = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
572         brush->cur_jitter = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
573
574         /* auto-name */
575         BLI_strncpy(brush->info, name, sizeof(brush->info));
576         BLI_uniquename(&ts->gp_brushes, brush, DATA_("GP_Brush"), '.', offsetof(bGPDbrush, info), sizeof(brush->info));
577
578         /* make this one the active one */
579         if (setactive) {
580                 gpencil_brush_setactive(ts, brush);
581         }
582
583         /* return brush */
584         return brush;
585 }
586
587 /* add a new gp-palettecolor and make it the active */
588 bGPDpalettecolor *gpencil_palettecolor_addnew(bGPDpalette *palette, const char *name, bool setactive)
589 {
590         bGPDpalettecolor *palcolor;
591
592         /* check that list is ok */
593         if (palette == NULL) {
594                 return NULL;
595         }
596
597         /* allocate memory and add to end of list */
598         palcolor = MEM_callocN(sizeof(bGPDpalettecolor), "bGPDpalettecolor");
599
600         /* add to datablock */
601         BLI_addtail(&palette->colors, palcolor);
602
603         /* set basic settings */
604         palcolor->flag |= PC_COLOR_HQ_FILL;
605         copy_v4_v4(palcolor->color, U.gpencil_new_layer_col);
606         ARRAY_SET_ITEMS(palcolor->fill, 1.0f, 1.0f, 1.0f);
607
608         /* auto-name */
609         BLI_strncpy(palcolor->info, name, sizeof(palcolor->info));
610         BLI_uniquename(&palette->colors, palcolor, DATA_("Color"), '.', offsetof(bGPDpalettecolor, info),
611                        sizeof(palcolor->info));
612
613         /* make this one the active one */
614         if (setactive) {
615                 gpencil_palettecolor_setactive(palette, palcolor);
616         }
617
618         /* return palette color */
619         return palcolor;
620 }
621
622 /* add a new gp-datablock */
623 bGPdata *gpencil_data_addnew(const char name[])
624 {
625         bGPdata *gpd;
626         
627         /* allocate memory for a new block */
628         gpd = BKE_libblock_alloc(G.main, ID_GD, name);
629         
630         /* initial settings */
631         gpd->flag = (GP_DATA_DISPINFO | GP_DATA_EXPAND);
632         
633         /* for now, stick to view is also enabled by default
634          * since this is more useful...
635          */
636         gpd->flag |= GP_DATA_VIEWALIGN;
637         
638         return gpd;
639 }
640
641 /* -------- Data Duplication ---------- */
642
643 /* make a copy of a given gpencil frame */
644 bGPDframe *gpencil_frame_duplicate(const bGPDframe *gpf_src)
645 {
646         bGPDstroke *gps_dst;
647         bGPDframe *gpf_dst;
648         
649         /* error checking */
650         if (gpf_src == NULL) {
651                 return NULL;
652         }
653                 
654         /* make a copy of the source frame */
655         gpf_dst = MEM_dupallocN(gpf_src);
656         gpf_dst->prev = gpf_dst->next = NULL;
657         
658         /* copy strokes */
659         BLI_listbase_clear(&gpf_dst->strokes);
660         for (bGPDstroke *gps_src = gpf_src->strokes.first; gps_src; gps_src = gps_src->next) {
661                 /* make copy of source stroke, then adjust pointer to points too */
662                 gps_dst = MEM_dupallocN(gps_src);
663                 gps_dst->points = MEM_dupallocN(gps_src->points);
664                 gps_dst->triangles = MEM_dupallocN(gps_src->triangles);
665                 gps_dst->flag |= GP_STROKE_RECALC_CACHES;
666                 BLI_addtail(&gpf_dst->strokes, gps_dst);
667         }
668         
669         /* return new frame */
670         return gpf_dst;
671 }
672
673 /* make a copy of a given gpencil brush */
674 bGPDbrush *gpencil_brush_duplicate(const bGPDbrush *brush_src)
675 {
676         bGPDbrush *brush_dst;
677
678         /* error checking */
679         if (brush_src == NULL) {
680                 return NULL;
681         }
682
683         /* make a copy of source brush */
684         brush_dst = MEM_dupallocN(brush_src);
685         brush_dst->prev = brush_dst->next = NULL;
686         /* make a copy of curves */
687         brush_dst->cur_sensitivity = curvemapping_copy(brush_src->cur_sensitivity);
688         brush_dst->cur_strength = curvemapping_copy(brush_src->cur_strength);
689         brush_dst->cur_jitter = curvemapping_copy(brush_src->cur_jitter);
690
691         /* return new brush */
692         return brush_dst;
693 }
694
695 /* make a copy of a given gpencil palette */
696 bGPDpalette *gpencil_palette_duplicate(const bGPDpalette *palette_src)
697 {
698         bGPDpalette *palette_dst;
699         const bGPDpalettecolor *palcolor_src;
700         bGPDpalettecolor *palcolord_dst;
701
702         /* error checking */
703         if (palette_src == NULL) {
704                 return NULL;
705         }
706
707         /* make a copy of source palette */
708         palette_dst = MEM_dupallocN(palette_src);
709         palette_dst->prev = palette_dst->next = NULL;
710
711         /* copy colors */
712         BLI_listbase_clear(&palette_dst->colors);
713         for (palcolor_src = palette_src->colors.first; palcolor_src; palcolor_src = palcolor_src->next) {
714                 /* make a copy of source */
715                 palcolord_dst = MEM_dupallocN(palcolor_src);
716                 BLI_addtail(&palette_dst->colors, palcolord_dst);
717         }
718
719         /* return new palette */
720         return palette_dst;
721 }
722 /* make a copy of a given gpencil layer */
723 bGPDlayer *gpencil_layer_duplicate(const bGPDlayer *gpl_src)
724 {
725         const bGPDframe *gpf_src;
726         bGPDframe *gpf_dst;
727         bGPDlayer *gpl_dst;
728         
729         /* error checking */
730         if (gpl_src == NULL) {
731                 return NULL;
732         }
733                 
734         /* make a copy of source layer */
735         gpl_dst = MEM_dupallocN(gpl_src);
736         gpl_dst->prev = gpl_dst->next = NULL;
737         
738         /* copy frames */
739         BLI_listbase_clear(&gpl_dst->frames);
740         for (gpf_src = gpl_src->frames.first; gpf_src; gpf_src = gpf_src->next) {
741                 /* make a copy of source frame */
742                 gpf_dst = gpencil_frame_duplicate(gpf_src);
743                 BLI_addtail(&gpl_dst->frames, gpf_dst);
744                 
745                 /* if source frame was the current layer's 'active' frame, reassign that too */
746                 if (gpf_src == gpl_dst->actframe)
747                         gpl_dst->actframe = gpf_dst;
748         }
749         
750         /* return new layer */
751         return gpl_dst;
752 }
753
754 /* make a copy of a given gpencil datablock */
755 bGPdata *gpencil_data_duplicate(Main *bmain, bGPdata *gpd_src, bool internal_copy)
756 {
757         const bGPDlayer *gpl_src;
758         bGPDlayer *gpl_dst;
759         bGPdata *gpd_dst;
760
761         /* error checking */
762         if (gpd_src == NULL) {
763                 return NULL;
764         }
765         
766         /* make a copy of the base-data */
767         if (internal_copy) {
768                 /* make a straight copy for undo buffers used during stroke drawing */
769                 gpd_dst = MEM_dupallocN(gpd_src);
770         }
771         else {
772                 /* make a copy when others use this */
773                 gpd_dst = BKE_libblock_copy(bmain, &gpd_src->id);
774         }
775         
776         /* copy layers */
777         BLI_listbase_clear(&gpd_dst->layers);
778         for (gpl_src = gpd_src->layers.first; gpl_src; gpl_src = gpl_src->next) {
779                 /* make a copy of source layer and its data */
780                 gpl_dst = gpencil_layer_duplicate(gpl_src);
781                 BLI_addtail(&gpd_dst->layers, gpl_dst);
782         }
783         if (!internal_copy) {
784                 /* copy palettes */
785                 bGPDpalette *palette_src, *palette_dst;
786                 BLI_listbase_clear(&gpd_dst->palettes);
787                 for (palette_src = gpd_src->palettes.first; palette_src; palette_src = palette_src->next) {
788                         palette_dst = gpencil_palette_duplicate(palette_src);
789                         BLI_addtail(&gpd_dst->palettes, palette_dst);
790                 }
791         }
792         
793         /* return new */
794         return gpd_dst;
795 }
796
797 void BKE_gpencil_make_local(Main *bmain, bGPdata *gpd, const bool lib_local)
798 {
799         BKE_id_make_local_generic(bmain, &gpd->id, true, lib_local);
800 }
801
802 /* -------- GP-Stroke API --------- */
803
804 /* ensure selection status of stroke is in sync with its points */
805 void gpencil_stroke_sync_selection(bGPDstroke *gps)
806 {
807         bGPDspoint *pt;
808         int i;
809         
810         /* error checking */
811         if (gps == NULL)
812                 return;
813         
814         /* we'll stop when we find the first selected point,
815          * so initially, we must deselect
816          */
817         gps->flag &= ~GP_STROKE_SELECT;
818         
819         for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
820                 if (pt->flag & GP_SPOINT_SELECT) {
821                         gps->flag |= GP_STROKE_SELECT;
822                         break;
823                 }
824         }
825 }
826
827 /* -------- GP-Frame API ---------- */
828
829 /* delete the last stroke of the given frame */
830 void gpencil_frame_delete_laststroke(bGPDlayer *gpl, bGPDframe *gpf)
831 {
832         bGPDstroke *gps = (gpf) ? gpf->strokes.last : NULL;
833         int cfra = (gpf) ? gpf->framenum : 0; /* assume that the current frame was not locked */
834         
835         /* error checking */
836         if (ELEM(NULL, gpf, gps))
837                 return;
838         
839         /* free the stroke and its data */
840         MEM_freeN(gps->points);
841         MEM_freeN(gps->triangles);
842         BLI_freelinkN(&gpf->strokes, gps);
843         
844         /* if frame has no strokes after this, delete it */
845         if (BLI_listbase_is_empty(&gpf->strokes)) {
846                 gpencil_layer_delframe(gpl, gpf);
847                 gpencil_layer_getframe(gpl, cfra, 0);
848         }
849 }
850
851 /* -------- GP-Layer API ---------- */
852
853 /* Check if the given layer is able to be edited or not */
854 bool gpencil_layer_is_editable(const bGPDlayer *gpl)
855 {
856         /* Sanity check */
857         if (gpl == NULL)
858                 return false;
859         
860         /* Layer must be: Visible + Editable */
861         if ((gpl->flag & (GP_LAYER_HIDE | GP_LAYER_LOCKED)) == 0) {
862                 /* Opacity must be sufficiently high that it is still "visible"
863                  * Otherwise, it's not really "visible" to the user, so no point editing...
864                  */
865                 if (gpl->opacity > GPENCIL_ALPHA_OPACITY_THRESH) {
866                         return true;
867                 }
868         }
869         
870         /* Something failed */
871         return false;
872 }
873
874 /* Look up the gp-frame on the requested frame number, but don't add a new one */
875 bGPDframe *BKE_gpencil_layer_find_frame(bGPDlayer *gpl, int cframe)
876 {
877         bGPDframe *gpf;
878         
879         /* Search in reverse order, since this is often used for playback/adding,
880          * where it's less likely that we're interested in the earlier frames
881          */
882         for (gpf = gpl->frames.last; gpf; gpf = gpf->prev) {
883                 if (gpf->framenum == cframe) {
884                         return gpf;
885                 }
886         }
887         
888         return NULL;
889 }
890
891 /* get the appropriate gp-frame from a given layer
892  *      - this sets the layer's actframe var (if allowed to)
893  *      - extension beyond range (if first gp-frame is after all frame in interest and cannot add)
894  */
895 bGPDframe *gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
896 {
897         bGPDframe *gpf = NULL;
898         short found = 0;
899         
900         /* error checking */
901         if (gpl == NULL) return NULL;
902         
903         /* check if there is already an active frame */
904         if (gpl->actframe) {
905                 gpf = gpl->actframe;
906                 
907                 /* do not allow any changes to layer's active frame if layer is locked from changes
908                  * or if the layer has been set to stay on the current frame
909                  */
910                 if (gpl->flag & GP_LAYER_FRAMELOCK)
911                         return gpf;
912                 /* do not allow any changes to actframe if frame has painting tag attached to it */
913                 if (gpf->flag & GP_FRAME_PAINT) 
914                         return gpf;
915                 
916                 /* try to find matching frame */
917                 if (gpf->framenum < cframe) {
918                         for (; gpf; gpf = gpf->next) {
919                                 if (gpf->framenum == cframe) {
920                                         found = 1;
921                                         break;
922                                 }
923                                 else if ((gpf->next) && (gpf->next->framenum > cframe)) {
924                                         found = 1;
925                                         break;
926                                 }
927                         }
928                         
929                         /* set the appropriate frame */
930                         if (addnew) {
931                                 if ((found) && (gpf->framenum == cframe))
932                                         gpl->actframe = gpf;
933                                 else if (addnew == GP_GETFRAME_ADD_COPY)
934                                         gpl->actframe = gpencil_frame_addcopy(gpl, cframe);
935                                 else
936                                         gpl->actframe = gpencil_frame_addnew(gpl, cframe);
937                         }
938                         else if (found)
939                                 gpl->actframe = gpf;
940                         else
941                                 gpl->actframe = gpl->frames.last;
942                 }
943                 else {
944                         for (; gpf; gpf = gpf->prev) {
945                                 if (gpf->framenum <= cframe) {
946                                         found = 1;
947                                         break;
948                                 }
949                         }
950                         
951                         /* set the appropriate frame */
952                         if (addnew) {
953                                 if ((found) && (gpf->framenum == cframe))
954                                         gpl->actframe = gpf;
955                                 else if (addnew == GP_GETFRAME_ADD_COPY)
956                                         gpl->actframe = gpencil_frame_addcopy(gpl, cframe);
957                                 else
958                                         gpl->actframe = gpencil_frame_addnew(gpl, cframe);
959                         }
960                         else if (found)
961                                 gpl->actframe = gpf;
962                         else
963                                 gpl->actframe = gpl->frames.first;
964                 }
965         }
966         else if (gpl->frames.first) {
967                 /* check which of the ends to start checking from */
968                 const int first = ((bGPDframe *)(gpl->frames.first))->framenum;
969                 const int last = ((bGPDframe *)(gpl->frames.last))->framenum;
970                 
971                 if (abs(cframe - first) > abs(cframe - last)) {
972                         /* find gp-frame which is less than or equal to cframe */
973                         for (gpf = gpl->frames.last; gpf; gpf = gpf->prev) {
974                                 if (gpf->framenum <= cframe) {
975                                         found = 1;
976                                         break;
977                                 }
978                         }
979                 }
980                 else {
981                         /* find gp-frame which is less than or equal to cframe */
982                         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
983                                 if (gpf->framenum <= cframe) {
984                                         found = 1;
985                                         break;
986                                 }
987                         }
988                 }
989                 
990                 /* set the appropriate frame */
991                 if (addnew) {
992                         if ((found) && (gpf->framenum == cframe))
993                                 gpl->actframe = gpf;
994                         else
995                                 gpl->actframe = gpencil_frame_addnew(gpl, cframe);
996                 }
997                 else if (found)
998                         gpl->actframe = gpf;
999                 else {
1000                         /* unresolved errogenous situation! */
1001                         printf("Error: cannot find appropriate gp-frame\n");
1002                         /* gpl->actframe should still be NULL */
1003                 }
1004         }
1005         else {
1006                 /* currently no frames (add if allowed to) */
1007                 if (addnew)
1008                         gpl->actframe = gpencil_frame_addnew(gpl, cframe);
1009                 else {
1010                         /* don't do anything... this may be when no frames yet! */
1011                         /* gpl->actframe should still be NULL */
1012                 }
1013         }
1014         
1015         /* return */
1016         return gpl->actframe;
1017 }
1018
1019 /* delete the given frame from a layer */
1020 bool gpencil_layer_delframe(bGPDlayer *gpl, bGPDframe *gpf)
1021 {
1022         bool changed = false;
1023         
1024         /* error checking */
1025         if (ELEM(NULL, gpl, gpf))
1026                 return false;
1027         
1028         /* if this frame was active, make the previous frame active instead 
1029          * since it's tricky to set active frame otherwise
1030          */
1031         if (gpl->actframe == gpf)
1032                 gpl->actframe = gpf->prev;
1033         else
1034                 gpl->actframe = NULL;
1035         
1036         /* free the frame and its data */
1037         changed = free_gpencil_strokes(gpf);
1038         BLI_freelinkN(&gpl->frames, gpf);
1039         
1040         return changed;
1041 }
1042
1043 /* get the active gp-layer for editing */
1044 bGPDlayer *gpencil_layer_getactive(bGPdata *gpd)
1045 {
1046         bGPDlayer *gpl;
1047         
1048         /* error checking */
1049         if (ELEM(NULL, gpd, gpd->layers.first))
1050                 return NULL;
1051                 
1052         /* loop over layers until found (assume only one active) */
1053         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1054                 if (gpl->flag & GP_LAYER_ACTIVE)
1055                         return gpl;
1056         }
1057         
1058         /* no active layer found */
1059         return NULL;
1060 }
1061
1062 /* set the active gp-layer */
1063 void gpencil_layer_setactive(bGPdata *gpd, bGPDlayer *active)
1064 {
1065         bGPDlayer *gpl;
1066         
1067         /* error checking */
1068         if (ELEM(NULL, gpd, gpd->layers.first, active))
1069                 return;
1070                 
1071         /* loop over layers deactivating all */
1072         for (gpl = gpd->layers.first; gpl; gpl = gpl->next)
1073                 gpl->flag &= ~GP_LAYER_ACTIVE;
1074         
1075         /* set as active one */
1076         active->flag |= GP_LAYER_ACTIVE;
1077 }
1078
1079 /* delete the active gp-layer */
1080 void gpencil_layer_delete(bGPdata *gpd, bGPDlayer *gpl)
1081 {
1082         /* error checking */
1083         if (ELEM(NULL, gpd, gpl)) 
1084                 return;
1085         
1086         /* free layer */
1087         free_gpencil_frames(gpl);
1088         BLI_freelinkN(&gpd->layers, gpl);
1089 }
1090
1091 /* ************************************************** */
1092 /* get the active gp-brush for editing */
1093 bGPDbrush *gpencil_brush_getactive(ToolSettings *ts)
1094 {
1095         bGPDbrush *brush;
1096
1097         /* error checking */
1098         if (ELEM(NULL, ts, ts->gp_brushes.first)) {
1099                 return NULL;
1100         }
1101
1102         /* loop over brushes until found (assume only one active) */
1103         for (brush = ts->gp_brushes.first; brush; brush = brush->next) {
1104                 if (brush->flag & GP_BRUSH_ACTIVE) {
1105                         return brush;
1106                 }
1107         }
1108
1109         /* no active brush found */
1110         return NULL;
1111 }
1112
1113 /* set the active gp-brush */
1114 void gpencil_brush_setactive(ToolSettings *ts, bGPDbrush *active)
1115 {
1116         bGPDbrush *brush;
1117
1118         /* error checking */
1119         if (ELEM(NULL, ts, ts->gp_brushes.first, active)) {
1120                 return;
1121         }
1122
1123         /* loop over brushes deactivating all */
1124         for (brush = ts->gp_brushes.first; brush; brush = brush->next) {
1125                 brush->flag &= ~GP_BRUSH_ACTIVE;
1126         }
1127
1128         /* set as active one */
1129         active->flag |= GP_BRUSH_ACTIVE;
1130 }
1131
1132 /* delete the active gp-brush */
1133 void gpencil_brush_delete(ToolSettings *ts, bGPDbrush *brush)
1134 {
1135         /* error checking */
1136         if (ELEM(NULL, ts, brush)) {
1137                 return;
1138         }
1139
1140         /* free curves */
1141         if (brush->cur_sensitivity) {
1142                 curvemapping_free(brush->cur_sensitivity);
1143         }
1144         if (brush->cur_strength) {
1145                 curvemapping_free(brush->cur_strength);
1146         }
1147         if (brush->cur_jitter) {
1148                 curvemapping_free(brush->cur_jitter);
1149         }
1150
1151         /* free */
1152         BLI_freelinkN(&ts->gp_brushes, brush);
1153 }
1154
1155 /* ************************************************** */
1156 /* get the active gp-palette for editing */
1157 bGPDpalette *gpencil_palette_getactive(bGPdata *gpd)
1158 {
1159         bGPDpalette *palette;
1160
1161         /* error checking */
1162         if (ELEM(NULL, gpd, gpd->palettes.first)) {
1163                 return NULL;
1164         }
1165
1166         /* loop over palettes until found (assume only one active) */
1167         for (palette = gpd->palettes.first; palette; palette = palette->next) {
1168                 if (palette->flag & PL_PALETTE_ACTIVE)
1169                         return palette;
1170         }
1171
1172         /* no active palette found */
1173         return NULL;
1174 }
1175
1176 /* set the active gp-palette */
1177 void gpencil_palette_setactive(bGPdata *gpd, bGPDpalette *active)
1178 {
1179         bGPDpalette *palette;
1180
1181         /* error checking */
1182         if (ELEM(NULL, gpd, gpd->palettes.first, active)) {
1183                 return;
1184         }
1185
1186         /* loop over palettes deactivating all */
1187         for (palette = gpd->palettes.first; palette; palette = palette->next) {
1188                 palette->flag &= ~PL_PALETTE_ACTIVE;
1189         }
1190
1191         /* set as active one */
1192         active->flag |= PL_PALETTE_ACTIVE;
1193         /* force color recalc */
1194         gpencil_palette_change_strokes(gpd);
1195 }
1196
1197 /* delete the active gp-palette */
1198 void gpencil_palette_delete(bGPdata *gpd, bGPDpalette *palette)
1199 {
1200         /* error checking */
1201         if (ELEM(NULL, gpd, palette)) {
1202                 return;
1203         }
1204
1205         /* free colors */
1206         free_gpencil_colors(palette);
1207         BLI_freelinkN(&gpd->palettes, palette);
1208         /* force color recalc */
1209         gpencil_palette_change_strokes(gpd);
1210 }
1211
1212 /* Set all strokes to recalc the palette color */
1213 void gpencil_palette_change_strokes(bGPdata *gpd)
1214 {
1215         bGPDlayer *gpl;
1216         bGPDframe *gpf;
1217         bGPDstroke *gps;
1218
1219         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1220                 for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1221                         for (gps = gpf->strokes.first; gps; gps = gps->next) {
1222                                 gps->flag |= GP_STROKE_RECALC_COLOR;
1223                         }
1224                 }
1225         }
1226 }
1227
1228
1229 /* get the active gp-palettecolor for editing */
1230 bGPDpalettecolor *gpencil_palettecolor_getactive(bGPDpalette *palette)
1231 {
1232         bGPDpalettecolor *palcolor;
1233
1234         /* error checking */
1235         if (ELEM(NULL, palette, palette->colors.first)) {
1236                 return NULL;
1237         }
1238
1239         /* loop over colors until found (assume only one active) */
1240         for (palcolor = palette->colors.first; palcolor; palcolor = palcolor->next) {
1241                 if (palcolor->flag & PC_COLOR_ACTIVE) {
1242                         return palcolor;
1243                 }
1244         }
1245
1246         /* no active color found */
1247         return NULL;
1248 }
1249 /* get the gp-palettecolor looking for name */
1250 bGPDpalettecolor *gpencil_palettecolor_getbyname(bGPDpalette *palette, char *name)
1251 {
1252         /* error checking */
1253         if (ELEM(NULL, palette, name)) {
1254                 return NULL;
1255         }
1256
1257         return BLI_findstring(&palette->colors, name, offsetof(bGPDpalettecolor, info));
1258 }
1259
1260 /* Change color name in all strokes */
1261 void gpencil_palettecolor_changename(bGPdata *gpd, char *oldname, const char *newname)
1262 {
1263         bGPDlayer *gpl;
1264         bGPDframe *gpf;
1265         bGPDstroke *gps;
1266
1267         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1268                 for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1269                         for (gps = gpf->strokes.first; gps; gps = gps->next) {
1270                                 if (STREQ(gps->colorname, oldname)) {
1271                                         strcpy(gps->colorname, newname);
1272                                 }
1273                         }
1274                 }
1275         }
1276                 
1277 }
1278
1279 /* Delete all strokes of the color */
1280 void gpencil_palettecolor_delete_strokes(struct bGPdata *gpd, char *name)
1281 {
1282         bGPDlayer *gpl;
1283         bGPDframe *gpf;
1284         bGPDstroke *gps, *gpsn;
1285
1286         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1287                 for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1288                         for (gps = gpf->strokes.first; gps; gps = gpsn) {
1289                                 gpsn = gps->next;
1290
1291                                 if (STREQ(gps->colorname, name)) {
1292                                         if (gps->points) MEM_freeN(gps->points);
1293                                         if (gps->triangles) MEM_freeN(gps->triangles);
1294                                         BLI_freelinkN(&gpf->strokes, gps);
1295                                 }
1296                         }
1297                 }
1298         }
1299
1300 }
1301
1302 /* set the active gp-palettecolor */
1303 void gpencil_palettecolor_setactive(bGPDpalette *palette, bGPDpalettecolor *active)
1304 {
1305         bGPDpalettecolor *palcolor;
1306
1307         /* error checking */
1308         if (ELEM(NULL, palette, palette->colors.first, active)) {
1309                 return;
1310         }
1311
1312         /* loop over colors deactivating all */
1313         for (palcolor = palette->colors.first; palcolor; palcolor = palcolor->next) {
1314                 palcolor->flag &= ~PC_COLOR_ACTIVE;
1315         }
1316
1317         /* set as active one */
1318         active->flag |= PC_COLOR_ACTIVE;
1319 }
1320
1321 /* delete the active gp-palettecolor */
1322 void gpencil_palettecolor_delete(bGPDpalette *palette, bGPDpalettecolor *palcolor)
1323 {
1324         /* error checking */
1325         if (ELEM(NULL, palette, palcolor)) {
1326                 return;
1327         }
1328
1329         /* free */
1330         BLI_freelinkN(&palette->colors, palcolor);
1331 }