doxygen: add newline after \file
[blender.git] / source / blender / editors / gpencil / editaction_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 edgpencil
22  */
23
24
25 #include <stdio.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include <stddef.h>
29 #include <math.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "BLI_blenlib.h"
34 #include "BLI_utildefines.h"
35
36 #include "DNA_gpencil_types.h"
37 #include "DNA_scene_types.h"
38
39 #include "BKE_fcurve.h"
40 #include "BKE_gpencil.h"
41 #include "BKE_report.h"
42
43 #include "ED_anim_api.h"
44 #include "ED_gpencil.h"
45 #include "ED_keyframes_edit.h"
46 #include "ED_markers.h"
47
48 #include "WM_api.h"
49
50 /* ***************************************** */
51 /* NOTE ABOUT THIS FILE:
52  * This file contains code for editing Grease Pencil data in the Action Editor
53  * as a 'keyframes', so that a user can adjust the timing of Grease Pencil drawings.
54  * Therefore, this file mostly contains functions for selecting Grease-Pencil frames.
55  */
56 /* ***************************************** */
57 /* Generics - Loopers */
58
59 /* Loops over the gp-frames for a gp-layer, and applies the given callback */
60 bool ED_gplayer_frames_looper(bGPDlayer *gpl, Scene *scene, short (*gpf_cb)(bGPDframe *, Scene *))
61 {
62         bGPDframe *gpf;
63
64         /* error checker */
65         if (gpl == NULL)
66                 return false;
67
68         /* do loop */
69         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
70                 /* execute callback */
71                 if (gpf_cb(gpf, scene))
72                         return true;
73         }
74
75         /* nothing to return */
76         return false;
77 }
78
79 /* ****************************************** */
80 /* Data Conversion Tools */
81
82 /* make a listing all the gp-frames in a layer as cfraelems */
83 void ED_gplayer_make_cfra_list(bGPDlayer *gpl, ListBase *elems, bool onlysel)
84 {
85         bGPDframe *gpf;
86         CfraElem *ce;
87
88         /* error checking */
89         if (ELEM(NULL, gpl, elems))
90                 return;
91
92         /* loop through gp-frames, adding */
93         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
94                 if ((onlysel == 0) || (gpf->flag & GP_FRAME_SELECT)) {
95                         ce = MEM_callocN(sizeof(CfraElem), "CfraElem");
96
97                         ce->cfra = (float)gpf->framenum;
98                         ce->sel = (gpf->flag & GP_FRAME_SELECT) ? 1 : 0;
99
100                         BLI_addtail(elems, ce);
101                 }
102         }
103 }
104
105 /* ***************************************** */
106 /* Selection Tools */
107
108 /* check if one of the frames in this layer is selected */
109 bool ED_gplayer_frame_select_check(bGPDlayer *gpl)
110 {
111         bGPDframe *gpf;
112
113         /* error checking */
114         if (gpl == NULL)
115                 return false;
116
117         /* stop at the first one found */
118         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
119                 if (gpf->flag & GP_FRAME_SELECT)
120                         return true;
121         }
122
123         /* not found */
124         return false;
125 }
126
127 /* helper function - select gp-frame based on SELECT_* mode */
128 static void gpframe_select(bGPDframe *gpf, short select_mode)
129 {
130         if (gpf == NULL)
131                 return;
132
133         switch (select_mode) {
134                 case SELECT_ADD:
135                         gpf->flag |= GP_FRAME_SELECT;
136                         break;
137                 case SELECT_SUBTRACT:
138                         gpf->flag &= ~GP_FRAME_SELECT;
139                         break;
140                 case SELECT_INVERT:
141                         gpf->flag ^= GP_FRAME_SELECT;
142                         break;
143         }
144 }
145
146 /* set all/none/invert select (like above, but with SELECT_* modes) */
147 void ED_gpencil_select_frames(bGPDlayer *gpl, short select_mode)
148 {
149         bGPDframe *gpf;
150
151         /* error checking */
152         if (gpl == NULL)
153                 return;
154
155         /* handle according to mode */
156         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
157                 gpframe_select(gpf, select_mode);
158         }
159 }
160
161 /* set all/none/invert select */
162 void ED_gplayer_frame_select_set(bGPDlayer *gpl, short mode)
163 {
164         /* error checking */
165         if (gpl == NULL)
166                 return;
167
168         /* now call the standard function */
169         ED_gpencil_select_frames(gpl, mode);
170 }
171
172 /* select the frame in this layer that occurs on this frame (there should only be one at most) */
173 void ED_gpencil_select_frame(bGPDlayer *gpl, int selx, short select_mode)
174 {
175         bGPDframe *gpf;
176
177         if (gpl == NULL)
178                 return;
179
180         gpf = BKE_gpencil_layer_find_frame(gpl, selx);
181
182         if (gpf) {
183                 gpframe_select(gpf, select_mode);
184         }
185 }
186
187 /* select the frames in this layer that occur within the bounds specified */
188 void ED_gplayer_frames_select_box(bGPDlayer *gpl, float min, float max, short select_mode)
189 {
190         bGPDframe *gpf;
191
192         if (gpl == NULL)
193                 return;
194
195         /* only select those frames which are in bounds */
196         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
197                 if (IN_RANGE(gpf->framenum, min, max))
198                         gpframe_select(gpf, select_mode);
199         }
200 }
201
202 /* select the frames in this layer that occur within the lasso/circle region specified */
203 void ED_gplayer_frames_select_region(KeyframeEditData *ked, bGPDlayer *gpl, short tool, short select_mode)
204 {
205         bGPDframe *gpf;
206
207         if (gpl == NULL)
208                 return;
209
210         /* only select frames which are within the region */
211         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
212                 /* construct a dummy point coordinate to do this testing with */
213                 float pt[2] = {0};
214
215                 pt[0] = gpf->framenum;
216                 pt[1] = ked->channel_y;
217
218                 /* check the necessary regions */
219                 if (tool == BEZT_OK_CHANNEL_LASSO) {
220                         /* Lasso */
221                         if (keyframe_region_lasso_test(ked->data, pt))
222                                 gpframe_select(gpf, select_mode);
223                 }
224                 else if (tool == BEZT_OK_CHANNEL_CIRCLE) {
225                         /* Circle */
226                         if (keyframe_region_circle_test(ked->data, pt))
227                                 gpframe_select(gpf, select_mode);
228                 }
229         }
230 }
231
232 /* ***************************************** */
233 /* Frame Editing Tools */
234
235 /* Delete selected frames */
236 bool ED_gplayer_frames_delete(bGPDlayer *gpl)
237 {
238         bGPDframe *gpf, *gpfn;
239         bool changed = false;
240
241         /* error checking */
242         if (gpl == NULL)
243                 return false;
244
245         /* check for frames to delete */
246         for (gpf = gpl->frames.first; gpf; gpf = gpfn) {
247                 gpfn = gpf->next;
248
249                 if (gpf->flag & GP_FRAME_SELECT) {
250                         BKE_gpencil_layer_delframe(gpl, gpf);
251                         changed = true;
252                 }
253         }
254
255         return changed;
256 }
257
258 /* Duplicate selected frames from given gp-layer */
259 void ED_gplayer_frames_duplicate(bGPDlayer *gpl)
260 {
261         bGPDframe *gpf, *gpfn;
262
263         /* error checking */
264         if (gpl == NULL)
265                 return;
266
267         /* duplicate selected frames  */
268         for (gpf = gpl->frames.first; gpf; gpf = gpfn) {
269                 gpfn = gpf->next;
270
271                 /* duplicate this frame */
272                 if (gpf->flag & GP_FRAME_SELECT) {
273                         bGPDframe *gpfd;
274
275                         /* duplicate frame, and deselect self */
276                         gpfd = BKE_gpencil_frame_duplicate(gpf);
277                         gpf->flag &= ~GP_FRAME_SELECT;
278
279                         BLI_insertlinkafter(&gpl->frames, gpf, gpfd);
280                 }
281         }
282 }
283
284 /* Set keyframe type for selected frames from given gp-layer
285  * \param type: The type of keyframe (eBezTriple_KeyframeType) to set selected frames to
286  */
287 void ED_gplayer_frames_keytype_set(bGPDlayer *gpl, short type)
288 {
289         bGPDframe *gpf;
290
291         if (gpl == NULL)
292                 return;
293
294         for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
295                 if (gpf->flag & GP_FRAME_SELECT) {
296                         gpf->key_type = type;
297                 }
298         }
299 }
300
301
302 /* -------------------------------------- */
303 /* Copy and Paste Tools */
304 /* - The copy/paste buffer currently stores a set of GP_Layers, with temporary
305  *   GP_Frames with the necessary strokes
306  * - Unless there is only one element in the buffer, names are also tested to check for compatibility.
307  * - All pasted frames are offset by the same amount. This is calculated as the difference in the times of
308  *   the current frame and the 'first keyframe' (i.e. the earliest one in all channels).
309  * - The earliest frame is calculated per copy operation.
310  */
311
312 /* globals for copy/paste data (like for other copy/paste buffers) */
313 static ListBase gp_anim_copybuf = {NULL, NULL};
314 static int gp_anim_copy_firstframe =  999999999;
315 static int gp_anim_copy_lastframe  = -999999999;
316 static int gp_anim_copy_cfra       =  0;
317
318
319 /* This function frees any MEM_calloc'ed copy/paste buffer data */
320 void ED_gpencil_anim_copybuf_free(void)
321 {
322         BKE_gpencil_free_layers(&gp_anim_copybuf);
323         BLI_listbase_clear(&gp_anim_copybuf);
324
325         gp_anim_copy_firstframe =  999999999;
326         gp_anim_copy_lastframe  = -999999999;
327         gp_anim_copy_cfra       =  0;
328 }
329
330
331 /* This function adds data to the copy/paste buffer, freeing existing data first
332  * Only the selected GP-layers get their selected keyframes copied.
333  *
334  * Returns whether the copy operation was successful or not
335  */
336 bool ED_gpencil_anim_copybuf_copy(bAnimContext *ac)
337 {
338         ListBase anim_data = {NULL, NULL};
339         bAnimListElem *ale;
340         int filter;
341
342         Scene *scene = ac->scene;
343
344
345         /* clear buffer first */
346         ED_gpencil_anim_copybuf_free();
347
348         /* filter data */
349         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_NODUPLIS);
350         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
351
352         /* assume that each of these is a GP layer */
353         for (ale = anim_data.first; ale; ale = ale->next) {
354                 ListBase copied_frames = {NULL, NULL};
355                 bGPDlayer *gpl = (bGPDlayer *)ale->data;
356                 bGPDframe *gpf;
357
358                 /* loop over frames, and copy only selected frames */
359                 for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
360                         /* if frame is selected, make duplicate it and its strokes */
361                         if (gpf->flag & GP_FRAME_SELECT) {
362                                 /* make a copy of this frame */
363                                 bGPDframe *new_frame = BKE_gpencil_frame_duplicate(gpf);
364                                 BLI_addtail(&copied_frames, new_frame);
365
366                                 /* extend extents for keyframes encountered */
367                                 if (gpf->framenum  < gp_anim_copy_firstframe)
368                                         gp_anim_copy_firstframe = gpf->framenum;
369                                 if (gpf->framenum > gp_anim_copy_lastframe)
370                                         gp_anim_copy_lastframe = gpf->framenum;
371                         }
372                 }
373
374                 /* create a new layer in buffer if there were keyframes here */
375                 if (BLI_listbase_is_empty(&copied_frames) == false) {
376                         bGPDlayer *new_layer = MEM_callocN(sizeof(bGPDlayer), "GPCopyPasteLayer");
377                         BLI_addtail(&gp_anim_copybuf, new_layer);
378
379                         /* move over copied frames */
380                         BLI_movelisttolist(&new_layer->frames, &copied_frames);
381                         BLI_assert(copied_frames.first == NULL);
382
383                         /* make a copy of the layer's name - for name-based matching later... */
384                         BLI_strncpy(new_layer->info, gpl->info, sizeof(new_layer->info));
385                 }
386         }
387
388         /* in case 'relative' paste method is used */
389         gp_anim_copy_cfra = CFRA;
390
391         /* clean up */
392         ANIM_animdata_freelist(&anim_data);
393
394         /* check if anything ended up in the buffer */
395         if (ELEM(NULL, gp_anim_copybuf.first, gp_anim_copybuf.last)) {
396                 BKE_report(ac->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
397                 return false;
398         }
399
400         /* report success */
401         return true;
402 }
403
404
405 /* Pastes keyframes from buffer, and reports success */
406 bool ED_gpencil_anim_copybuf_paste(bAnimContext *ac, const short offset_mode)
407 {
408         ListBase anim_data = {NULL, NULL};
409         bAnimListElem *ale;
410         int filter;
411
412         Scene *scene = ac->scene;
413         bool no_name = false;
414         int offset = 0;
415
416         /* check if buffer is empty */
417         if (BLI_listbase_is_empty(&gp_anim_copybuf)) {
418                 BKE_report(ac->reports, RPT_ERROR, "No data in buffer to paste");
419                 return false;
420         }
421
422         /* check if single channel in buffer (disregard names if so)  */
423         if (gp_anim_copybuf.first == gp_anim_copybuf.last) {
424                 no_name = true;
425         }
426
427         /* methods of offset (eKeyPasteOffset) */
428         switch (offset_mode) {
429                 case KEYFRAME_PASTE_OFFSET_CFRA_START:
430                         offset = (CFRA - gp_anim_copy_firstframe);
431                         break;
432                 case KEYFRAME_PASTE_OFFSET_CFRA_END:
433                         offset = (CFRA - gp_anim_copy_lastframe);
434                         break;
435                 case KEYFRAME_PASTE_OFFSET_CFRA_RELATIVE:
436                         offset = (CFRA - gp_anim_copy_cfra);
437                         break;
438                 case KEYFRAME_PASTE_OFFSET_NONE:
439                         offset = 0;
440                         break;
441         }
442
443
444         /* filter data */
445         // TODO: try doing it with selection, then without selection imits
446         filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
447         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
448
449         /* from selected channels */
450         for (ale = anim_data.first; ale; ale = ale->next) {
451                 bGPDlayer *gpld = (bGPDlayer *)ale->data;
452                 bGPDlayer *gpls = NULL;
453                 bGPDframe *gpfs, *gpf;
454
455
456                 /* find suitable layer from buffer to use to paste from */
457                 for (gpls = gp_anim_copybuf.first; gpls; gpls = gpls->next) {
458                         /* check if layer name matches */
459                         if ((no_name) || STREQ(gpls->info, gpld->info)) {
460                                 break;
461                         }
462                 }
463
464                 /* this situation might occur! */
465                 if (gpls == NULL)
466                         continue;
467
468                 /* add frames from buffer */
469                 for (gpfs = gpls->frames.first; gpfs; gpfs = gpfs->next) {
470                         /* temporarily apply offset to buffer-frame while copying */
471                         gpfs->framenum += offset;
472
473                         /* get frame to copy data into (if no frame returned, then just ignore) */
474                         gpf = BKE_gpencil_layer_getframe(gpld, gpfs->framenum, GP_GETFRAME_ADD_NEW);
475                         if (gpf) {
476                                 bGPDstroke *gps, *gpsn;
477
478                                 /* This should be the right frame... as it may be a pre-existing frame,
479                                  * must make sure that only compatible stroke types get copied over
480                                  * - We cannot just add a duplicate frame, as that would cause errors
481                                  * - For now, we don't check if the types will be compatible since we
482                                  *   don't have enough info to do so. Instead, we simply just paste,
483                                  *   if it works, it will show up.
484                                  */
485                                 for (gps = gpfs->strokes.first; gps; gps = gps->next) {
486                                         /* make a copy of stroke, then of its points array */
487                                         gpsn = MEM_dupallocN(gps);
488                                         gpsn->points = MEM_dupallocN(gps->points);
489                                         if (gps->dvert != NULL) {
490                                                 gpsn->dvert = MEM_dupallocN(gps->dvert);
491                                                 BKE_gpencil_stroke_weights_duplicate(gps, gpsn);
492                                         }
493                                         /* duplicate triangle information */
494                                         gpsn->triangles = MEM_dupallocN(gps->triangles);
495                                         /* append stroke to frame */
496                                         BLI_addtail(&gpf->strokes, gpsn);
497                                 }
498
499                                 /* if no strokes (i.e. new frame) added, free gpf */
500                                 if (BLI_listbase_is_empty(&gpf->strokes))
501                                         BKE_gpencil_layer_delframe(gpld, gpf);
502                         }
503
504                         /* unapply offset from buffer-frame */
505                         gpfs->framenum -= offset;
506                 }
507         }
508
509         /* clean up */
510         ANIM_animdata_freelist(&anim_data);
511         return true;
512 }
513
514 /* -------------------------------------- */
515 /* Snap Tools */
516
517 static short snap_gpf_nearest(bGPDframe *UNUSED(gpf), Scene *UNUSED(scene))
518 {
519 #if 0 /* note: gpf->framenum is already an int! */
520         if (gpf->flag & GP_FRAME_SELECT)
521                 gpf->framenum = (int)(floor(gpf->framenum + 0.5));
522 #endif
523         return 0;
524 }
525
526 static short snap_gpf_nearestsec(bGPDframe *gpf, Scene *scene)
527 {
528         float secf = (float)FPS;
529         if (gpf->flag & GP_FRAME_SELECT)
530                 gpf->framenum = (int)(floorf(gpf->framenum / secf + 0.5f) * secf);
531         return 0;
532 }
533
534 static short snap_gpf_cframe(bGPDframe *gpf, Scene *scene)
535 {
536         if (gpf->flag & GP_FRAME_SELECT)
537                 gpf->framenum = (int)CFRA;
538         return 0;
539 }
540
541 static short snap_gpf_nearmarker(bGPDframe *gpf, Scene *scene)
542 {
543         if (gpf->flag & GP_FRAME_SELECT)
544                 gpf->framenum = (int)ED_markers_find_nearest_marker_time(&scene->markers, (float)gpf->framenum);
545         return 0;
546 }
547
548 /* snap selected frames to ... */
549 void ED_gplayer_snap_frames(bGPDlayer *gpl, Scene *scene, short mode)
550 {
551         switch (mode) {
552                 case SNAP_KEYS_NEARFRAME: /* snap to nearest frame */
553                         ED_gplayer_frames_looper(gpl, scene, snap_gpf_nearest);
554                         break;
555                 case SNAP_KEYS_CURFRAME: /* snap to current frame */
556                         ED_gplayer_frames_looper(gpl, scene, snap_gpf_cframe);
557                         break;
558                 case SNAP_KEYS_NEARMARKER: /* snap to nearest marker */
559                         ED_gplayer_frames_looper(gpl, scene, snap_gpf_nearmarker);
560                         break;
561                 case SNAP_KEYS_NEARSEC: /* snap to nearest second */
562                         ED_gplayer_frames_looper(gpl, scene, snap_gpf_nearestsec);
563                         break;
564                 default: /* just in case */
565                         break;
566         }
567 }
568
569 /* -------------------------------------- */
570 /* Mirror Tools */
571
572 static short mirror_gpf_cframe(bGPDframe *gpf, Scene *scene)
573 {
574         int diff;
575
576         if (gpf->flag & GP_FRAME_SELECT) {
577                 diff = CFRA - gpf->framenum;
578                 gpf->framenum = CFRA + diff;
579         }
580
581         return 0;
582 }
583
584 static short mirror_gpf_yaxis(bGPDframe *gpf, Scene *UNUSED(scene))
585 {
586         int diff;
587
588         if (gpf->flag & GP_FRAME_SELECT) {
589                 diff = -gpf->framenum;
590                 gpf->framenum = diff;
591         }
592
593         return 0;
594 }
595
596 static short mirror_gpf_xaxis(bGPDframe *gpf, Scene *UNUSED(scene))
597 {
598         int diff;
599
600         /* NOTE: since we can't really do this, we just do the same as for yaxis... */
601         if (gpf->flag & GP_FRAME_SELECT) {
602                 diff = -gpf->framenum;
603                 gpf->framenum = diff;
604         }
605
606         return 0;
607 }
608
609 static short mirror_gpf_marker(bGPDframe *gpf, Scene *scene)
610 {
611         static TimeMarker *marker;
612         static short initialized = 0;
613         int diff;
614
615         /* In order for this mirror function to work without
616          * any extra arguments being added, we use the case
617          * of bezt==NULL to denote that we should find the
618          * marker to mirror over. The static pointer is safe
619          * to use this way, as it will be set to null after
620          * each cycle in which this is called.
621          */
622
623         if (gpf) {
624                 /* mirroring time */
625                 if ((gpf->flag & GP_FRAME_SELECT) && (marker)) {
626                         diff = (marker->frame - gpf->framenum);
627                         gpf->framenum = (marker->frame + diff);
628                 }
629         }
630         else {
631                 /* initialization time */
632                 if (initialized) {
633                         /* reset everything for safety */
634                         marker = NULL;
635                         initialized = 0;
636                 }
637                 else {
638                         /* try to find a marker */
639                         marker = ED_markers_get_first_selected(&scene->markers);
640                         if (marker) {
641                                 initialized = 1;
642                         }
643                 }
644         }
645
646         return 0;
647 }
648
649
650 /* mirror selected gp-frames on... */
651 // TODO: mirror over a specific time
652 void ED_gplayer_mirror_frames(bGPDlayer *gpl, Scene *scene, short mode)
653 {
654         switch (mode) {
655                 case MIRROR_KEYS_CURFRAME: /* mirror over current frame */
656                         ED_gplayer_frames_looper(gpl, scene, mirror_gpf_cframe);
657                         break;
658                 case MIRROR_KEYS_YAXIS: /* mirror over frame 0 */
659                         ED_gplayer_frames_looper(gpl, scene, mirror_gpf_yaxis);
660                         break;
661                 case MIRROR_KEYS_XAXIS: /* mirror over value 0 */
662                         ED_gplayer_frames_looper(gpl, scene, mirror_gpf_xaxis);
663                         break;
664                 case MIRROR_KEYS_MARKER: /* mirror over marker */
665                         mirror_gpf_marker(NULL, NULL);
666                         ED_gplayer_frames_looper(gpl, scene, mirror_gpf_marker);
667                         mirror_gpf_marker(NULL, NULL);
668                         break;
669                 default: /* just in case */
670                         ED_gplayer_frames_looper(gpl, scene, mirror_gpf_yaxis);
671                         break;
672         }
673 }
674
675 /* ***************************************** */