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