Fix T50614: Curve doesn't restore initial form after deleting all its shapekeys
[blender.git] / source / blender / editors / animation / anim_draw.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  * All rights reserved.
20  *
21  * 
22  * Contributor(s): Joshua Leung
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/animation/anim_draw.c
28  *  \ingroup edanimation
29  */
30
31 #include "BLI_sys_types.h"
32
33 #include "DNA_anim_types.h"
34 #include "DNA_scene_types.h"
35 #include "DNA_space_types.h"
36 #include "DNA_userdef_types.h"
37 #include "DNA_screen_types.h"
38 #include "DNA_object_types.h"
39 #include "DNA_gpencil_types.h"
40 #include "DNA_mask_types.h"
41
42 #include "BLI_math.h"
43 #include "BLI_timecode.h"
44 #include "BLI_utildefines.h"
45 #include "BLI_rect.h"
46 #include "BLI_dlrbTree.h"
47
48 #include "BKE_context.h"
49 #include "BKE_curve.h"
50 #include "BKE_fcurve.h"
51 #include "BKE_global.h"
52 #include "BKE_nla.h"
53 #include "BKE_mask.h"
54
55 #include "ED_anim_api.h"
56 #include "ED_keyframes_edit.h"
57 #include "ED_keyframes_draw.h"
58
59 #include "RNA_access.h"
60
61 #include "BIF_gl.h"
62
63 #include "UI_interface.h"
64 #include "UI_resources.h"
65 #include "UI_view2d.h"
66
67 /* *************************************************** */
68 /* CURRENT FRAME DRAWING */
69
70 /* Draw current frame number in a little green box beside the current frame indicator */
71 static void draw_cfra_number(Scene *scene, View2D *v2d, const float cfra, const bool time)
72 {
73         const uiFontStyle *fstyle = UI_FSTYLE_WIDGET;
74         float xscale, yscale, x, y;
75         char numstr[32] = "    t";  /* t is the character to start replacing from */
76         int slen;
77         
78         /* because the frame number text is subject to the same scaling as the contents of the view */
79         UI_view2d_scale_get(v2d, &xscale, &yscale);
80         glScalef(1.0f / xscale, 1.0f, 1.0f);
81         
82         /* get timecode string 
83          *      - padding on str-buf passed so that it doesn't sit on the frame indicator
84          *      - power = 0, gives 'standard' behavior for time
85          *        but power = 1 is required for frames (to get integer frames)
86          */
87         if (time) {
88                 BLI_timecode_string_from_time(&numstr[4], sizeof(numstr) - 4, 0, FRA2TIME(cfra), FPS, U.timecode_style);
89         }
90         else {
91                 BLI_timecode_string_from_time_seconds(&numstr[4], sizeof(numstr) - 4, 1, cfra);
92         }
93
94         slen = UI_fontstyle_string_width(fstyle, numstr) - 1;
95         
96         /* get starting coordinates for drawing */
97         x = cfra * xscale;
98         y = 0.9f * U.widget_unit;
99         
100         /* draw green box around/behind text */
101         UI_ThemeColorShade(TH_CFRAME, 0);
102         glRectf(x, y,  x + slen,  y + 0.75f * U.widget_unit);
103         
104         /* draw current frame number - black text */
105         UI_ThemeColor(TH_TEXT);
106         UI_fontstyle_draw_simple(fstyle, x - 0.25f * U.widget_unit, y + 0.15f * U.widget_unit, numstr);
107         
108         /* restore view transform */
109         glScalef(xscale, 1.0, 1.0);
110 }
111
112 /* General call for drawing current frame indicator in animation editor */
113 void ANIM_draw_cfra(const bContext *C, View2D *v2d, short flag)
114 {
115         Scene *scene = CTX_data_scene(C);
116
117         /* Draw a light green line to indicate current frame */
118         UI_ThemeColor(TH_CFRAME);
119
120         const float time = scene->r.cfra + scene->r.subframe;
121         const float x = (float)(time * scene->r.framelen);
122
123         glLineWidth((flag & DRAWCFRA_WIDE) ? 3.0 : 2.0);
124
125         glBegin(GL_LINES);
126         glVertex2f(x, v2d->cur.ymin - 500.0f); /* XXX arbitrary... want it go to bottom */
127         glVertex2f(x, v2d->cur.ymax);
128         glEnd();
129
130         /* Draw current frame number in a little box */
131         if (flag & DRAWCFRA_SHOW_NUMBOX) {
132                 UI_view2d_view_orthoSpecial(CTX_wm_region(C), v2d, 1);
133                 draw_cfra_number(scene, v2d, x, (flag & DRAWCFRA_UNIT_SECONDS) != 0);
134         }
135 }
136
137 /* *************************************************** */
138 /* PREVIEW RANGE 'CURTAINS' */
139 /* Note: 'Preview Range' tools are defined in anim_ops.c */
140
141 /* Draw preview range 'curtains' for highlighting where the animation data is */
142 void ANIM_draw_previewrange(const bContext *C, View2D *v2d, int end_frame_width)
143 {
144         Scene *scene = CTX_data_scene(C);
145         
146         /* only draw this if preview range is set */
147         if (PRVRANGEON) {
148                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
149                 glEnable(GL_BLEND);
150                 glColor4f(0.0f, 0.0f, 0.0f, 0.4f);
151                 
152                 /* only draw two separate 'curtains' if there's no overlap between them */
153                 if (PSFRA < PEFRA + end_frame_width) {
154                         glRectf(v2d->cur.xmin, v2d->cur.ymin, (float)PSFRA, v2d->cur.ymax);
155                         glRectf((float)(PEFRA + end_frame_width), v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
156                 }
157                 else {
158                         glRectf(v2d->cur.xmin, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
159                 }
160                 
161                 glDisable(GL_BLEND);
162         }
163 }
164
165 /* *************************************************** */
166 /* NLA-MAPPING UTILITIES (required for drawing and also editing keyframes)  */
167
168 /* Obtain the AnimData block providing NLA-mapping for the given channel (if applicable) */
169 // TODO: do not supply return this if the animdata tells us that there is no mapping to perform
170 AnimData *ANIM_nla_mapping_get(bAnimContext *ac, bAnimListElem *ale)
171 {
172         /* sanity checks */
173         if (ac == NULL)
174                 return NULL;
175         
176         /* abort if rendering - we may get some race condition issues... */
177         if (G.is_rendering) return NULL;
178         
179         /* apart from strictly keyframe-related contexts, this shouldn't even happen */
180         // XXX: nla and channel here may not be necessary...
181         if (ELEM(ac->datatype, ANIMCONT_ACTION, ANIMCONT_SHAPEKEY, ANIMCONT_DOPESHEET,
182                                ANIMCONT_FCURVES, ANIMCONT_NLA, ANIMCONT_CHANNEL))
183         {
184                 /* handling depends on the type of animation-context we've got */
185                 if (ale) {
186                         /* NLA Control Curves occur on NLA strips, and shouldn't be subjected to this kind of mapping */
187                         if (ale->type != ANIMTYPE_NLACURVE)
188                                 return ale->adt;
189                 }
190         }
191         
192         /* cannot handle... */
193         return NULL;
194 }
195
196 /* ------------------- */
197
198 /* helper function for ANIM_nla_mapping_apply_fcurve() -> "restore", i.e. mapping points back to action-time */
199 static short bezt_nlamapping_restore(KeyframeEditData *ked, BezTriple *bezt)
200 {
201         /* AnimData block providing scaling is stored in 'data', only_keys option is stored in i1 */
202         AnimData *adt = (AnimData *)ked->data;
203         short only_keys = (short)ked->i1;
204         
205         /* adjust BezTriple handles only if allowed to */
206         if (only_keys == 0) {
207                 bezt->vec[0][0] = BKE_nla_tweakedit_remap(adt, bezt->vec[0][0], NLATIME_CONVERT_UNMAP);
208                 bezt->vec[2][0] = BKE_nla_tweakedit_remap(adt, bezt->vec[2][0], NLATIME_CONVERT_UNMAP);
209         }
210         
211         bezt->vec[1][0] = BKE_nla_tweakedit_remap(adt, bezt->vec[1][0], NLATIME_CONVERT_UNMAP);
212         
213         return 0;
214 }
215
216 /* helper function for ANIM_nla_mapping_apply_fcurve() -> "apply", i.e. mapping points to NLA-mapped global time */
217 static short bezt_nlamapping_apply(KeyframeEditData *ked, BezTriple *bezt)
218 {
219         /* AnimData block providing scaling is stored in 'data', only_keys option is stored in i1 */
220         AnimData *adt = (AnimData *)ked->data;
221         short only_keys = (short)ked->i1;
222         
223         /* adjust BezTriple handles only if allowed to */
224         if (only_keys == 0) {
225                 bezt->vec[0][0] = BKE_nla_tweakedit_remap(adt, bezt->vec[0][0], NLATIME_CONVERT_MAP);
226                 bezt->vec[2][0] = BKE_nla_tweakedit_remap(adt, bezt->vec[2][0], NLATIME_CONVERT_MAP);
227         }
228         
229         bezt->vec[1][0] = BKE_nla_tweakedit_remap(adt, bezt->vec[1][0], NLATIME_CONVERT_MAP);
230         
231         return 0;
232 }
233
234
235 /* Apply/Unapply NLA mapping to all keyframes in the nominated F-Curve 
236  *      - restore = whether to map points back to non-mapped time 
237  *  - only_keys = whether to only adjust the location of the center point of beztriples
238  */
239 void ANIM_nla_mapping_apply_fcurve(AnimData *adt, FCurve *fcu, bool restore, bool only_keys)
240 {
241         KeyframeEditData ked = {{NULL}};
242         KeyframeEditFunc map_cb;
243         
244         /* init edit data 
245          *      - AnimData is stored in 'data'
246          *      - only_keys is stored in 'i1'
247          */
248         ked.data = (void *)adt;
249         ked.i1 = (int)only_keys;
250         
251         /* get editing callback */
252         if (restore)
253                 map_cb = bezt_nlamapping_restore;
254         else
255                 map_cb = bezt_nlamapping_apply;
256         
257         /* apply to F-Curve */
258         ANIM_fcurve_keyframes_loop(&ked, fcu, NULL, map_cb, NULL);
259 }
260
261 /* *************************************************** */
262 /* UNITS CONVERSION MAPPING (required for drawing and editing keyframes) */
263
264 /* Get flags used for normalization in ANIM_unit_mapping_get_factor. */
265 short ANIM_get_normalization_flags(bAnimContext *ac)
266 {
267         if (ac->sl->spacetype == SPACE_IPO) {
268                 SpaceIpo *sipo = (SpaceIpo *) ac->sl;
269                 bool use_normalization = (sipo->flag & SIPO_NORMALIZE) != 0;
270                 bool freeze_normalization = (sipo->flag & SIPO_NORMALIZE_FREEZE) != 0;
271                 return use_normalization
272                     ? (ANIM_UNITCONV_NORMALIZE |  (freeze_normalization ? ANIM_UNITCONV_NORMALIZE_FREEZE : 0))
273                     : 0;
274         }
275
276         return 0;
277 }
278
279 static float normalization_factor_get(Scene *scene, FCurve *fcu, short flag, float *r_offset)
280 {
281         float factor = 1.0f, offset = 0.0f;
282
283         if (flag & ANIM_UNITCONV_RESTORE) {
284                 if (r_offset)
285                         *r_offset = fcu->prev_offset;
286
287                 return 1.0f / fcu->prev_norm_factor;
288         }
289
290         if (flag & ANIM_UNITCONV_NORMALIZE_FREEZE) {
291                 if (r_offset)
292                         *r_offset = fcu->prev_offset;
293                 if (fcu->prev_norm_factor == 0.0f) {
294                         /* Happens when Auto Normalize was disabled before
295                          * any curves were displayed.
296                          */
297                         return 1.0f;
298                 }
299                 return fcu->prev_norm_factor;
300         }
301
302         if (G.moving & G_TRANSFORM_FCURVES) {
303                 if (r_offset)
304                         *r_offset = fcu->prev_offset;
305                 if (fcu->prev_norm_factor == 0.0f) {
306                         /* Same as above. */
307                         return 1.0f;
308                 }
309                 return fcu->prev_norm_factor;
310         }
311
312         fcu->prev_norm_factor = 1.0f;
313         if (fcu->bezt) {
314                 const bool use_preview_only = PRVRANGEON;
315                 const BezTriple *bezt;
316                 int i;
317                 float max_coord = -FLT_MAX;
318                 float min_coord = FLT_MAX;
319                 float range;
320
321                 if (fcu->totvert < 1) {
322                         return 1.0f;
323                 }
324
325                 for (i = 0, bezt = fcu->bezt; i < fcu->totvert; i++, bezt++) {
326                         if (use_preview_only && !IN_RANGE_INCL(bezt->vec[1][0],
327                                                                scene->r.psfra,
328                                                                scene->r.pefra))
329                         {
330                                 continue;
331                         }
332
333                         if (i == 0) {
334                                 /* We ignore extrapolation flags and handle here, and use the
335                                  * control point position only. so we normalize "interesting"
336                                  * part of the curve.
337                                  *
338                                  * Here we handle left extrapolation.
339                                  */
340                                 max_coord = max_ff(max_coord, bezt->vec[1][1]);
341
342                                 min_coord = min_ff(min_coord, bezt->vec[1][1]);
343                         }
344                         else {
345                                 const BezTriple *prev_bezt = bezt - 1;
346                                 if (prev_bezt->ipo == BEZT_IPO_CONST) {
347                                         /* Constant interpolation: previous CV value is used up
348                                          * to the current keyframe.
349                                          */
350                                         max_coord = max_ff(max_coord, bezt->vec[1][1]);
351                                         min_coord = min_ff(min_coord, bezt->vec[1][1]);
352                                 }
353                                 else if (prev_bezt->ipo == BEZT_IPO_LIN) {
354                                         /* Linear interpolation: min/max using both previous and
355                                          * and current CV.
356                                          */
357                                         max_coord = max_ff(max_coord, bezt->vec[1][1]);
358                                         min_coord = min_ff(min_coord, bezt->vec[1][1]);
359                                         max_coord = max_ff(max_coord, prev_bezt->vec[1][1]);
360                                         min_coord = min_ff(min_coord, prev_bezt->vec[1][1]);
361                                 }
362                                 else if (prev_bezt->ipo == BEZT_IPO_BEZ) {
363                                         const int resol = fcu->driver
364                                                 ? 32
365                                                 : min_ii((int)(5.0f * len_v2v2(bezt->vec[1], prev_bezt->vec[1])), 32);
366                                         if (resol < 2) {
367                                                 max_coord = max_ff(max_coord, prev_bezt->vec[1][1]);
368                                                 min_coord = min_ff(min_coord, prev_bezt->vec[1][1]);
369                                         }
370                                         else {
371                                                 float data[120];
372                                                 float v1[2], v2[2], v3[2], v4[2];
373
374                                                 v1[0] = prev_bezt->vec[1][0];
375                                                 v1[1] = prev_bezt->vec[1][1];
376                                                 v2[0] = prev_bezt->vec[2][0];
377                                                 v2[1] = prev_bezt->vec[2][1];
378
379                                                 v3[0] = bezt->vec[0][0];
380                                                 v3[1] = bezt->vec[0][1];
381                                                 v4[0] = bezt->vec[1][0];
382                                                 v4[1] = bezt->vec[1][1];
383
384                                                 correct_bezpart(v1, v2, v3, v4);
385
386                                                 BKE_curve_forward_diff_bezier(v1[0], v2[0], v3[0], v4[0], data, resol, sizeof(float) * 3);
387                                                 BKE_curve_forward_diff_bezier(v1[1], v2[1], v3[1], v4[1], data + 1, resol, sizeof(float) * 3);
388
389                                                 for (int j = 0; j <= resol; ++j) {
390                                                         const float *fp = &data[j * 3];
391                                                         max_coord = max_ff(max_coord, fp[1]);
392                                                         min_coord = min_ff(min_coord, fp[1]);
393                                                 }
394                                         }
395                                 }
396                         }
397                 }
398
399                 if (max_coord > min_coord) {
400                         range = max_coord - min_coord;
401                         if (range > FLT_EPSILON) {
402                                 factor = 2.0f / range;
403                         }
404                         offset = -min_coord - range / 2.0f;
405                 }
406                 else if (max_coord == min_coord) {
407                         factor = 1.0f;
408                         offset = -min_coord;
409                 }
410         }
411         BLI_assert(factor != 0.0f);
412         if (r_offset) {
413                 *r_offset = offset;
414         }
415
416         fcu->prev_norm_factor = factor;
417         fcu->prev_offset = offset;
418         return factor;
419 }
420
421 /* Get unit conversion factor for given ID + F-Curve */
422 float ANIM_unit_mapping_get_factor(Scene *scene, ID *id, FCurve *fcu, short flag, float *r_offset)
423 {
424         if (flag & ANIM_UNITCONV_NORMALIZE) {
425                 return normalization_factor_get(scene, fcu, flag, r_offset);
426         }
427
428         if (r_offset)
429                 *r_offset = 0.0f;
430
431         /* sanity checks */
432         if (id && fcu && fcu->rna_path) {
433                 PointerRNA ptr, id_ptr;
434                 PropertyRNA *prop;
435                 
436                 /* get RNA property that F-Curve affects */
437                 RNA_id_pointer_create(id, &id_ptr);
438                 if (RNA_path_resolve_property(&id_ptr, fcu->rna_path, &ptr, &prop)) {
439                         /* rotations: radians <-> degrees? */
440                         if (RNA_SUBTYPE_UNIT(RNA_property_subtype(prop)) == PROP_UNIT_ROTATION) {
441                                 /* if the radians flag is not set, default to using degrees which need conversions */
442                                 if ((scene) && (scene->unit.system_rotation == USER_UNIT_ROT_RADIANS) == 0) {
443                                         if (flag & ANIM_UNITCONV_RESTORE)
444                                                 return DEG2RADF(1.0f);  /* degrees to radians */
445                                         else
446                                                 return RAD2DEGF(1.0f);  /* radians to degrees */
447                                 }
448                         }
449                         
450                         /* TODO: other rotation types here as necessary */
451                 }
452         }
453
454         /* no mapping needs to occur... */
455         return 1.0f;
456 }
457
458 static bool find_prev_next_keyframes(struct bContext *C, int *nextfra, int *prevfra)
459 {
460         Scene *scene = CTX_data_scene(C);
461         Object *ob = CTX_data_active_object(C);
462         Mask *mask = CTX_data_edit_mask(C);
463         bDopeSheet ads = {NULL};
464         DLRBT_Tree keys;
465         ActKeyColumn *aknext, *akprev;
466         float cfranext, cfraprev;
467         bool donenext = false, doneprev = false;
468         int nextcount = 0, prevcount = 0;
469
470         cfranext = cfraprev = (float)(CFRA);
471
472         /* init binarytree-list for getting keyframes */
473         BLI_dlrbTree_init(&keys);
474
475         /* seed up dummy dopesheet context with flags to perform necessary filtering */
476         if ((scene->flag & SCE_KEYS_NO_SELONLY) == 0) {
477                 /* only selected channels are included */
478                 ads.filterflag |= ADS_FILTER_ONLYSEL;
479         }
480
481         /* populate tree with keyframe nodes */
482         scene_to_keylist(&ads, scene, &keys, NULL);
483         gpencil_to_keylist(&ads, scene->gpd, &keys);
484
485         if (ob) {
486                 ob_to_keylist(&ads, ob, &keys, NULL);
487                 gpencil_to_keylist(&ads, ob->gpd, &keys);
488         }
489
490         if (mask) {
491                 MaskLayer *masklay = BKE_mask_layer_active(mask);
492                 mask_to_keylist(&ads, masklay, &keys);
493         }
494
495         /* build linked-list for searching */
496         BLI_dlrbTree_linkedlist_sync(&keys);
497
498         /* find matching keyframe in the right direction */
499         do {
500                 aknext = (ActKeyColumn *)BLI_dlrbTree_search_next(&keys, compare_ak_cfraPtr, &cfranext);
501
502                 if (aknext) {
503                         if (CFRA == (int)aknext->cfra) {
504                                 /* make this the new starting point for the search and ignore */
505                                 cfranext = aknext->cfra;
506                         }
507                         else {
508                                 /* this changes the frame, so set the frame and we're done */
509                                 if (++nextcount == U.view_frame_keyframes)
510                                         donenext = true;
511                         }
512                         cfranext = aknext->cfra;
513                 }
514         } while ((aknext != NULL) && (donenext == false));
515
516         do {
517                 akprev = (ActKeyColumn *)BLI_dlrbTree_search_prev(&keys, compare_ak_cfraPtr, &cfraprev);
518
519                 if (akprev) {
520                         if (CFRA == (int)akprev->cfra) {
521                                 /* make this the new starting point for the search */
522                         }
523                         else {
524                                 /* this changes the frame, so set the frame and we're done */
525                                 if (++prevcount == U.view_frame_keyframes)
526                                         doneprev = true;
527                         }
528                         cfraprev = akprev->cfra;
529                 }
530         } while ((akprev != NULL) && (doneprev == false));
531
532         /* free temp stuff */
533         BLI_dlrbTree_free(&keys);
534
535         /* any success? */
536         if (doneprev || donenext) {
537                 if (doneprev)
538                         *prevfra = cfraprev;
539                 else
540                         *prevfra = CFRA - (cfranext - CFRA);
541
542                 if (donenext)
543                         *nextfra = cfranext;
544                 else
545                         *nextfra = CFRA + (CFRA - cfraprev);
546
547                 return true;
548         }
549
550         return false;
551 }
552
553 void ANIM_center_frame(struct bContext *C, int smooth_viewtx)
554 {
555         ARegion *ar = CTX_wm_region(C);
556         Scene *scene = CTX_data_scene(C);
557         float w = BLI_rctf_size_x(&ar->v2d.cur);
558         rctf newrct;
559         int nextfra, prevfra;
560
561         switch (U.view_frame_type) {
562                 case ZOOM_FRAME_MODE_SECONDS:
563                 {
564                         const float fps = FPS;
565                         newrct.xmax = scene->r.cfra + U.view_frame_seconds * fps + 1;
566                         newrct.xmin = scene->r.cfra - U.view_frame_seconds * fps - 1;
567                         newrct.ymax = ar->v2d.cur.ymax;
568                         newrct.ymin = ar->v2d.cur.ymin;
569                         break;
570                 }
571
572                 /* hardest case of all, look for all keyframes around frame and display those */
573                 case ZOOM_FRAME_MODE_KEYFRAMES:
574                         if (find_prev_next_keyframes(C, &nextfra, &prevfra)) {
575                                 newrct.xmax = nextfra;
576                                 newrct.xmin = prevfra;
577                                 newrct.ymax = ar->v2d.cur.ymax;
578                                 newrct.ymin = ar->v2d.cur.ymin;
579                                 break;
580                         }
581                         /* else drop through, keep range instead */
582
583                 case ZOOM_FRAME_MODE_KEEP_RANGE:
584                 default:
585                         newrct.xmax = scene->r.cfra + (w / 2);
586                         newrct.xmin = scene->r.cfra - (w / 2);
587                         newrct.ymax = ar->v2d.cur.ymax;
588                         newrct.ymin = ar->v2d.cur.ymin;
589                         break;
590         }
591
592         UI_view2d_smooth_view(C, ar, &newrct, smooth_viewtx);
593 }
594 /* *************************************************** */