source/blender/editors/animation/anim_draw.c

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * The Original Code is Copyright (C) 2008 Blender Foundation.
  21  * All rights reserved.
  22  *
  23  *
  24  * Contributor(s): Joshua Leung
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 /** \file blender/editors/animation/anim_draw.c
  30  *  \ingroup edanimation
  31  */
  32
  33 #include "BLO_sys_types.h"
  34
  35 #include "DNA_anim_types.h"
  36 #include "DNA_object_types.h"
  37 #include "DNA_scene_types.h"
  38 #include "BLI_math.h"
  39
  40 #include "BKE_context.h"
  41 #include "BKE_nla.h"
  42 #include "BKE_object.h"
  43
  44 #include "ED_anim_api.h"
  45 #include "ED_keyframes_edit.h"
  46
  47 #include "RNA_access.h"
  48
  49 #include "BIF_gl.h"
  50
  51 #include "UI_interface.h"
  52 #include "UI_resources.h"
  53 #include "UI_view2d.h"
  54
  55 /* XXX */
  56 extern void ui_rasterpos_safe(float x, float y, float aspect);
  57
  58 /* *************************************************** */
  59 /* TIME CODE FORMATTING */
  60
  61 /* Generate timecode/frame number string and store in the supplied string
  62  *      - buffer: must be at least 13 chars long
  63  *      - power: special setting for View2D grid drawing,
  64  *        used to specify how detailed we need to be
  65  *      - timecodes: boolean specifying whether timecodes or
  66  *        frame numbers get drawn
  67  *      - cfra: time in frames or seconds, consistent with the values shown by timecodes
  68  */
  69 // TODO: have this in kernel instead under scene?
  70 void ANIM_timecode_string_from_frame (char *str, Scene *scene, int power, short timecodes, float cfra)
  71 {
  72         if (timecodes) {
  73                 int hours=0, minutes=0, seconds=0, frames=0;
  74                 float raw_seconds= cfra;
  75                 char neg[2]= "";
  76
  77                 /* get cframes */
  78                 if (cfra < 0) {
  79                         /* correction for negative cfraues */
  80                         sprintf(neg, "-");
  81                         cfra = -cfra;
  82                 }
  83                 if (cfra >= 3600) {
  84                         /* hours */
  85                         /* XXX should we only display a single digit for hours since clips are
  86                          *         VERY UNLIKELY to be more than 1-2 hours max? However, that would
  87                          *         go against conventions...
  88                          */
  89                         hours= (int)cfra / 3600;
  90                         cfra= (float)fmod(cfra, 3600);
  91                 }
  92                 if (cfra >= 60) {
  93                         /* minutes */
  94                         minutes= (int)cfra / 60;
  95                         cfra= (float)fmod(cfra, 60);
  96                 }
  97                 if (power <= 0) {
  98                         /* seconds + frames
  99                          *      Frames are derived from 'fraction' of second. We need to perform some additional rounding
 100                          *      to cope with 'half' frames, etc., which should be fine in most cases
 101                          */
 102                         seconds= (int)cfra;
 103                         frames= (int)floor( (((double)cfra - (double)seconds) * FPS) + 0.5 );
 104                 }
 105                 else {
 106                         /* seconds (with pixel offset rounding) */
 107                         seconds= (int)floor(cfra + 0.375f);
 108                 }
 109
 110                 switch (U.timecode_style) {
 111                         case USER_TIMECODE_MINIMAL:
 112                         {
 113                                 /*      - In general, minutes and seconds should be shown, as most clips will be
 114                                  *        within this length. Hours will only be included if relevant.
 115                                  *      - Only show frames when zoomed in enough for them to be relevant
 116                                  *        (using separator of '+' for frames).
 117                                  *        When showing frames, use slightly different display to avoid confusion with mm:ss format
 118                                  */
 119                                 if (power <= 0) {
 120                                         /* include "frames" in display */
 121                                         if (hours) sprintf(str, "%s%02d:%02d:%02d+%02d", neg, hours, minutes, seconds, frames);
 122                                         else if (minutes) sprintf(str, "%s%02d:%02d+%02d", neg, minutes, seconds, frames);
 123                                         else sprintf(str, "%s%d+%02d", neg, seconds, frames);
 124                                 }
 125                                 else {
 126                                         /* don't include 'frames' in display */
 127                                         if (hours) sprintf(str, "%s%02d:%02d:%02d", neg, hours, minutes, seconds);
 128                                         else sprintf(str, "%s%02d:%02d", neg, minutes, seconds);
 129                                 }
 130                         }
 131                                 break;
 132
 133                         case USER_TIMECODE_SMPTE_MSF:
 134                         {
 135                                 /* reduced SMPTE format that always shows minutes, seconds, frames. Hours only shown as needed. */
 136                                 if (hours) sprintf(str, "%s%02d:%02d:%02d:%02d", neg, hours, minutes, seconds, frames);
 137                                 else sprintf(str, "%s%02d:%02d:%02d", neg, minutes, seconds, frames);
 138                         }
 139                                 break;
 140
 141                         case USER_TIMECODE_MILLISECONDS:
 142                         {
 143                                 /* reduced SMPTE. Instead of frames, milliseconds are shown */
 144                                 int ms_dp= (power <= 0) ? (1 - power) : 1; /* precision of decimal part */
 145                                 int s_pad= ms_dp+3;     /* to get 2 digit whole-number part for seconds display (i.e. 3 is for 2 digits + radix, on top of full length) */
 146
 147                                 if (hours) sprintf(str, "%s%02d:%02d:%0*.*f", neg, hours, minutes, s_pad, ms_dp, cfra);
 148                                 else sprintf(str, "%s%02d:%0*.*f", neg, minutes, s_pad,  ms_dp, cfra);
 149                         }
 150                                 break;
 151
 152                         case USER_TIMECODE_SECONDS_ONLY:
 153                         {
 154                                 /* only show the original seconds display */
 155                                 /* round to whole numbers if power is >= 1 (i.e. scale is coarse) */
 156                                 if (power <= 0) sprintf(str, "%.*f", 1-power, raw_seconds);
 157                                 else sprintf(str, "%d", (int)floor(raw_seconds + 0.375f));
 158                         }
 159                                 break;
 160
 161                         case USER_TIMECODE_SMPTE_FULL:
 162                         default:
 163                         {
 164                                 /* full SMPTE format */
 165                                 sprintf(str, "%s%02d:%02d:%02d:%02d", neg, hours, minutes, seconds, frames);
 166                         }
 167                                 break;
 168                 }
 169         }
 170         else {
 171                 /* round to whole numbers if power is >= 1 (i.e. scale is coarse) */
 172                 if (power <= 0) sprintf(str, "%.*f", 1-power, cfra);
 173                 else sprintf(str, "%d", (int)floor(cfra + 0.375f));
 174         }
 175 }
 176
 177 /* *************************************************** */
 178 /* CURRENT FRAME DRAWING */
 179
 180 /* Draw current frame number in a little green box beside the current frame indicator */
 181 static void draw_cfra_number (Scene *scene, View2D *v2d, float cfra, short time)
 182 {
 183         float xscale, yscale, x, y;
 184         char str[32] = "    t"; /* t is the character to start replacing from */
 185         short slen;
 186
 187         /* because the frame number text is subject to the same scaling as the contents of the view */
 188         UI_view2d_getscale(v2d, &xscale, &yscale);
 189         glScalef(1.0f/xscale, 1.0f, 1.0f);
 190
 191         /* get timecode string
 192          *      - padding on str-buf passed so that it doesn't sit on the frame indicator
 193          *      - power = 0, gives 'standard' behaviour for time
 194          *        but power = 1 is required for frames (to get integer frames)
 195          */
 196         if (time)
 197                 ANIM_timecode_string_from_frame(&str[4], scene, 0, time, FRA2TIME(cfra));
 198         else
 199                 ANIM_timecode_string_from_frame(&str[4], scene, 1, time, cfra);
 200         slen= (short)UI_GetStringWidth(str) - 1;
 201
 202         /* get starting coordinates for drawing */
 203         x= cfra * xscale;
 204         y= 18;
 205
 206         /* draw green box around/behind text */
 207         UI_ThemeColorShade(TH_CFRAME, 0);
 208         glRectf(x, y,  x+slen,  y+15);
 209
 210         /* draw current frame number - black text */
 211         UI_ThemeColor(TH_TEXT);
 212         UI_DrawString(x-5, y+3, str);
 213
 214         /* restore view transform */
 215         glScalef(xscale, 1.0, 1.0);
 216 }
 217
 218 /* General call for drawing current frame indicator in animation editor */
 219 void ANIM_draw_cfra (const bContext *C, View2D *v2d, short flag)
 220 {
 221         Scene *scene= CTX_data_scene(C);
 222         float vec[2];
 223
 224         /* Draw a light green line to indicate current frame */
 225         vec[0]= (float)(scene->r.cfra * scene->r.framelen);
 226
 227         UI_ThemeColor(TH_CFRAME);
 228         glLineWidth(2.0);
 229
 230         glBegin(GL_LINE_STRIP);
 231                 vec[1]= v2d->cur.ymin-500.0f;   /* XXX arbitrary... want it go to bottom */
 232                 glVertex2fv(vec);
 233
 234                 vec[1]= v2d->cur.ymax;
 235                 glVertex2fv(vec);
 236         glEnd();
 237
 238         /* Draw dark green line if slow-parenting/time-offset is enabled */
 239         if (flag & DRAWCFRA_SHOW_TIMEOFS) {
 240                 Object *ob= OBACT;
 241                 if(ob) {
 242                         float timeoffset= give_timeoffset(ob);
 243                         // XXX ob->ipoflag is depreceated!
 244                         if ((ob->ipoflag & OB_OFFS_OB) && (timeoffset != 0.0f)) {
 245                                 vec[0]-= timeoffset; /* could avoid calling twice */
 246
 247                                 UI_ThemeColorShade(TH_CFRAME, -30);
 248
 249                                 glBegin(GL_LINE_STRIP);
 250                                         /*vec[1]= v2d->cur.ymax;*/ // this is set already. this line is only included
 251                                         glVertex2fv(vec);
 252
 253                                         vec[1]= v2d->cur.ymin;
 254                                         glVertex2fv(vec);
 255                                 glEnd();
 256                         }
 257                 }
 258         }
 259
 260         glLineWidth(1.0);
 261
 262         /* Draw current frame number in a little box */
 263         if (flag & DRAWCFRA_SHOW_NUMBOX) {
 264                 UI_view2d_view_orthoSpecial(CTX_wm_region(C), v2d, 1);
 265                 draw_cfra_number(scene, v2d, vec[0], (flag & DRAWCFRA_UNIT_SECONDS));
 266         }
 267 }
 268
 269 /* *************************************************** */
 270 /* PREVIEW RANGE 'CURTAINS' */
 271 /* Note: 'Preview Range' tools are defined in anim_ops.c */
 272
 273 /* Draw preview range 'curtains' for highlighting where the animation data is */
 274 void ANIM_draw_previewrange (const bContext *C, View2D *v2d)
 275 {
 276         Scene *scene= CTX_data_scene(C);
 277
 278         /* only draw this if preview range is set */
 279         if (PRVRANGEON) {
 280                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 281                 glEnable(GL_BLEND);
 282                 glColor4f(0.0f, 0.0f, 0.0f, 0.4f);
 283
 284                 /* only draw two separate 'curtains' if there's no overlap between them */
 285                 if (PSFRA < PEFRA) {
 286                         glRectf(v2d->cur.xmin, v2d->cur.ymin, (float)PSFRA, v2d->cur.ymax);
 287                         glRectf((float)PEFRA, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
 288                 }
 289                 else {
 290                         glRectf(v2d->cur.xmin, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
 291                 }
 292
 293                 glDisable(GL_BLEND);
 294         }
 295 }
 296
 297 /* *************************************************** */
 298 /* NLA-MAPPING UTILITIES (required for drawing and also editing keyframes)  */
 299
 300 /* Obtain the AnimData block providing NLA-mapping for the given channel (if applicable) */
 301 // TODO: do not supply return this if the animdata tells us that there is no mapping to perform
 302 AnimData *ANIM_nla_mapping_get(bAnimContext *ac, bAnimListElem *ale)
 303 {
 304         /* sanity checks */
 305         if (ac == NULL)
 306                 return NULL;
 307
 308         /* handling depends on the type of animation-context we've got */
 309         if (ale)
 310                 return ale->adt;
 311         else
 312                 return NULL;
 313 }
 314
 315 /* ------------------- */
 316
 317 /* helper function for ANIM_nla_mapping_apply_fcurve() -> "restore", i.e. mapping points back to action-time */
 318 static short bezt_nlamapping_restore(KeyframeEditData *ked, BezTriple *bezt)
 319 {
 320         /* AnimData block providing scaling is stored in 'data', only_keys option is stored in i1 */
 321         AnimData *adt= (AnimData *)ked->data;
 322         short only_keys= (short)ked->i1;
 323
 324         /* adjust BezTriple handles only if allowed to */
 325         if (only_keys == 0) {
 326                 bezt->vec[0][0]= BKE_nla_tweakedit_remap(adt, bezt->vec[0][0], NLATIME_CONVERT_UNMAP);
 327                 bezt->vec[2][0]= BKE_nla_tweakedit_remap(adt, bezt->vec[2][0], NLATIME_CONVERT_UNMAP);
 328         }
 329
 330         bezt->vec[1][0]= BKE_nla_tweakedit_remap(adt, bezt->vec[1][0], NLATIME_CONVERT_UNMAP);
 331
 332         return 0;
 333 }
 334
 335 /* helper function for ANIM_nla_mapping_apply_fcurve() -> "apply", i.e. mapping points to NLA-mapped global time */
 336 static short bezt_nlamapping_apply(KeyframeEditData *ked, BezTriple *bezt)
 337 {
 338         /* AnimData block providing scaling is stored in 'data', only_keys option is stored in i1 */
 339         AnimData *adt= (AnimData*)ked->data;
 340         short only_keys= (short)ked->i1;
 341
 342         /* adjust BezTriple handles only if allowed to */
 343         if (only_keys == 0) {
 344                 bezt->vec[0][0]= BKE_nla_tweakedit_remap(adt, bezt->vec[0][0], NLATIME_CONVERT_MAP);
 345                 bezt->vec[2][0]= BKE_nla_tweakedit_remap(adt, bezt->vec[2][0], NLATIME_CONVERT_MAP);
 346         }
 347
 348         bezt->vec[1][0]= BKE_nla_tweakedit_remap(adt, bezt->vec[1][0], NLATIME_CONVERT_MAP);
 349
 350         return 0;
 351 }
 352
 353
 354 /* Apply/Unapply NLA mapping to all keyframes in the nominated F-Curve
 355  *      - restore = whether to map points back to non-mapped time
 356  *      - only_keys = whether to only adjust the location of the center point of beztriples
 357  */
 358 void ANIM_nla_mapping_apply_fcurve (AnimData *adt, FCurve *fcu, short restore, short only_keys)
 359 {
 360         KeyframeEditData ked= {{NULL}};
 361         KeyframeEditFunc map_cb;
 362
 363         /* init edit data
 364          *      - AnimData is stored in 'data'
 365          *      - only_keys is stored in 'i1'
 366          */
 367         ked.data= (void *)adt;
 368         ked.i1= (int)only_keys;
 369
 370         /* get editing callback */
 371         if (restore)
 372                 map_cb= bezt_nlamapping_restore;
 373         else
 374                 map_cb= bezt_nlamapping_apply;
 375
 376         /* apply to F-Curve */
 377         ANIM_fcurve_keyframes_loop(&ked, fcu, NULL, map_cb, NULL);
 378 }
 379
 380 /* *************************************************** */
 381 /* UNITS CONVERSION MAPPING (required for drawing and editing keyframes) */
 382
 383 /* Get unit conversion factor for given ID + F-Curve */
 384 float ANIM_unit_mapping_get_factor (Scene *scene, ID *id, FCurve *fcu, short restore)
 385 {
 386         /* sanity checks */
 387         if (id && fcu && fcu->rna_path)
 388         {
 389                 PointerRNA ptr, id_ptr;
 390                 PropertyRNA *prop;
 391
 392                 /* get RNA property that F-Curve affects */
 393                 RNA_id_pointer_create(id, &id_ptr);
 394                 if (RNA_path_resolve(&id_ptr, fcu->rna_path, &ptr, &prop))
 395                 {
 396                         /* rotations: radians <-> degrees? */
 397                         if (RNA_SUBTYPE_UNIT(RNA_property_subtype(prop)) == PROP_UNIT_ROTATION)
 398                         {
 399                                 /* if the radians flag is not set, default to using degrees which need conversions */
 400                                 if ((scene) && (scene->unit.system_rotation == USER_UNIT_ROT_RADIANS) == 0) {
 401                                         if (restore)
 402                                                 return M_PI / 180.0;    /* degrees to radians */
 403                                         else
 404                                                 return 180.0 / M_PI;    /* radians to degrees */
 405                                 }
 406                         }
 407
 408                         // TODO: other rotation types here as necessary
 409                 }
 410         }
 411
 412         /* no mapping needs to occur... */
 413         return 1.0f;
 414 }
 415
 416 /* ----------------------- */
 417
 418 /* helper function for ANIM_unit_mapping_apply_fcurve -> mapping callback for unit mapping */
 419 static short bezt_unit_mapping_apply (KeyframeEditData *ked, BezTriple *bezt)
 420 {
 421         /* mapping factor is stored in f1, flags are stored in i1 */
 422         short only_keys= (ked->i1 & ANIM_UNITCONV_ONLYKEYS);
 423         short sel_vs= (ked->i1 & ANIM_UNITCONV_SELVERTS);
 424         float fac= ked->f1;
 425
 426         /* adjust BezTriple handles only if allowed to */
 427         if (only_keys == 0) {
 428                 if ((sel_vs==0) || (bezt->f1 & SELECT))
 429                         bezt->vec[0][1] *= fac;
 430                 if ((sel_vs==0) || (bezt->f3 & SELECT))
 431                         bezt->vec[2][1] *= fac;
 432         }
 433
 434         if ((sel_vs == 0) || (bezt->f2 & SELECT))
 435                 bezt->vec[1][1] *= fac;
 436
 437         return 0;
 438 }
 439
 440 /* Apply/Unapply units conversions to keyframes */
 441 void ANIM_unit_mapping_apply_fcurve (Scene *scene, ID *id, FCurve *fcu, short flag)
 442 {
 443         KeyframeEditData ked;
 444         KeyframeEditFunc sel_cb;
 445         float fac;
 446
 447         /* calculate mapping factor, and abort if nothing to change */
 448         fac= ANIM_unit_mapping_get_factor(scene, id, fcu, (flag & ANIM_UNITCONV_RESTORE));
 449         if (fac == 1.0f)
 450                 return;
 451
 452         /* init edit data
 453          *      - mapping factor is stored in f1
 454          *      - flags are stored in 'i1'
 455          */
 456         memset(&ked, 0, sizeof(KeyframeEditData));
 457         ked.f1= (float)fac;
 458         ked.i1= (int)flag;
 459
 460         /* only selected? */
 461         if (flag & ANIM_UNITCONV_ONLYSEL)
 462                 sel_cb= ANIM_editkeyframes_ok(BEZT_OK_SELECTED);
 463         else
 464                 sel_cb= NULL;
 465
 466         /* apply to F-Curve */
 467         ANIM_fcurve_keyframes_loop(&ked, fcu, sel_cb, bezt_unit_mapping_apply, NULL);
 468
 469         // FIXME: loop here for samples should be generalised
 470         // TODO: only sel?
 471         if (fcu->fpt) {
 472                 FPoint *fpt;
 473                 unsigned int i;
 474
 475                 for (i=0, fpt=fcu->fpt; i < fcu->totvert; i++, fpt++) {
 476                         /* apply unit mapping */
 477                         fpt->vec[1] *= fac;
 478                 }
 479         }
 480 }
 481
 482 /* *************************************************** */