8621da0d42e3fa0610408a6be61dae1ec88d3c43
[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
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
48 #include "BKE_animsys.h"
49 #include "BKE_global.h"
50 #include "BKE_gpencil.h"
51 #include "BKE_library.h"
52 #include "BKE_main.h"
53
54
55 /* ************************************************** */
56 /* GENERAL STUFF */
57
58 /* --------- Memory Management ------------ */
59
60 /* Free strokes belonging to a gp-frame */
61 bool free_gpencil_strokes(bGPDframe *gpf)
62 {
63         bGPDstroke *gps, *gpsn;
64         bool changed = (BLI_listbase_is_empty(&gpf->strokes) == false);
65
66         /* free strokes */
67         for (gps = gpf->strokes.first; gps; gps = gpsn) {
68                 gpsn = gps->next;
69                 
70                 /* free stroke memory arrays, then stroke itself */
71                 if (gps->points) MEM_freeN(gps->points);
72                 if (gps->triangles) MEM_freeN(gps->triangles);
73                 BLI_freelinkN(&gpf->strokes, gps);
74         }
75
76         return changed;
77 }
78
79 /* Free all of a gp-layer's frames */
80 void free_gpencil_frames(bGPDlayer *gpl)
81 {
82         bGPDframe *gpf, *gpfn;
83         
84         /* error checking */
85         if (gpl == NULL) return;
86         
87         /* free frames */
88         for (gpf = gpl->frames.first; gpf; gpf = gpfn) {
89                 gpfn = gpf->next;
90                 
91                 /* free strokes and their associated memory */
92                 free_gpencil_strokes(gpf);
93                 BLI_freelinkN(&gpl->frames, gpf);
94         }
95         gpl->actframe = NULL;
96 }
97
98 /* Free all of the gp-layers for a viewport (list should be &gpd->layers or so) */
99 void free_gpencil_layers(ListBase *list)
100 {
101         bGPDlayer *gpl, *gpln;
102         
103         /* error checking */
104         if (list == NULL) return;
105         
106         /* delete layers */
107         for (gpl = list->first; gpl; gpl = gpln) {
108                 gpln = gpl->next;
109                 
110                 /* free layers and their data */
111                 free_gpencil_frames(gpl);
112                 BLI_freelinkN(list, gpl);
113         }
114 }
115
116 /* Free all of GPencil datablock's related data, but not the block itself */
117 /** Free (or release) any data used by this grease pencil (does not free the gpencil itself). */
118 void BKE_gpencil_free(bGPdata *gpd)
119 {
120         BKE_animdata_free(&gpd->id, false);
121
122         /* free layers */
123         free_gpencil_layers(&gpd->layers);
124 }
125
126 /* -------- Container Creation ---------- */
127
128 /* add a new gp-frame to the given layer */
129 bGPDframe *gpencil_frame_addnew(bGPDlayer *gpl, int cframe)
130 {
131         bGPDframe *gpf = NULL, *gf = NULL;
132         short state = 0;
133         
134         /* error checking */
135         if (gpl == NULL)
136                 return NULL;
137                 
138         /* allocate memory for this frame */
139         gpf = MEM_callocN(sizeof(bGPDframe), "bGPDframe");
140         gpf->framenum = cframe;
141         
142         /* find appropriate place to add frame */
143         if (gpl->frames.first) {
144                 for (gf = gpl->frames.first; gf; gf = gf->next) {
145                         /* check if frame matches one that is supposed to be added */
146                         if (gf->framenum == cframe) {
147                                 state = -1;
148                                 break;
149                         }
150                         
151                         /* if current frame has already exceeded the frame to add, add before */
152                         if (gf->framenum > cframe) {
153                                 BLI_insertlinkbefore(&gpl->frames, gf, gpf);
154                                 state = 1;
155                                 break;
156                         }
157                 }
158         }
159         
160         /* check whether frame was added successfully */
161         if (state == -1) {
162                 printf("Error: Frame (%d) existed already for this layer. Using existing frame\n", cframe);
163                 
164                 /* free the newly created one, and use the old one instead */
165                 MEM_freeN(gpf);
166                 
167                 /* return existing frame instead... */
168                 BLI_assert(gf != NULL);
169                 gpf = gf;
170         }
171         else if (state == 0) {
172                 /* add to end then! */
173                 BLI_addtail(&gpl->frames, gpf);
174         }
175         
176         /* return frame */
177         return gpf;
178 }
179
180 /* add a copy of the active gp-frame to the given layer */
181 bGPDframe *gpencil_frame_addcopy(bGPDlayer *gpl, int cframe)
182 {
183         bGPDframe *new_frame, *gpf;
184         bool found = false;
185         
186         /* Error checking/handling */
187         if (gpl == NULL) {
188                 /* no layer */
189                 return NULL;
190         }
191         else if (gpl->actframe == NULL) {
192                 /* no active frame, so just create a new one from scratch */
193                 return gpencil_frame_addnew(gpl, cframe);
194         }
195         
196         /* Create a copy of the frame */
197         new_frame = gpencil_frame_duplicate(gpl->actframe);
198         
199         /* Find frame to insert it before */
200         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
201                 if (gpf->framenum > cframe) {
202                         /* Add it here */
203                         BLI_insertlinkbefore(&gpl->frames, gpf, new_frame);
204                         
205                         found = true;
206                         break;
207                 }
208                 else if (gpf->framenum == cframe) {
209                         /* This only happens when we're editing with framelock on...
210                          * - Delete the new frame and don't do anything else here...
211                          */
212                         free_gpencil_strokes(new_frame);
213                         MEM_freeN(new_frame);
214                         new_frame = NULL;
215                         
216                         found = true;
217                         break;
218                 }
219         }
220         
221         if (found == false) {
222                 /* Add new frame to the end */
223                 BLI_addtail(&gpl->frames, new_frame);
224         }
225         
226         /* Ensure that frame is set up correctly, and return it */
227         if (new_frame) {
228                 new_frame->framenum = cframe;
229                 gpl->actframe = new_frame;
230         }
231         
232         return new_frame;
233 }
234
235 /* add a new gp-layer and make it the active layer */
236 bGPDlayer *gpencil_layer_addnew(bGPdata *gpd, const char *name, bool setactive)
237 {
238         bGPDlayer *gpl;
239         
240         /* check that list is ok */
241         if (gpd == NULL)
242                 return NULL;
243                 
244         /* allocate memory for frame and add to end of list */
245         gpl = MEM_callocN(sizeof(bGPDlayer), "bGPDlayer");
246         
247         /* add to datablock */
248         BLI_addtail(&gpd->layers, gpl);
249         
250         /* set basic settings */
251         copy_v4_v4(gpl->color, U.gpencil_new_layer_col);
252         gpl->thickness = 3;
253         
254         /* onion-skinning settings */
255         if (gpd->flag & GP_DATA_SHOW_ONIONSKINS)
256                 gpl->flag |= GP_LAYER_ONIONSKIN;
257         
258         gpl->flag |= (GP_LAYER_GHOST_PREVCOL | GP_LAYER_GHOST_NEXTCOL);
259         
260         ARRAY_SET_ITEMS(gpl->gcolor_prev, 0.145098f, 0.419608f, 0.137255f); /* green */
261         ARRAY_SET_ITEMS(gpl->gcolor_next, 0.125490f, 0.082353f, 0.529412f); /* blue */
262         
263         /* high quality fill by default */
264         gpl->flag |= GP_LAYER_HQ_FILL;
265         
266         /* default smooth iterations */
267         gpl->draw_smoothlvl = 1;
268         
269         /* auto-name */
270         BLI_strncpy(gpl->info, name, sizeof(gpl->info));
271         BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info));
272         
273         /* make this one the active one */
274         if (setactive)
275                 gpencil_layer_setactive(gpd, gpl);
276         
277         /* return layer */
278         return gpl;
279 }
280
281 /* add a new gp-datablock */
282 bGPdata *gpencil_data_addnew(const char name[])
283 {
284         bGPdata *gpd;
285         
286         /* allocate memory for a new block */
287         gpd = BKE_libblock_alloc(G.main, ID_GD, name);
288         
289         /* initial settings */
290         gpd->flag = (GP_DATA_DISPINFO | GP_DATA_EXPAND);
291         
292         /* for now, stick to view is also enabled by default
293          * since this is more useful...
294          */
295         gpd->flag |= GP_DATA_VIEWALIGN;
296         
297         return gpd;
298 }
299
300 /* -------- Data Duplication ---------- */
301
302 /* make a copy of a given gpencil frame */
303 bGPDframe *gpencil_frame_duplicate(bGPDframe *src)
304 {
305         bGPDstroke *gps, *gpsd;
306         bGPDframe *dst;
307         
308         /* error checking */
309         if (src == NULL)
310                 return NULL;
311                 
312         /* make a copy of the source frame */
313         dst = MEM_dupallocN(src);
314         dst->prev = dst->next = NULL;
315         
316         /* copy strokes */
317         BLI_listbase_clear(&dst->strokes);
318         for (gps = src->strokes.first; gps; gps = gps->next) {
319                 /* make copy of source stroke, then adjust pointer to points too */
320                 gpsd = MEM_dupallocN(gps);
321                 gpsd->points = MEM_dupallocN(gps->points);
322                 gpsd->triangles = MEM_dupallocN(gps->triangles);
323                 gpsd->flag |= GP_STROKE_RECALC_CACHES;
324                 BLI_addtail(&dst->strokes, gpsd);
325         }
326         
327         /* return new frame */
328         return dst;
329 }
330
331 /* make a copy of a given gpencil layer */
332 bGPDlayer *gpencil_layer_duplicate(bGPDlayer *src)
333 {
334         bGPDframe *gpf, *gpfd;
335         bGPDlayer *dst;
336         
337         /* error checking */
338         if (src == NULL)
339                 return NULL;
340                 
341         /* make a copy of source layer */
342         dst = MEM_dupallocN(src);
343         dst->prev = dst->next = NULL;
344         
345         /* copy frames */
346         BLI_listbase_clear(&dst->frames);
347         for (gpf = src->frames.first; gpf; gpf = gpf->next) {
348                 /* make a copy of source frame */
349                 gpfd = gpencil_frame_duplicate(gpf);
350                 BLI_addtail(&dst->frames, gpfd);
351                 
352                 /* if source frame was the current layer's 'active' frame, reassign that too */
353                 if (gpf == dst->actframe)
354                         dst->actframe = gpfd;
355         }
356         
357         /* return new layer */
358         return dst;
359 }
360
361 /* make a copy of a given gpencil datablock */
362 bGPdata *gpencil_data_duplicate(Main *bmain, bGPdata *src, bool internal_copy)
363 {
364         bGPDlayer *gpl, *gpld;
365         bGPdata *dst;
366         
367         /* error checking */
368         if (src == NULL)
369                 return NULL;
370         
371         /* make a copy of the base-data */
372         if (internal_copy) {
373                 /* make a straight copy for undo buffers used during stroke drawing */
374                 dst = MEM_dupallocN(src);
375         }
376         else {
377                 /* make a copy when others use this */
378                 dst = BKE_libblock_copy(bmain, &src->id);
379         }
380         
381         /* copy layers */
382         BLI_listbase_clear(&dst->layers);
383         for (gpl = src->layers.first; gpl; gpl = gpl->next) {
384                 /* make a copy of source layer and its data */
385                 gpld = gpencil_layer_duplicate(gpl);
386                 BLI_addtail(&dst->layers, gpld);
387         }
388         
389         /* return new */
390         return dst;
391 }
392
393 void BKE_gpencil_make_local(Main *bmain, bGPdata *gpd, const bool lib_local)
394 {
395         BKE_id_make_local_generic(bmain, &gpd->id, true, lib_local);
396 }
397
398 /* -------- GP-Stroke API --------- */
399
400 /* ensure selection status of stroke is in sync with its points */
401 void gpencil_stroke_sync_selection(bGPDstroke *gps)
402 {
403         bGPDspoint *pt;
404         int i;
405         
406         /* error checking */
407         if (gps == NULL)
408                 return;
409         
410         /* we'll stop when we find the first selected point,
411          * so initially, we must deselect
412          */
413         gps->flag &= ~GP_STROKE_SELECT;
414         
415         for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
416                 if (pt->flag & GP_SPOINT_SELECT) {
417                         gps->flag |= GP_STROKE_SELECT;
418                         break;
419                 }
420         }
421 }
422
423 /* -------- GP-Frame API ---------- */
424
425 /* delete the last stroke of the given frame */
426 void gpencil_frame_delete_laststroke(bGPDlayer *gpl, bGPDframe *gpf)
427 {
428         bGPDstroke *gps = (gpf) ? gpf->strokes.last : NULL;
429         int cfra = (gpf) ? gpf->framenum : 0; /* assume that the current frame was not locked */
430         
431         /* error checking */
432         if (ELEM(NULL, gpf, gps))
433                 return;
434         
435         /* free the stroke and its data */
436         MEM_freeN(gps->points);
437         MEM_freeN(gps->triangles);
438         BLI_freelinkN(&gpf->strokes, gps);
439         
440         /* if frame has no strokes after this, delete it */
441         if (BLI_listbase_is_empty(&gpf->strokes)) {
442                 gpencil_layer_delframe(gpl, gpf);
443                 gpencil_layer_getframe(gpl, cfra, 0);
444         }
445 }
446
447 /* -------- GP-Layer API ---------- */
448
449 /* Check if the given layer is able to be edited or not */
450 bool gpencil_layer_is_editable(const bGPDlayer *gpl)
451 {
452         /* Sanity check */
453         if (gpl == NULL)
454                 return false;
455         
456         /* Layer must be: Visible + Editable */
457         if ((gpl->flag & (GP_LAYER_HIDE | GP_LAYER_LOCKED)) == 0) {
458                 /* Opacity must be sufficiently high that it is still "visible"
459                  * Otherwise, it's not really "visible" to the user, so no point editing...
460                  */
461                 if ((gpl->color[3] > GPENCIL_ALPHA_OPACITY_THRESH) || (gpl->fill[3] > GPENCIL_ALPHA_OPACITY_THRESH)) {
462                         return true;
463                 }
464         }
465         
466         /* Something failed */
467         return false;
468 }
469
470 /* Look up the gp-frame on the requested frame number, but don't add a new one */
471 bGPDframe *BKE_gpencil_layer_find_frame(bGPDlayer *gpl, int cframe)
472 {
473         bGPDframe *gpf;
474         
475         /* Search in reverse order, since this is often used for playback/adding,
476          * where it's less likely that we're interested in the earlier frames
477          */
478         for (gpf = gpl->frames.last; gpf; gpf = gpf->prev) {
479                 if (gpf->framenum == cframe) {
480                         return gpf;
481                 }
482         }
483         
484         return NULL;
485 }
486
487 /* get the appropriate gp-frame from a given layer
488  *      - this sets the layer's actframe var (if allowed to)
489  *      - extension beyond range (if first gp-frame is after all frame in interest and cannot add)
490  */
491 bGPDframe *gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
492 {
493         bGPDframe *gpf = NULL;
494         short found = 0;
495         
496         /* error checking */
497         if (gpl == NULL) return NULL;
498         
499         /* check if there is already an active frame */
500         if (gpl->actframe) {
501                 gpf = gpl->actframe;
502                 
503                 /* do not allow any changes to layer's active frame if layer is locked from changes
504                  * or if the layer has been set to stay on the current frame
505                  */
506                 if (gpl->flag & GP_LAYER_FRAMELOCK)
507                         return gpf;
508                 /* do not allow any changes to actframe if frame has painting tag attached to it */
509                 if (gpf->flag & GP_FRAME_PAINT) 
510                         return gpf;
511                 
512                 /* try to find matching frame */
513                 if (gpf->framenum < cframe) {
514                         for (; gpf; gpf = gpf->next) {
515                                 if (gpf->framenum == cframe) {
516                                         found = 1;
517                                         break;
518                                 }
519                                 else if ((gpf->next) && (gpf->next->framenum > cframe)) {
520                                         found = 1;
521                                         break;
522                                 }
523                         }
524                         
525                         /* set the appropriate frame */
526                         if (addnew) {
527                                 if ((found) && (gpf->framenum == cframe))
528                                         gpl->actframe = gpf;
529                                 else if (addnew == GP_GETFRAME_ADD_COPY)
530                                         gpl->actframe = gpencil_frame_addcopy(gpl, cframe);
531                                 else
532                                         gpl->actframe = gpencil_frame_addnew(gpl, cframe);
533                         }
534                         else if (found)
535                                 gpl->actframe = gpf;
536                         else
537                                 gpl->actframe = gpl->frames.last;
538                 }
539                 else {
540                         for (; gpf; gpf = gpf->prev) {
541                                 if (gpf->framenum <= cframe) {
542                                         found = 1;
543                                         break;
544                                 }
545                         }
546                         
547                         /* set the appropriate frame */
548                         if (addnew) {
549                                 if ((found) && (gpf->framenum == cframe))
550                                         gpl->actframe = gpf;
551                                 else if (addnew == GP_GETFRAME_ADD_COPY)
552                                         gpl->actframe = gpencil_frame_addcopy(gpl, cframe);
553                                 else
554                                         gpl->actframe = gpencil_frame_addnew(gpl, cframe);
555                         }
556                         else if (found)
557                                 gpl->actframe = gpf;
558                         else
559                                 gpl->actframe = gpl->frames.first;
560                 }
561         }
562         else if (gpl->frames.first) {
563                 /* check which of the ends to start checking from */
564                 const int first = ((bGPDframe *)(gpl->frames.first))->framenum;
565                 const int last = ((bGPDframe *)(gpl->frames.last))->framenum;
566                 
567                 if (abs(cframe - first) > abs(cframe - last)) {
568                         /* find gp-frame which is less than or equal to cframe */
569                         for (gpf = gpl->frames.last; gpf; gpf = gpf->prev) {
570                                 if (gpf->framenum <= cframe) {
571                                         found = 1;
572                                         break;
573                                 }
574                         }
575                 }
576                 else {
577                         /* find gp-frame which is less than or equal to cframe */
578                         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
579                                 if (gpf->framenum <= cframe) {
580                                         found = 1;
581                                         break;
582                                 }
583                         }
584                 }
585                 
586                 /* set the appropriate frame */
587                 if (addnew) {
588                         if ((found) && (gpf->framenum == cframe))
589                                 gpl->actframe = gpf;
590                         else
591                                 gpl->actframe = gpencil_frame_addnew(gpl, cframe);
592                 }
593                 else if (found)
594                         gpl->actframe = gpf;
595                 else {
596                         /* unresolved errogenous situation! */
597                         printf("Error: cannot find appropriate gp-frame\n");
598                         /* gpl->actframe should still be NULL */
599                 }
600         }
601         else {
602                 /* currently no frames (add if allowed to) */
603                 if (addnew)
604                         gpl->actframe = gpencil_frame_addnew(gpl, cframe);
605                 else {
606                         /* don't do anything... this may be when no frames yet! */
607                         /* gpl->actframe should still be NULL */
608                 }
609         }
610         
611         /* return */
612         return gpl->actframe;
613 }
614
615 /* delete the given frame from a layer */
616 bool gpencil_layer_delframe(bGPDlayer *gpl, bGPDframe *gpf)
617 {
618         bool changed = false;
619         
620         /* error checking */
621         if (ELEM(NULL, gpl, gpf))
622                 return false;
623         
624         /* if this frame was active, make the previous frame active instead 
625          * since it's tricky to set active frame otherwise
626          */
627         if (gpl->actframe == gpf)
628                 gpl->actframe = gpf->prev;
629         else
630                 gpl->actframe = NULL;
631         
632         /* free the frame and its data */
633         changed = free_gpencil_strokes(gpf);
634         BLI_freelinkN(&gpl->frames, gpf);
635         
636         return changed;
637 }
638
639 /* get the active gp-layer for editing */
640 bGPDlayer *gpencil_layer_getactive(bGPdata *gpd)
641 {
642         bGPDlayer *gpl;
643         
644         /* error checking */
645         if (ELEM(NULL, gpd, gpd->layers.first))
646                 return NULL;
647                 
648         /* loop over layers until found (assume only one active) */
649         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
650                 if (gpl->flag & GP_LAYER_ACTIVE)
651                         return gpl;
652         }
653         
654         /* no active layer found */
655         return NULL;
656 }
657
658 /* set the active gp-layer */
659 void gpencil_layer_setactive(bGPdata *gpd, bGPDlayer *active)
660 {
661         bGPDlayer *gpl;
662         
663         /* error checking */
664         if (ELEM(NULL, gpd, gpd->layers.first, active))
665                 return;
666                 
667         /* loop over layers deactivating all */
668         for (gpl = gpd->layers.first; gpl; gpl = gpl->next)
669                 gpl->flag &= ~GP_LAYER_ACTIVE;
670         
671         /* set as active one */
672         active->flag |= GP_LAYER_ACTIVE;
673 }
674
675 /* delete the active gp-layer */
676 void gpencil_layer_delete(bGPdata *gpd, bGPDlayer *gpl)
677 {
678         /* error checking */
679         if (ELEM(NULL, gpd, gpl)) 
680                 return;
681         
682         /* free layer */
683         free_gpencil_frames(gpl);
684         BLI_freelinkN(&gpd->layers, gpl);
685 }
686
687 /* ************************************************** */