GPencil: Interpolate pressure in active Smooth
[blender.git] / source / blender / blenkernel / intern / ipo.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 /* NOTE:
25  *
26  * This file is no longer used to provide tools for the deprecated IPO system. Instead, it
27  * is only used to house the conversion code to the new system.
28  *
29  * -- Joshua Leung, Jan 2009
30  */
31
32 #include <math.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <stddef.h>
36
37 /* since we have versioning code here */
38 #define DNA_DEPRECATED_ALLOW
39
40 #include "DNA_anim_types.h"
41 #include "DNA_constraint_types.h"
42 #include "DNA_camera_types.h"
43 #include "DNA_light_types.h"
44 #include "DNA_ipo_types.h"
45 #include "DNA_key_types.h"
46 #include "DNA_material_types.h"
47 #include "DNA_nla_types.h"
48 #include "DNA_sequence_types.h"
49 #include "DNA_scene_types.h"
50 #include "DNA_world_types.h"
51 #include "DNA_object_types.h"
52
53 #include "BLI_blenlib.h"
54 #include "BLI_dynstr.h"
55 #include "BLI_string_utils.h"
56 #include "BLI_utildefines.h"
57
58 #include "BLT_translation.h"
59
60 #include "BKE_ipo.h"
61 #include "BKE_animsys.h"
62 #include "BKE_action.h"
63 #include "BKE_fcurve.h"
64 #include "BKE_global.h"
65 #include "BKE_key.h"
66 #include "BKE_library.h"
67 #include "BKE_main.h"
68 #include "BKE_nla.h"
69 #include "BKE_sequencer.h"
70
71 #include "CLG_log.h"
72
73 #include "MEM_guardedalloc.h"
74
75 #ifdef WIN32
76 #  include "BLI_math_base.h" /* M_PI */
77 #endif
78
79 static CLG_LogRef LOG = {"bke.ipo"};
80
81 /* *************************************************** */
82 /* Old-Data Freeing Tools */
83
84 /* Free data from old IPO-Blocks (those which haven't been converted), but not IPO block itself */
85 // XXX this shouldn't be necessary anymore, but may occur while not all data is converted yet
86 void BKE_ipo_free(Ipo *ipo)
87 {
88   IpoCurve *icu, *icn;
89   int n = 0;
90
91   for (icu = ipo->curve.first; icu; icu = icn) {
92     icn = icu->next;
93     n++;
94
95     if (icu->bezt) {
96       MEM_freeN(icu->bezt);
97     }
98     if (icu->bp) {
99       MEM_freeN(icu->bp);
100     }
101     if (icu->driver) {
102       MEM_freeN(icu->driver);
103     }
104
105     BLI_freelinkN(&ipo->curve, icu);
106   }
107
108   if (G.debug & G_DEBUG) {
109     printf("Freed %d (Unconverted) Ipo-Curves from IPO '%s'\n", n, ipo->id.name + 2);
110   }
111 }
112
113 /* *************************************************** */
114 /* ADRCODE to RNA-Path Conversion Code  - Special (Bitflags) */
115
116 /* Mapping Table for bitflag <-> RNA path */
117 typedef struct AdrBit2Path {
118   int bit;
119   const char *path;
120   int array_index;
121 } AdrBit2Path;
122
123 /* ----------------- */
124 /* Mapping Tables to use bits <-> RNA paths */
125
126 /* Object layers */
127 static AdrBit2Path ob_layer_bits[] = {
128     {(1 << 0), "layers", 0},   {(1 << 1), "layers", 1},   {(1 << 2), "layers", 2},
129     {(1 << 3), "layers", 3},   {(1 << 4), "layers", 4},   {(1 << 5), "layers", 5},
130     {(1 << 6), "layers", 6},   {(1 << 7), "layers", 7},   {(1 << 8), "layers", 8},
131     {(1 << 9), "layers", 9},   {(1 << 10), "layers", 10}, {(1 << 11), "layers", 11},
132     {(1 << 12), "layers", 12}, {(1 << 13), "layers", 13}, {(1 << 14), "layers", 14},
133     {(1 << 15), "layers", 15}, {(1 << 16), "layers", 16}, {(1 << 17), "layers", 17},
134     {(1 << 18), "layers", 18}, {(1 << 19), "layers", 19},
135 };
136
137 /* ----------------- */
138
139 /* quick macro for returning the appropriate array for adrcode_bitmaps_to_paths() */
140 #define RET_ABP(items) \
141   { \
142     *tot = sizeof(items) / sizeof(AdrBit2Path); \
143     return items; \
144   } \
145   (void)0
146
147 /* This function checks if a Blocktype+Adrcode combo, returning a mapping table */
148 static AdrBit2Path *adrcode_bitmaps_to_paths(int blocktype, int adrcode, int *tot)
149 {
150   /* Object layers */
151   if ((blocktype == ID_OB) && (adrcode == OB_LAY)) {
152     RET_ABP(ob_layer_bits);
153   }
154   // XXX TODO: add other types...
155
156   /* Normal curve */
157   return NULL;
158 }
159 #undef RET_ABP
160
161 /* *************************************************** */
162 /* ADRCODE to RNA-Path Conversion Code  - Standard */
163
164 /* Object types */
165 static const char *ob_adrcodes_to_paths(int adrcode, int *array_index)
166 {
167   /* set array index like this in-case nothing sets it correctly  */
168   *array_index = 0;
169
170   /* result depends on adrcode */
171   switch (adrcode) {
172     case OB_LOC_X:
173       *array_index = 0;
174       return "location";
175     case OB_LOC_Y:
176       *array_index = 1;
177       return "location";
178     case OB_LOC_Z:
179       *array_index = 2;
180       return "location";
181     case OB_DLOC_X:
182       *array_index = 0;
183       return "delta_location";
184     case OB_DLOC_Y:
185       *array_index = 1;
186       return "delta_location";
187     case OB_DLOC_Z:
188       *array_index = 2;
189       return "delta_location";
190
191     case OB_ROT_X:
192       *array_index = 0;
193       return "rotation_euler";
194     case OB_ROT_Y:
195       *array_index = 1;
196       return "rotation_euler";
197     case OB_ROT_Z:
198       *array_index = 2;
199       return "rotation_euler";
200     case OB_DROT_X:
201       *array_index = 0;
202       return "delta_rotation_euler";
203     case OB_DROT_Y:
204       *array_index = 1;
205       return "delta_rotation_euler";
206     case OB_DROT_Z:
207       *array_index = 2;
208       return "delta_rotation_euler";
209
210     case OB_SIZE_X:
211       *array_index = 0;
212       return "scale";
213     case OB_SIZE_Y:
214       *array_index = 1;
215       return "scale";
216     case OB_SIZE_Z:
217       *array_index = 2;
218       return "scale";
219     case OB_DSIZE_X:
220       *array_index = 0;
221       return "delta_scale";
222     case OB_DSIZE_Y:
223       *array_index = 1;
224       return "delta_scale";
225     case OB_DSIZE_Z:
226       *array_index = 2;
227       return "delta_scale";
228     case OB_COL_R:
229       *array_index = 0;
230       return "color";
231     case OB_COL_G:
232       *array_index = 1;
233       return "color";
234     case OB_COL_B:
235       *array_index = 2;
236       return "color";
237     case OB_COL_A:
238       *array_index = 3;
239       return "color";
240 #if 0
241     case OB_PD_FSTR:
242       if (ob->pd) {
243         poin = &(ob->pd->f_strength);
244       }
245       break;
246     case OB_PD_FFALL:
247       if (ob->pd) {
248         poin = &(ob->pd->f_power);
249       }
250       break;
251     case OB_PD_SDAMP:
252       if (ob->pd) {
253         poin = &(ob->pd->pdef_damp);
254       }
255       break;
256     case OB_PD_RDAMP:
257       if (ob->pd) {
258         poin = &(ob->pd->pdef_rdamp);
259       }
260       break;
261     case OB_PD_PERM:
262       if (ob->pd) {
263         poin = &(ob->pd->pdef_perm);
264       }
265       break;
266     case OB_PD_FMAXD:
267       if (ob->pd) {
268         poin = &(ob->pd->maxdist);
269       }
270       break;
271 #endif
272   }
273
274   return NULL;
275 }
276
277 /* PoseChannel types
278  * NOTE: pchan name comes from 'actname' added earlier...
279  */
280 static const char *pchan_adrcodes_to_paths(int adrcode, int *array_index)
281 {
282   /* set array index like this in-case nothing sets it correctly  */
283   *array_index = 0;
284
285   /* result depends on adrcode */
286   switch (adrcode) {
287     case AC_QUAT_W:
288       *array_index = 0;
289       return "rotation_quaternion";
290     case AC_QUAT_X:
291       *array_index = 1;
292       return "rotation_quaternion";
293     case AC_QUAT_Y:
294       *array_index = 2;
295       return "rotation_quaternion";
296     case AC_QUAT_Z:
297       *array_index = 3;
298       return "rotation_quaternion";
299
300     case AC_EUL_X:
301       *array_index = 0;
302       return "rotation_euler";
303     case AC_EUL_Y:
304       *array_index = 1;
305       return "rotation_euler";
306     case AC_EUL_Z:
307       *array_index = 2;
308       return "rotation_euler";
309
310     case AC_LOC_X:
311       *array_index = 0;
312       return "location";
313     case AC_LOC_Y:
314       *array_index = 1;
315       return "location";
316     case AC_LOC_Z:
317       *array_index = 2;
318       return "location";
319
320     case AC_SIZE_X:
321       *array_index = 0;
322       return "scale";
323     case AC_SIZE_Y:
324       *array_index = 1;
325       return "scale";
326     case AC_SIZE_Z:
327       *array_index = 2;
328       return "scale";
329   }
330
331   /* for debugging only */
332   CLOG_ERROR(&LOG, "unmatched PoseChannel setting (code %d)", adrcode);
333   return NULL;
334 }
335
336 /* Constraint types */
337 static const char *constraint_adrcodes_to_paths(int adrcode, int *array_index)
338 {
339   /* set array index like this in-case nothing sets it correctly  */
340   *array_index = 0;
341
342   /* result depends on adrcode */
343   switch (adrcode) {
344     case CO_ENFORCE:
345       return "influence";
346     case CO_HEADTAIL:
347       /* XXX this needs to be wrapped in RNA.. probably then this path will be invalid. */
348       return "data.head_tail";
349   }
350
351   return NULL;
352 }
353
354 /* ShapeKey types
355  * NOTE: as we don't have access to the keyblock where the data comes from (for now),
356  *       we'll just use numerical indices for now...
357  */
358 static char *shapekey_adrcodes_to_paths(ID *id, int adrcode, int *UNUSED(array_index))
359 {
360   static char buf[128];
361
362   /* block will be attached to ID_KE block... */
363   if (adrcode == 0) {
364     /* adrcode=0 was the misnamed "speed" curve (now "evaluation time") */
365     BLI_strncpy(buf, "eval_time", sizeof(buf));
366   }
367   else {
368     /* Find the name of the ShapeKey (i.e. KeyBlock) to look for */
369     Key *key = (Key *)id;
370     KeyBlock *kb = BKE_keyblock_from_key(key, adrcode);
371
372     /* setting that we alter is the "value" (i.e. keyblock.curval) */
373     if (kb) {
374       /* Use the keyblock name, escaped, so that path lookups for this will work */
375       BLI_snprintf(buf, sizeof(buf), "key_blocks[\"%s\"].value", kb->name);
376     }
377     else {
378       /* Fallback - Use the adrcode as index directly, so that this can be manually fixed */
379       BLI_snprintf(buf, sizeof(buf), "key_blocks[%d].value", adrcode);
380     }
381   }
382   return buf;
383 }
384
385 /* MTex (Texture Slot) types */
386 static const char *mtex_adrcodes_to_paths(int adrcode, int *UNUSED(array_index))
387 {
388   const char *base = NULL, *prop = NULL;
389   static char buf[128];
390
391   /* base part of path */
392   if (adrcode & MA_MAP1) {
393     base = "textures[0]";
394   }
395   else if (adrcode & MA_MAP2) {
396     base = "textures[1]";
397   }
398   else if (adrcode & MA_MAP3) {
399     base = "textures[2]";
400   }
401   else if (adrcode & MA_MAP4) {
402     base = "textures[3]";
403   }
404   else if (adrcode & MA_MAP5) {
405     base = "textures[4]";
406   }
407   else if (adrcode & MA_MAP6) {
408     base = "textures[5]";
409   }
410   else if (adrcode & MA_MAP7) {
411     base = "textures[6]";
412   }
413   else if (adrcode & MA_MAP8) {
414     base = "textures[7]";
415   }
416   else if (adrcode & MA_MAP9) {
417     base = "textures[8]";
418   }
419   else if (adrcode & MA_MAP10) {
420     base = "textures[9]";
421   }
422   else if (adrcode & MA_MAP11) {
423     base = "textures[10]";
424   }
425   else if (adrcode & MA_MAP12) {
426     base = "textures[11]";
427   }
428   else if (adrcode & MA_MAP13) {
429     base = "textures[12]";
430   }
431   else if (adrcode & MA_MAP14) {
432     base = "textures[13]";
433   }
434   else if (adrcode & MA_MAP15) {
435     base = "textures[14]";
436   }
437   else if (adrcode & MA_MAP16) {
438     base = "textures[15]";
439   }
440   else if (adrcode & MA_MAP17) {
441     base = "textures[16]";
442   }
443   else if (adrcode & MA_MAP18) {
444     base = "textures[17]";
445   }
446
447   /* property identifier for path */
448   adrcode = (adrcode & (MA_MAP1 - 1));
449   switch (adrcode) {
450 #if 0  // XXX these are not wrapped in RNA yet!
451     case MAP_OFS_X:
452       poin = &(mtex->ofs[0]);
453       break;
454     case MAP_OFS_Y:
455       poin = &(mtex->ofs[1]);
456       break;
457     case MAP_OFS_Z:
458       poin = &(mtex->ofs[2]);
459       break;
460     case MAP_SIZE_X:
461       poin = &(mtex->size[0]);
462       break;
463     case MAP_SIZE_Y:
464       poin = &(mtex->size[1]);
465       break;
466     case MAP_SIZE_Z:
467       poin = &(mtex->size[2]);
468       break;
469     case MAP_R:
470       poin = &(mtex->r);
471       break;
472     case MAP_G:
473       poin = &(mtex->g);
474       break;
475     case MAP_B:
476       poin = &(mtex->b);
477       break;
478     case MAP_DVAR:
479       poin = &(mtex->def_var);
480       break;
481     case MAP_COLF:
482       poin = &(mtex->colfac);
483       break;
484     case MAP_NORF:
485       poin = &(mtex->norfac);
486       break;
487     case MAP_VARF:
488       poin = &(mtex->varfac);
489       break;
490 #endif
491     case MAP_DISP:
492       prop = "warp_factor";
493       break;
494   }
495
496   /* only build and return path if there's a property */
497   if (prop) {
498     BLI_snprintf(buf, 128, "%s.%s", base, prop);
499     return buf;
500   }
501   else {
502     return NULL;
503   }
504 }
505
506 /* Texture types */
507 static const char *texture_adrcodes_to_paths(int adrcode, int *array_index)
508 {
509   /* set array index like this in-case nothing sets it correctly  */
510   *array_index = 0;
511
512   /* result depends on adrcode */
513   switch (adrcode) {
514     case TE_NSIZE:
515       return "noise_size";
516     case TE_TURB:
517       return "turbulence";
518
519     case TE_NDEPTH:  // XXX texture RNA undefined
520       // poin= &(tex->noisedepth); *type= IPO_SHORT; break;
521       break;
522     case TE_NTYPE:  // XXX texture RNA undefined
523       // poin= &(tex->noisetype); *type= IPO_SHORT; break;
524       break;
525
526     case TE_N_BAS1:
527       return "noise_basis";
528     case TE_N_BAS2:
529       return "noise_basis";  // XXX this is not yet defined in RNA...
530
531     /* voronoi */
532     case TE_VNW1:
533       *array_index = 0;
534       return "feature_weights";
535     case TE_VNW2:
536       *array_index = 1;
537       return "feature_weights";
538     case TE_VNW3:
539       *array_index = 2;
540       return "feature_weights";
541     case TE_VNW4:
542       *array_index = 3;
543       return "feature_weights";
544     case TE_VNMEXP:
545       return "minkovsky_exponent";
546     case TE_VN_DISTM:
547       return "distance_metric";
548     case TE_VN_COLT:
549       return "color_type";
550
551     /* distorted noise / voronoi */
552     case TE_ISCA:
553       return "noise_intensity";
554
555     /* distorted noise */
556     case TE_DISTA:
557       return "distortion_amount";
558
559     /* musgrave */
560     case TE_MG_TYP:  // XXX texture RNA undefined
561       //  poin= &(tex->stype); *type= IPO_SHORT; break;
562       break;
563     case TE_MGH:
564       return "highest_dimension";
565     case TE_MG_LAC:
566       return "lacunarity";
567     case TE_MG_OCT:
568       return "octaves";
569     case TE_MG_OFF:
570       return "offset";
571     case TE_MG_GAIN:
572       return "gain";
573
574     case TE_COL_R:
575       *array_index = 0;
576       return "rgb_factor";
577     case TE_COL_G:
578       *array_index = 1;
579       return "rgb_factor";
580     case TE_COL_B:
581       *array_index = 2;
582       return "rgb_factor";
583
584     case TE_BRIGHT:
585       return "brightness";
586     case TE_CONTRA:
587       return "contrast";
588   }
589
590   return NULL;
591 }
592
593 /* Material Types */
594 static const char *material_adrcodes_to_paths(int adrcode, int *array_index)
595 {
596   /* set array index like this in-case nothing sets it correctly  */
597   *array_index = 0;
598
599   /* result depends on adrcode */
600   switch (adrcode) {
601     case MA_COL_R:
602       *array_index = 0;
603       return "diffuse_color";
604     case MA_COL_G:
605       *array_index = 1;
606       return "diffuse_color";
607     case MA_COL_B:
608       *array_index = 2;
609       return "diffuse_color";
610
611     case MA_SPEC_R:
612       *array_index = 0;
613       return "specular_color";
614     case MA_SPEC_G:
615       *array_index = 1;
616       return "specular_color";
617     case MA_SPEC_B:
618       *array_index = 2;
619       return "specular_color";
620
621     case MA_MIR_R:
622       *array_index = 0;
623       return "mirror_color";
624     case MA_MIR_G:
625       *array_index = 1;
626       return "mirror_color";
627     case MA_MIR_B:
628       *array_index = 2;
629       return "mirror_color";
630
631     case MA_ALPHA:
632       return "alpha";
633
634     case MA_REF:
635       return "diffuse_intensity";
636
637     case MA_EMIT:
638       return "emit";
639
640     case MA_AMB:
641       return "ambient";
642
643     case MA_SPEC:
644       return "specular_intensity";
645
646     case MA_HARD:
647       return "specular_hardness";
648
649     case MA_SPTR:
650       return "specular_opacity";
651
652     case MA_IOR:
653       return "ior";
654
655     case MA_HASIZE:
656       return "halo.size";
657
658     case MA_TRANSLU:
659       return "translucency";
660
661     case MA_RAYM:
662       return "raytrace_mirror.reflect";
663
664     case MA_FRESMIR:
665       return "raytrace_mirror.fresnel";
666
667     case MA_FRESMIRI:
668       return "raytrace_mirror.fresnel_factor";
669
670     case MA_FRESTRA:
671       return "raytrace_transparency.fresnel";
672
673     case MA_FRESTRAI:
674       return "raytrace_transparency.fresnel_factor";
675
676     case MA_ADD:
677       return "halo.add";
678
679     default: /* for now, we assume that the others were MTex channels */
680       return mtex_adrcodes_to_paths(adrcode, array_index);
681   }
682
683   return NULL;
684 }
685
686 /* Camera Types */
687 static const char *camera_adrcodes_to_paths(int adrcode, int *array_index)
688 {
689   /* set array index like this in-case nothing sets it correctly  */
690   *array_index = 0;
691
692   /* result depends on adrcode */
693   switch (adrcode) {
694     case CAM_LENS:
695 #if 0   /* XXX this cannot be resolved easily... \
696          * perhaps we assume camera is perspective (works for most cases... */
697       if (ca->type == CAM_ORTHO) {
698         return "ortho_scale";
699       }
700       else {
701         return "lens";
702       }
703 #else   // XXX lazy hack for now...
704       return "lens";
705 #endif  // XXX this cannot be resolved easily
706
707     case CAM_STA:
708       return "clip_start";
709     case CAM_END:
710       return "clip_end";
711
712 #if 0   // XXX these are not defined in RNA
713     case CAM_YF_APERT:
714       poin = &(ca->YF_aperture);
715       break;
716     case CAM_YF_FDIST:
717       poin = &(ca->dof_distance);
718       break;
719 #endif  // XXX these are not defined in RNA
720
721     case CAM_SHIFT_X:
722       return "shift_x";
723     case CAM_SHIFT_Y:
724       return "shift_y";
725   }
726
727   /* unrecognized adrcode, or not-yet-handled ones! */
728   return NULL;
729 }
730
731 /* Light Types */
732 static const char *light_adrcodes_to_paths(int adrcode, int *array_index)
733 {
734   /* set array index like this in-case nothing sets it correctly  */
735   *array_index = 0;
736
737   /* result depends on adrcode */
738   switch (adrcode) {
739     case LA_ENERGY:
740       return "energy";
741
742     case LA_COL_R:
743       *array_index = 0;
744       return "color";
745     case LA_COL_G:
746       *array_index = 1;
747       return "color";
748     case LA_COL_B:
749       *array_index = 2;
750       return "color";
751
752     case LA_DIST:
753       return "distance";
754
755     case LA_SPOTSI:
756       return "spot_size";
757     case LA_SPOTBL:
758       return "spot_blend";
759
760     case LA_QUAD1:
761       return "linear_attenuation";
762     case LA_QUAD2:
763       return "quadratic_attenuation";
764
765     case LA_HALOINT:
766       return "halo_intensity";
767
768     default: /* for now, we assume that the others were MTex channels */
769       return mtex_adrcodes_to_paths(adrcode, array_index);
770   }
771
772   /* unrecognized adrcode, or not-yet-handled ones! */
773   return NULL;
774 }
775
776 /* Sound Types */
777 static const char *sound_adrcodes_to_paths(int adrcode, int *array_index)
778 {
779   /* set array index like this in-case nothing sets it correctly  */
780   *array_index = 0;
781
782   /* result depends on adrcode */
783   switch (adrcode) {
784     case SND_VOLUME:
785       return "volume";
786     case SND_PITCH:
787       return "pitch";
788       /* XXX Joshua -- I had wrapped panning in rna,
789        * but someone commented out, calling it "unused" */
790 #if 0
791     case SND_PANNING:
792       return "panning";
793 #endif
794     case SND_ATTEN:
795       return "attenuation";
796   }
797
798   /* unrecognized adrcode, or not-yet-handled ones! */
799   return NULL;
800 }
801
802 /* World Types */
803 static const char *world_adrcodes_to_paths(int adrcode, int *array_index)
804 {
805   /* set array index like this in-case nothing sets it correctly  */
806   *array_index = 0;
807
808   /* result depends on adrcode */
809   switch (adrcode) {
810     case WO_HOR_R:
811       *array_index = 0;
812       return "horizon_color";
813     case WO_HOR_G:
814       *array_index = 1;
815       return "horizon_color";
816     case WO_HOR_B:
817       *array_index = 2;
818       return "horizon_color";
819     case WO_ZEN_R:
820       *array_index = 0;
821       return "zenith_color";
822     case WO_ZEN_G:
823       *array_index = 1;
824       return "zenith_color";
825     case WO_ZEN_B:
826       *array_index = 2;
827       return "zenith_color";
828
829     case WO_EXPOS:
830       return "exposure";
831
832     case WO_MISI:
833       return "mist.intensity";
834     case WO_MISTDI:
835       return "mist.depth";
836     case WO_MISTSTA:
837       return "mist.start";
838     case WO_MISTHI:
839       return "mist.height";
840
841     default: /* for now, we assume that the others were MTex channels */
842       return mtex_adrcodes_to_paths(adrcode, array_index);
843   }
844
845   return NULL;
846 }
847
848 /* Particle Types */
849 static const char *particle_adrcodes_to_paths(int adrcode, int *array_index)
850 {
851   /* set array index like this in-case nothing sets it correctly  */
852   *array_index = 0;
853
854   /* result depends on adrcode */
855   switch (adrcode) {
856     case PART_CLUMP:
857       return "settings.clump_factor";
858     case PART_AVE:
859       return "settings.angular_velocity_factor";
860     case PART_SIZE:
861       return "settings.particle_size";
862     case PART_DRAG:
863       return "settings.drag_factor";
864     case PART_BROWN:
865       return "settings.brownian_factor";
866     case PART_DAMP:
867       return "settings.damp_factor";
868     case PART_LENGTH:
869       return "settings.length";
870     case PART_GRAV_X:
871       *array_index = 0;
872       return "settings.acceleration";
873     case PART_GRAV_Y:
874       *array_index = 1;
875       return "settings.acceleration";
876     case PART_GRAV_Z:
877       *array_index = 2;
878       return "settings.acceleration";
879     case PART_KINK_AMP:
880       return "settings.kink_amplitude";
881     case PART_KINK_FREQ:
882       return "settings.kink_frequency";
883     case PART_KINK_SHAPE:
884       return "settings.kink_shape";
885     case PART_BB_TILT:
886       return "settings.billboard_tilt";
887
888       /* PartDeflect needs to be sorted out properly in rna_object_force;
889        * If anyone else works on this, but is unfamiliar, these particular
890        * settings reference the particles of the system themselves
891        * being used as forces -- it will use the same rna structure
892        * as the similar object forces */
893 #if 0
894     case PART_PD_FSTR:
895       if (part->pd) {
896         poin = &(part->pd->f_strength);
897       }
898       break;
899     case PART_PD_FFALL:
900       if (part->pd) {
901         poin = &(part->pd->f_power);
902       }
903       break;
904     case PART_PD_FMAXD:
905       if (part->pd) {
906         poin = &(part->pd->maxdist);
907       }
908       break;
909     case PART_PD2_FSTR:
910       if (part->pd2) {
911         poin = &(part->pd2->f_strength);
912       }
913       break;
914     case PART_PD2_FFALL:
915       if (part->pd2) {
916         poin = &(part->pd2->f_power);
917       }
918       break;
919     case PART_PD2_FMAXD:
920       if (part->pd2) {
921         poin = &(part->pd2->maxdist);
922       }
923       break;
924 #endif
925   }
926
927   return NULL;
928 }
929
930 /* ------- */
931
932 /* Allocate memory for RNA-path for some property given a blocktype, adrcode,
933  * and 'root' parts of path.
934  *
935  * Input:
936  *     - id                      - the data-block that the curve's IPO block
937  *                                 is attached to and/or which the new paths will start from
938  *     - blocktype, adrcode      - determines setting to get
939  *     - actname, constname, seq - used to build path
940  * Output:
941  *     - array_index             - index in property's array (if applicable) to use
942  *     - return                  - the allocated path...
943  */
944 static char *get_rna_access(ID *id,
945                             int blocktype,
946                             int adrcode,
947                             char actname[],
948                             char constname[],
949                             Sequence *seq,
950                             int *array_index)
951 {
952   DynStr *path = BLI_dynstr_new();
953   const char *propname = NULL;
954   char *rpath = NULL;
955   char buf[512];
956   int dummy_index = 0;
957
958   /* hack: if constname is set, we can only be dealing with an Constraint curve */
959   if (constname) {
960     blocktype = ID_CO;
961   }
962
963   /* get property name based on blocktype */
964   switch (blocktype) {
965     case ID_OB: /* object */
966       propname = ob_adrcodes_to_paths(adrcode, &dummy_index);
967       break;
968
969     case ID_PO: /* pose channel */
970       propname = pchan_adrcodes_to_paths(adrcode, &dummy_index);
971       break;
972
973     case ID_KE: /* shapekeys */
974       propname = shapekey_adrcodes_to_paths(id, adrcode, &dummy_index);
975       break;
976
977     case ID_CO: /* constraint */
978       propname = constraint_adrcodes_to_paths(adrcode, &dummy_index);
979       break;
980
981     case ID_TE: /* texture */
982       propname = texture_adrcodes_to_paths(adrcode, &dummy_index);
983       break;
984
985     case ID_MA: /* material */
986       propname = material_adrcodes_to_paths(adrcode, &dummy_index);
987       break;
988
989     case ID_CA: /* camera */
990       propname = camera_adrcodes_to_paths(adrcode, &dummy_index);
991       break;
992
993     case ID_LA: /* light */
994       propname = light_adrcodes_to_paths(adrcode, &dummy_index);
995       break;
996
997     case ID_SO: /* sound */
998       propname = sound_adrcodes_to_paths(adrcode, &dummy_index);
999       break;
1000
1001     case ID_WO: /* world */
1002       propname = world_adrcodes_to_paths(adrcode, &dummy_index);
1003       break;
1004
1005     case ID_PA: /* particle */
1006       propname = particle_adrcodes_to_paths(adrcode, &dummy_index);
1007       break;
1008
1009     case ID_CU: /* curve */
1010       /* this used to be a 'dummy' curve which got evaluated on the fly...
1011        * now we've got real var for this!
1012        */
1013       propname = "eval_time";
1014       break;
1015
1016     /* XXX problematic blocktypes */
1017     case ID_SEQ: /* sequencer strip */
1018       // SEQ_FAC1:
1019       switch (adrcode) {
1020         case SEQ_FAC1:
1021           propname = "effect_fader";
1022           break;
1023         case SEQ_FAC_SPEED:
1024           propname = "speed_fader";
1025           break;
1026         case SEQ_FAC_OPACITY:
1027           propname = "blend_opacity";
1028           break;
1029       }
1030       //  poin= &(seq->facf0); // XXX this doesn't seem to be included anywhere in sequencer RNA...
1031       break;
1032
1033     /* special hacks */
1034     case -1:
1035       /* special case for rotdiff drivers... we don't need a property for this... */
1036       break;
1037
1038     /* TODO... add other blocktypes... */
1039     default:
1040       CLOG_WARN(&LOG, "No path for blocktype %d, adrcode %d yet", blocktype, adrcode);
1041       break;
1042   }
1043
1044   /* check if any property found
1045    * - blocktype < 0 is special case for a specific type of driver,
1046    *   where we don't need a property name...
1047    */
1048   if ((propname == NULL) && (blocktype > 0)) {
1049     /* nothing was found, so exit */
1050     if (array_index) {
1051       *array_index = 0;
1052     }
1053
1054     BLI_dynstr_free(path);
1055
1056     return NULL;
1057   }
1058   else {
1059     if (array_index) {
1060       *array_index = dummy_index;
1061     }
1062   }
1063
1064   /* 'buf' _must_ be initialized in this block */
1065   /* append preceding bits to path */
1066   /* note, strings are not escapted and they should be! */
1067   if ((actname && actname[0]) && (constname && constname[0])) {
1068     /* Constraint in Pose-Channel */
1069     BLI_snprintf(buf, sizeof(buf), "pose.bones[\"%s\"].constraints[\"%s\"]", actname, constname);
1070   }
1071   else if (actname && actname[0]) {
1072     if ((blocktype == ID_OB) && STREQ(actname, "Object")) {
1073       /* Actionified "Object" IPO's... no extra path stuff needed */
1074       buf[0] = '\0'; /* empty string */
1075     }
1076     else if ((blocktype == ID_KE) && STREQ(actname, "Shape")) {
1077       /* Actionified "Shape" IPO's -
1078        * these are forced onto object level via the action container there... */
1079       strcpy(buf, "data.shape_keys");
1080     }
1081     else {
1082       /* Pose-Channel */
1083       BLI_snprintf(buf, sizeof(buf), "pose.bones[\"%s\"]", actname);
1084     }
1085   }
1086   else if (constname && constname[0]) {
1087     /* Constraint in Object */
1088     BLI_snprintf(buf, sizeof(buf), "constraints[\"%s\"]", constname);
1089   }
1090   else if (seq) {
1091     /* Sequence names in Scene */
1092     BLI_snprintf(buf, sizeof(buf), "sequence_editor.sequences_all[\"%s\"]", seq->name + 2);
1093   }
1094   else {
1095     buf[0] = '\0'; /* empty string */
1096   }
1097
1098   BLI_dynstr_append(path, buf);
1099
1100   /* need to add dot before property if there was anything preceding this */
1101   if (buf[0]) {
1102     BLI_dynstr_append(path, ".");
1103   }
1104
1105   /* now write name of property */
1106   BLI_dynstr_append(path, propname);
1107
1108   /* if there was no array index pointer provided, add it to the path */
1109   if (array_index == NULL) {
1110     BLI_snprintf(buf, sizeof(buf), "[\"%d\"]", dummy_index);
1111     BLI_dynstr_append(path, buf);
1112   }
1113
1114   /* convert to normal MEM_malloc'd string */
1115   rpath = BLI_dynstr_get_cstring(path);
1116   BLI_dynstr_free(path);
1117
1118   /* return path... */
1119   return rpath;
1120 }
1121
1122 /* *************************************************** */
1123 /* Conversion Utilities */
1124
1125 /* Convert adrcodes to driver target transform channel types */
1126 static short adrcode_to_dtar_transchan(short adrcode)
1127 {
1128   switch (adrcode) {
1129     case OB_LOC_X:
1130       return DTAR_TRANSCHAN_LOCX;
1131     case OB_LOC_Y:
1132       return DTAR_TRANSCHAN_LOCY;
1133     case OB_LOC_Z:
1134       return DTAR_TRANSCHAN_LOCZ;
1135
1136     case OB_ROT_X:
1137       return DTAR_TRANSCHAN_ROTX;
1138     case OB_ROT_Y:
1139       return DTAR_TRANSCHAN_ROTY;
1140     case OB_ROT_Z:
1141       return DTAR_TRANSCHAN_ROTZ;
1142
1143     case OB_SIZE_X:
1144       return DTAR_TRANSCHAN_SCALEX;
1145     case OB_SIZE_Y:
1146       return DTAR_TRANSCHAN_SCALEX;
1147     case OB_SIZE_Z:
1148       return DTAR_TRANSCHAN_SCALEX;
1149
1150     default:
1151       return 0;
1152   }
1153 }
1154
1155 /* Convert IpoDriver to ChannelDriver - will free the old data (i.e. the old driver) */
1156 static ChannelDriver *idriver_to_cdriver(IpoDriver *idriver)
1157 {
1158   ChannelDriver *cdriver;
1159
1160   /* allocate memory for new driver */
1161   cdriver = MEM_callocN(sizeof(ChannelDriver), "ChannelDriver");
1162
1163   /* if 'pydriver', just copy data across */
1164   if (idriver->type == IPO_DRIVER_TYPE_PYTHON) {
1165     /* PyDriver only requires the expression to be copied */
1166     // FIXME: expression will be useless due to API changes, but at least not totally lost
1167     cdriver->type = DRIVER_TYPE_PYTHON;
1168     if (idriver->name[0]) {
1169       BLI_strncpy(cdriver->expression, idriver->name, sizeof(cdriver->expression));
1170     }
1171   }
1172   else {
1173     DriverVar *dvar = NULL;
1174     DriverTarget *dtar = NULL;
1175
1176     /* this should be ok for all types here... */
1177     cdriver->type = DRIVER_TYPE_AVERAGE;
1178
1179     /* what to store depends on the 'blocktype' - object or posechannel */
1180     if (idriver->blocktype == ID_AR) { /* PoseChannel */
1181       if (idriver->adrcode == OB_ROT_DIFF) {
1182         /* Rotational Difference requires a special type of variable */
1183         dvar = driver_add_new_variable(cdriver);
1184         driver_change_variable_type(dvar, DVAR_TYPE_ROT_DIFF);
1185
1186         /* first bone target */
1187         dtar = &dvar->targets[0];
1188         dtar->id = (ID *)idriver->ob;
1189         dtar->idtype = ID_OB;
1190         if (idriver->name[0]) {
1191           BLI_strncpy(dtar->pchan_name, idriver->name, sizeof(dtar->pchan_name));
1192         }
1193
1194         /* second bone target (name was stored in same var as the first one) */
1195         dtar = &dvar->targets[1];
1196         dtar->id = (ID *)idriver->ob;
1197         dtar->idtype = ID_OB;
1198         if (idriver->name[0]) {  // xxx... for safety
1199           BLI_strncpy(
1200               dtar->pchan_name, idriver->name + DRIVER_NAME_OFFS, sizeof(dtar->pchan_name));
1201         }
1202       }
1203       else {
1204         /* only a single variable, of type 'transform channel' */
1205         dvar = driver_add_new_variable(cdriver);
1206         driver_change_variable_type(dvar, DVAR_TYPE_TRANSFORM_CHAN);
1207
1208         /* only requires a single target */
1209         dtar = &dvar->targets[0];
1210         dtar->id = (ID *)idriver->ob;
1211         dtar->idtype = ID_OB;
1212         if (idriver->name[0]) {
1213           BLI_strncpy(dtar->pchan_name, idriver->name, sizeof(dtar->pchan_name));
1214         }
1215         dtar->transChan = adrcode_to_dtar_transchan(idriver->adrcode);
1216         dtar->flag |= DTAR_FLAG_LOCALSPACE; /* old drivers took local space */
1217       }
1218     }
1219     else { /* Object */
1220            /* only a single variable, of type 'transform channel' */
1221       dvar = driver_add_new_variable(cdriver);
1222       driver_change_variable_type(dvar, DVAR_TYPE_TRANSFORM_CHAN);
1223
1224       /* only requires single target */
1225       dtar = &dvar->targets[0];
1226       dtar->id = (ID *)idriver->ob;
1227       dtar->idtype = ID_OB;
1228       dtar->transChan = adrcode_to_dtar_transchan(idriver->adrcode);
1229     }
1230   }
1231
1232   /* return the new one */
1233   return cdriver;
1234 }
1235
1236 /* Add F-Curve to the correct list
1237  * - grpname is needed to be used as group name where relevant, and is usually derived from actname
1238  */
1239 static void fcurve_add_to_list(
1240     ListBase *groups, ListBase *list, FCurve *fcu, char *grpname, int muteipo)
1241 {
1242   /* If we're adding to an action, we will have groups to write to... */
1243   if (groups && grpname) {
1244     /* wrap the pointers given into a dummy action that we pass to the API func
1245      * and extract the resultant lists...
1246      */
1247     bAction tmp_act;
1248     bActionGroup *agrp = NULL;
1249
1250     /* init the temp action */
1251     memset(&tmp_act, 0, sizeof(bAction));  // XXX only enable this line if we get errors
1252     tmp_act.groups.first = groups->first;
1253     tmp_act.groups.last = groups->last;
1254     tmp_act.curves.first = list->first;
1255     tmp_act.curves.last = list->last;
1256     /* ... xxx, the other vars don't need to be filled in */
1257
1258     /* get the group to use */
1259     agrp = BKE_action_group_find_name(&tmp_act, grpname);
1260     /* no matching group, so add one */
1261     if (agrp == NULL) {
1262       /* Add a new group, and make it active */
1263       agrp = MEM_callocN(sizeof(bActionGroup), "bActionGroup");
1264
1265       agrp->flag = AGRP_SELECTED;
1266       if (muteipo) {
1267         agrp->flag |= AGRP_MUTED;
1268       }
1269
1270       BLI_strncpy(agrp->name, grpname, sizeof(agrp->name));
1271
1272       BLI_addtail(&tmp_act.groups, agrp);
1273       BLI_uniquename(&tmp_act.groups,
1274                      agrp,
1275                      DATA_("Group"),
1276                      '.',
1277                      offsetof(bActionGroup, name),
1278                      sizeof(agrp->name));
1279     }
1280
1281     /* add F-Curve to group */
1282     /* WARNING: this func should only need to look at the stuff we initialized,
1283      * if not, things may crash. */
1284     action_groups_add_channel(&tmp_act, agrp, fcu);
1285
1286     if (agrp->flag & AGRP_MUTED) { /* flush down */
1287       fcu->flag |= FCURVE_MUTED;
1288     }
1289
1290     /* set the output lists based on the ones in the temp action */
1291     groups->first = tmp_act.groups.first;
1292     groups->last = tmp_act.groups.last;
1293     list->first = tmp_act.curves.first;
1294     list->last = tmp_act.curves.last;
1295   }
1296   else {
1297     /* simply add the F-Curve to the end of the given list */
1298     BLI_addtail(list, fcu);
1299   }
1300 }
1301
1302 /**
1303  * Convert IPO-Curve to F-Curve (including Driver data), and free any of the old data that
1304  * is not relevant, BUT do not free the IPO-Curve itself...
1305  *
1306  * \param actname: name of Action-Channel (if applicable) that IPO-Curve's IPO-block belonged to.
1307  * \param constname: name of Constraint-Channel (if applicable)
1308  * that IPO-Curve's IPO-block belonged to \a seq.
1309  * \param seq: sequencer-strip (if applicable) that IPO-Curve's IPO-block belonged to.
1310  */
1311 static void icu_to_fcurves(ID *id,
1312                            ListBase *groups,
1313                            ListBase *list,
1314                            IpoCurve *icu,
1315                            char *actname,
1316                            char *constname,
1317                            Sequence *seq,
1318                            int muteipo)
1319 {
1320   AdrBit2Path *abp;
1321   FCurve *fcu;
1322   int totbits;
1323
1324   /* allocate memory for a new F-Curve */
1325   fcu = MEM_callocN(sizeof(FCurve), "FCurve");
1326
1327   /* convert driver */
1328   if (icu->driver) {
1329     fcu->driver = idriver_to_cdriver(icu->driver);
1330   }
1331
1332   /* copy flags */
1333   if (icu->flag & IPO_VISIBLE) {
1334     fcu->flag |= FCURVE_VISIBLE;
1335   }
1336   if (icu->flag & IPO_SELECT) {
1337     fcu->flag |= FCURVE_SELECTED;
1338   }
1339   if (icu->flag & IPO_ACTIVE) {
1340     fcu->flag |= FCURVE_ACTIVE;
1341   }
1342   if (icu->flag & IPO_MUTE) {
1343     fcu->flag |= FCURVE_MUTED;
1344   }
1345   if (icu->flag & IPO_PROTECT) {
1346     fcu->flag |= FCURVE_PROTECTED;
1347   }
1348
1349   /* set extrapolation */
1350   switch (icu->extrap) {
1351     case IPO_HORIZ: /* constant extrapolation */
1352     case IPO_DIR:   /* linear extrapolation */
1353     {
1354       /* just copy, as the new defines match the old ones... */
1355       fcu->extend = icu->extrap;
1356       break;
1357     }
1358     case IPO_CYCL:  /* cyclic extrapolation */
1359     case IPO_CYCLX: /* cyclic extrapolation + offset */
1360     {
1361       /* Add a new FModifier (Cyclic) instead of setting extend value
1362        * as that's the new equivalent of that option.
1363        */
1364       FModifier *fcm = add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES, fcu);
1365       FMod_Cycles *data = (FMod_Cycles *)fcm->data;
1366
1367       /* if 'offset' one is in use, set appropriate settings */
1368       if (icu->extrap == IPO_CYCLX) {
1369         data->before_mode = data->after_mode = FCM_EXTRAPOLATE_CYCLIC_OFFSET;
1370       }
1371       else {
1372         data->before_mode = data->after_mode = FCM_EXTRAPOLATE_CYCLIC;
1373       }
1374       break;
1375     }
1376   }
1377
1378   /* -------- */
1379
1380   /* get adrcode <-> bitflags mapping to handle nasty bitflag curves? */
1381   abp = adrcode_bitmaps_to_paths(icu->blocktype, icu->adrcode, &totbits);
1382   if (abp && totbits) {
1383     FCurve *fcurve;
1384     int b;
1385
1386     if (G.debug & G_DEBUG) {
1387       printf("\tconvert bitflag ipocurve, totbits = %d\n", totbits);
1388     }
1389
1390     /* add the 'only int values' flag */
1391     fcu->flag |= (FCURVE_INT_VALUES | FCURVE_DISCRETE_VALUES);
1392
1393     /* for each bit we have to remap + check for:
1394      * 1) we need to make copy the existing F-Curve data (fcu -> fcurve),
1395      *    except for the last one which will use the original
1396      * 2) copy the relevant path info across
1397      * 3) filter the keyframes for the flag of interest
1398      */
1399     for (b = 0; b < totbits; b++, abp++) {
1400       unsigned int i = 0;
1401
1402       /* make a copy of existing base-data if not the last curve */
1403       if (b < (totbits - 1)) {
1404         fcurve = copy_fcurve(fcu);
1405       }
1406       else {
1407         fcurve = fcu;
1408       }
1409
1410       /* set path */
1411       fcurve->rna_path = BLI_strdup(abp->path);
1412       fcurve->array_index = abp->array_index;
1413
1414       /* Convert keyframes:
1415        * - Beztriples and bpoints are mutually exclusive,
1416        *   so we won't have both at the same time.
1417        * - Beztriples are more likely to be encountered as they are keyframes
1418        *   (the other type wasn't used yet).
1419        */
1420       fcurve->totvert = icu->totvert;
1421
1422       if (icu->bezt) {
1423         BezTriple *dst, *src;
1424
1425         /* allocate new array for keyframes/beztriples */
1426         fcurve->bezt = MEM_callocN(sizeof(BezTriple) * fcurve->totvert, "BezTriples");
1427
1428         /* loop through copying all BezTriples individually, as we need to modify a few things */
1429         for (dst = fcurve->bezt, src = icu->bezt, i = 0; i < fcurve->totvert; i++, dst++, src++) {
1430           /* firstly, copy BezTriple data */
1431           *dst = *src;
1432
1433           /* interpolation can only be constant... */
1434           dst->ipo = BEZT_IPO_CONST;
1435
1436           /* 'hide' flag is now used for keytype - only 'keyframes' existed before */
1437           dst->hide = BEZT_KEYTYPE_KEYFRAME;
1438
1439           /* auto-handles - per curve to per handle */
1440           if (icu->flag & IPO_AUTO_HORIZ) {
1441             if (dst->h1 == HD_AUTO) {
1442               dst->h1 = HD_AUTO_ANIM;
1443             }
1444             if (dst->h2 == HD_AUTO) {
1445               dst->h2 = HD_AUTO_ANIM;
1446             }
1447           }
1448
1449           /* correct values, by checking if the flag of interest is set */
1450           if (((int)(dst->vec[1][1])) & (abp->bit)) {
1451             dst->vec[0][1] = dst->vec[1][1] = dst->vec[2][1] = 1.0f;
1452           }
1453           else {
1454             dst->vec[0][1] = dst->vec[1][1] = dst->vec[2][1] = 0.0f;
1455           }
1456         }
1457       }
1458       else if (icu->bp) {
1459         /* TODO: need to convert from BPoint type to the more compact FPoint type...
1460          * but not priority, since no data used this. */
1461         // BPoint *bp;
1462         // FPoint *fpt;
1463       }
1464
1465       /* add new F-Curve to list */
1466       fcurve_add_to_list(groups, list, fcurve, actname, muteipo);
1467     }
1468   }
1469   else {
1470     unsigned int i = 0;
1471
1472     /* get rna-path
1473      * - we will need to set the 'disabled' flag if no path is able to be made (for now)
1474      */
1475     fcu->rna_path = get_rna_access(
1476         id, icu->blocktype, icu->adrcode, actname, constname, seq, &fcu->array_index);
1477     if (fcu->rna_path == NULL) {
1478       fcu->flag |= FCURVE_DISABLED;
1479     }
1480
1481     /* Convert keyframes:
1482      * - Beztriples and bpoints are mutually exclusive, so we won't have both at the same time.
1483      * - Beztriples are more likely to be encountered as they are keyframes
1484      *   (the other type wasn't used yet).
1485      */
1486     fcu->totvert = icu->totvert;
1487
1488     if (icu->bezt) {
1489       BezTriple *dst, *src;
1490
1491       /* allocate new array for keyframes/beztriples */
1492       fcu->bezt = MEM_callocN(sizeof(BezTriple) * fcu->totvert, "BezTriples");
1493
1494       /* loop through copying all BezTriples individually, as we need to modify a few things */
1495       for (dst = fcu->bezt, src = icu->bezt, i = 0; i < fcu->totvert; i++, dst++, src++) {
1496         /* firstly, copy BezTriple data */
1497         *dst = *src;
1498
1499         /* now copy interpolation from curve (if not already set) */
1500         if (icu->ipo != IPO_MIXED) {
1501           dst->ipo = icu->ipo;
1502         }
1503
1504         /* 'hide' flag is now used for keytype - only 'keyframes' existed before */
1505         dst->hide = BEZT_KEYTYPE_KEYFRAME;
1506
1507         /* auto-handles - per curve to per handle */
1508         if (icu->flag & IPO_AUTO_HORIZ) {
1509           if (dst->h1 == HD_AUTO) {
1510             dst->h1 = HD_AUTO_ANIM;
1511           }
1512           if (dst->h2 == HD_AUTO) {
1513             dst->h2 = HD_AUTO_ANIM;
1514           }
1515         }
1516
1517         /* correct values for euler rotation curves
1518          * - they were degrees/10
1519          * - we need radians for RNA to do the right thing
1520          */
1521         if (((icu->blocktype == ID_OB) && ELEM(icu->adrcode, OB_ROT_X, OB_ROT_Y, OB_ROT_Z)) ||
1522             ((icu->blocktype == ID_PO) && ELEM(icu->adrcode, AC_EUL_X, AC_EUL_Y, AC_EUL_Z))) {
1523           const float fac = (float)M_PI / 18.0f;  // 10.0f * M_PI/180.0f;
1524
1525           dst->vec[0][1] *= fac;
1526           dst->vec[1][1] *= fac;
1527           dst->vec[2][1] *= fac;
1528         }
1529
1530         /* correct values for path speed curves
1531          * - their values were 0-1
1532          * - we now need as 'frames'
1533          */
1534         if ((id) && (icu->blocktype == GS(id->name)) &&
1535             (fcu->rna_path && STREQ(fcu->rna_path, "eval_time"))) {
1536           Curve *cu = (Curve *)id;
1537
1538           dst->vec[0][1] *= cu->pathlen;
1539           dst->vec[1][1] *= cu->pathlen;
1540           dst->vec[2][1] *= cu->pathlen;
1541         }
1542
1543         /* correct times for rotation drivers
1544          * - need to go from degrees to radians...
1545          * - there's only really 1 target to worry about
1546          * - were also degrees/10
1547          */
1548         if (fcu->driver && fcu->driver->variables.first) {
1549           DriverVar *dvar = fcu->driver->variables.first;
1550           DriverTarget *dtar = &dvar->targets[0];
1551
1552           if (ELEM(dtar->transChan,
1553                    DTAR_TRANSCHAN_ROTX,
1554                    DTAR_TRANSCHAN_ROTY,
1555                    DTAR_TRANSCHAN_ROTZ)) {
1556             const float fac = (float)M_PI / 18.0f;
1557
1558             dst->vec[0][0] *= fac;
1559             dst->vec[1][0] *= fac;
1560             dst->vec[2][0] *= fac;
1561           }
1562         }
1563
1564         /* correct values for sequencer curves, that were not locked to frame */
1565         if (seq && (seq->flag & SEQ_IPO_FRAME_LOCKED) == 0) {
1566           const float mul = (seq->enddisp - seq->startdisp) / 100.0f;
1567           const float offset = seq->startdisp;
1568
1569           dst->vec[0][0] *= mul;
1570           dst->vec[0][0] += offset;
1571
1572           dst->vec[1][0] *= mul;
1573           dst->vec[1][0] += offset;
1574
1575           dst->vec[2][0] *= mul;
1576           dst->vec[2][0] += offset;
1577         }
1578       }
1579     }
1580     else if (icu->bp) {
1581       /* TODO: need to convert from BPoint type to the more compact FPoint type...
1582        * but not priority, since no data used this */
1583       // BPoint *bp;
1584       // FPoint *fpt;
1585     }
1586
1587     /* add new F-Curve to list */
1588     fcurve_add_to_list(groups, list, fcu, actname, muteipo);
1589   }
1590 }
1591
1592 /* ------------------------- */
1593
1594 /* Convert IPO-block (i.e. all its IpoCurves) to the new system.
1595  * This does not assume that any ID or AnimData uses it, but does assume that
1596  * it is given two lists, which it will perform driver/animation-data separation.
1597  */
1598 static void ipo_to_animato(ID *id,
1599                            Ipo *ipo,
1600                            char actname[],
1601                            char constname[],
1602                            Sequence *seq,
1603                            ListBase *animgroups,
1604                            ListBase *anim,
1605                            ListBase *drivers)
1606 {
1607   IpoCurve *icu;
1608
1609   /* sanity check */
1610   if (ELEM(NULL, ipo, anim, drivers)) {
1611     return;
1612   }
1613
1614   if (G.debug & G_DEBUG) {
1615     printf("ipo_to_animato\n");
1616   }
1617
1618   /* validate actname and constname
1619    * - clear actname if it was one of the generic <builtin> ones (i.e. 'Object', or 'Shapes')
1620    * - actname can then be used to assign F-Curves in Action to Action Groups
1621    *   (i.e. thus keeping the benefits that used to be provided by Action Channels for grouping
1622    *   F-Curves for bones). This may be added later... for now let's just dump without them...
1623    */
1624   if (actname) {
1625     if ((ipo->blocktype == ID_OB) && STREQ(actname, "Object")) {
1626       actname = NULL;
1627     }
1628     else if ((ipo->blocktype == ID_OB) && STREQ(actname, "Shape")) {
1629       actname = NULL;
1630     }
1631   }
1632
1633   /* loop over IPO-Curves, freeing as we progress */
1634   for (icu = ipo->curve.first; icu; icu = icu->next) {
1635     /* Since an IPO-Curve may end up being made into many F-Curves (i.e. bitflag curves),
1636      * we figure out the best place to put the channel,
1637      * then tell the curve-converter to just dump there. */
1638     if (icu->driver) {
1639       /* Blender 2.4x allowed empty drivers,
1640        * but we don't now, since they cause more trouble than they're worth. */
1641       if ((icu->driver->ob) || (icu->driver->type == IPO_DRIVER_TYPE_PYTHON)) {
1642         icu_to_fcurves(id, NULL, drivers, icu, actname, constname, seq, ipo->muteipo);
1643       }
1644       else {
1645         MEM_freeN(icu->driver);
1646         icu->driver = NULL;
1647       }
1648     }
1649     else {
1650       icu_to_fcurves(id, animgroups, anim, icu, actname, constname, seq, ipo->muteipo);
1651     }
1652   }
1653
1654   /* if this IPO block doesn't have any users after this one, free... */
1655   id_us_min(&ipo->id);
1656   if (ID_REAL_USERS(ipo) <= 0) {
1657     IpoCurve *icn;
1658
1659     for (icu = ipo->curve.first; icu; icu = icn) {
1660       icn = icu->next;
1661
1662       /* free driver */
1663       if (icu->driver) {
1664         MEM_freeN(icu->driver);
1665       }
1666
1667       /* free old data of curve now that it's no longer needed for converting any more curves */
1668       if (icu->bezt) {
1669         MEM_freeN(icu->bezt);
1670       }
1671       if (icu->bp) {
1672         MEM_freeN(icu->bezt);
1673       }
1674
1675       /* free this IPO-Curve */
1676       BLI_freelinkN(&ipo->curve, icu);
1677     }
1678   }
1679 }
1680
1681 /* Convert Action-block to new system, separating animation and drivers
1682  * New curves may not be converted directly into the given Action (i.e. for Actions linked
1683  * to Objects, where ob->ipo and ob->action need to be combined).
1684  * NOTE: we need to be careful here, as same data-structs are used for new system too!
1685  */
1686 static void action_to_animato(
1687     ID *id, bAction *act, ListBase *groups, ListBase *curves, ListBase *drivers)
1688 {
1689   bActionChannel *achan, *achann;
1690   bConstraintChannel *conchan, *conchann;
1691
1692   /* only continue if there are Action Channels (indicating unconverted data) */
1693   if (BLI_listbase_is_empty(&act->chanbase)) {
1694     return;
1695   }
1696
1697   /* get rid of all Action Groups */
1698   // XXX this is risky if there's some old + some new data in the Action...
1699   if (act->groups.first) {
1700     BLI_freelistN(&act->groups);
1701   }
1702
1703   /* loop through Action-Channels, converting data, freeing as we go */
1704   for (achan = act->chanbase.first; achan; achan = achann) {
1705     /* get pointer to next Action Channel */
1706     achann = achan->next;
1707
1708     /* convert Action Channel's IPO data */
1709     if (achan->ipo) {
1710       ipo_to_animato(id, achan->ipo, achan->name, NULL, NULL, groups, curves, drivers);
1711       id_us_min(&achan->ipo->id);
1712       achan->ipo = NULL;
1713     }
1714
1715     /* convert constraint channel IPO-data */
1716     for (conchan = achan->constraintChannels.first; conchan; conchan = conchann) {
1717       /* get pointer to next Constraint Channel */
1718       conchann = conchan->next;
1719
1720       /* convert Constraint Channel's IPO data */
1721       if (conchan->ipo) {
1722         ipo_to_animato(
1723             id, conchan->ipo, achan->name, conchan->name, NULL, groups, curves, drivers);
1724         id_us_min(&conchan->ipo->id);
1725         conchan->ipo = NULL;
1726       }
1727
1728       /* free Constraint Channel */
1729       BLI_freelinkN(&achan->constraintChannels, conchan);
1730     }
1731
1732     /* free Action Channel */
1733     BLI_freelinkN(&act->chanbase, achan);
1734   }
1735 }
1736
1737 /* ------------------------- */
1738
1739 /* Convert IPO-block (i.e. all its IpoCurves) for some ID to the new system
1740  * This assumes that AnimData has been added already. Separation of drivers
1741  * from animation data is accomplished here too...
1742  */
1743 static void ipo_to_animdata(
1744     Main *bmain, ID *id, Ipo *ipo, char actname[], char constname[], Sequence *seq)
1745 {
1746   AnimData *adt = BKE_animdata_from_id(id);
1747   ListBase anim = {NULL, NULL};
1748   ListBase drivers = {NULL, NULL};
1749
1750   /* sanity check */
1751   if (ELEM(NULL, id, ipo)) {
1752     return;
1753   }
1754   if (adt == NULL) {
1755     CLOG_ERROR(&LOG, "adt invalid");
1756     return;
1757   }
1758
1759   if (G.debug & G_DEBUG) {
1760     printf("ipo to animdata - ID:%s, IPO:%s, actname:%s constname:%s seqname:%s  curves:%d\n",
1761            id->name + 2,
1762            ipo->id.name + 2,
1763            (actname) ? actname : "<None>",
1764            (constname) ? constname : "<None>",
1765            (seq) ? (seq->name + 2) : "<None>",
1766            BLI_listbase_count(&ipo->curve));
1767   }
1768
1769   /* Convert curves to animato system
1770    * (separated into separate lists of F-Curves for animation and drivers),
1771    * and the try to put these lists in the right places, but do not free the lists here. */
1772   // XXX there shouldn't be any need for the groups, so don't supply pointer for that now...
1773   ipo_to_animato(id, ipo, actname, constname, seq, NULL, &anim, &drivers);
1774
1775   /* deal with animation first */
1776   if (anim.first) {
1777     if (G.debug & G_DEBUG) {
1778       printf("\thas anim\n");
1779     }
1780     /* try to get action */
1781     if (adt->action == NULL) {
1782       char nameBuf[MAX_ID_NAME];
1783
1784       BLI_snprintf(nameBuf, sizeof(nameBuf), "CDA:%s", ipo->id.name + 2);
1785
1786       adt->action = BKE_action_add(bmain, nameBuf);
1787       if (G.debug & G_DEBUG) {
1788         printf("\t\tadded new action - '%s'\n", nameBuf);
1789       }
1790     }
1791
1792     /* add F-Curves to action */
1793     BLI_movelisttolist(&adt->action->curves, &anim);
1794   }
1795
1796   /* deal with drivers */
1797   if (drivers.first) {
1798     if (G.debug & G_DEBUG) {
1799       printf("\thas drivers\n");
1800     }
1801     /* add drivers to end of driver stack */
1802     BLI_movelisttolist(&adt->drivers, &drivers);
1803   }
1804 }
1805
1806 /* Convert Action-block to new system
1807  * NOTE: we need to be careful here, as same data-structs are used for new system too!
1808  */
1809 static void action_to_animdata(ID *id, bAction *act)
1810 {
1811   AnimData *adt = BKE_animdata_from_id(id);
1812
1813   /* only continue if there are Action Channels (indicating unconverted data) */
1814   if (ELEM(NULL, adt, act->chanbase.first)) {
1815     return;
1816   }
1817
1818   /* check if we need to set this Action as the AnimData's action */
1819   if (adt->action == NULL) {
1820     /* set this Action as AnimData's Action */
1821     if (G.debug & G_DEBUG) {
1822       printf("act_to_adt - set adt action to act\n");
1823     }
1824     adt->action = act;
1825   }
1826
1827   /* convert Action data */
1828   action_to_animato(id, act, &adt->action->groups, &adt->action->curves, &adt->drivers);
1829 }
1830
1831 /* ------------------------- */
1832
1833 /* TODO:
1834  * - NLA group duplicators info
1835  * - NLA curve/stride modifiers... */
1836
1837 /* Convert NLA-Strip to new system */
1838 static void nlastrips_to_animdata(ID *id, ListBase *strips)
1839 {
1840   AnimData *adt = BKE_animdata_from_id(id);
1841   NlaTrack *nlt = NULL;
1842   NlaStrip *strip;
1843   bActionStrip *as, *asn;
1844
1845   /* for each one of the original strips, convert to a new strip and free the old... */
1846   for (as = strips->first; as; as = asn) {
1847     asn = as->next;
1848
1849     /* this old strip is only worth something if it had an action... */
1850     if (as->act) {
1851       /* convert Action data (if not yet converted), storing the results in the same Action */
1852       action_to_animato(id, as->act, &as->act->groups, &as->act->curves, &adt->drivers);
1853
1854       /* Create a new-style NLA-strip which references this Action,
1855        * then copy over relevant settings. */
1856       {
1857         /* init a new strip, and assign the action to it
1858          * - no need to muck around with the user-counts, since this is just
1859          *   passing over the ref to the new owner, not creating an additional ref
1860          */
1861         strip = MEM_callocN(sizeof(NlaStrip), "NlaStrip");
1862         strip->act = as->act;
1863
1864         /* endpoints */
1865         strip->start = as->start;
1866         strip->end = as->end;
1867         strip->actstart = as->actstart;
1868         strip->actend = as->actend;
1869
1870         /* action reuse */
1871         strip->repeat = as->repeat;
1872         strip->scale = as->scale;
1873         if (as->flag & ACTSTRIP_LOCK_ACTION) {
1874           strip->flag |= NLASTRIP_FLAG_SYNC_LENGTH;
1875         }
1876
1877         /* blending */
1878         strip->blendin = as->blendin;
1879         strip->blendout = as->blendout;
1880         strip->blendmode = (as->mode == ACTSTRIPMODE_ADD) ? NLASTRIP_MODE_ADD :
1881                                                             NLASTRIP_MODE_REPLACE;
1882         if (as->flag & ACTSTRIP_AUTO_BLENDS) {
1883           strip->flag |= NLASTRIP_FLAG_AUTO_BLENDS;
1884         }
1885
1886         /* assorted setting flags */
1887         if (as->flag & ACTSTRIP_SELECT) {
1888           strip->flag |= NLASTRIP_FLAG_SELECT;
1889         }
1890         if (as->flag & ACTSTRIP_ACTIVE) {
1891           strip->flag |= NLASTRIP_FLAG_ACTIVE;
1892         }
1893
1894         if (as->flag & ACTSTRIP_MUTE) {
1895           strip->flag |= NLASTRIP_FLAG_MUTED;
1896         }
1897         if (as->flag & ACTSTRIP_REVERSE) {
1898           strip->flag |= NLASTRIP_FLAG_REVERSE;
1899         }
1900
1901         /* by default, we now always extrapolate, while in the past this was optional */
1902         if ((as->flag & ACTSTRIP_HOLDLASTFRAME) == 0) {
1903           strip->extendmode = NLASTRIP_EXTEND_NOTHING;
1904         }
1905       }
1906
1907       /* try to add this strip to the current NLA-Track (i.e. the 'last' one on the stack atm) */
1908       if (BKE_nlatrack_add_strip(nlt, strip) == 0) {
1909         /* trying to add to the current failed (no space),
1910          * so add a new track to the stack, and add to that...
1911          */
1912         nlt = BKE_nlatrack_add(adt, NULL);
1913         BKE_nlatrack_add_strip(nlt, strip);
1914       }
1915
1916       /* ensure that strip has a name */
1917       BKE_nlastrip_validate_name(adt, strip);
1918     }
1919
1920     /* modifiers */
1921     // FIXME: for now, we just free them...
1922     if (as->modifiers.first) {
1923       BLI_freelistN(&as->modifiers);
1924     }
1925
1926     /* free the old strip */
1927     BLI_freelinkN(strips, as);
1928   }
1929 }
1930
1931 /* *************************************************** */
1932 /* External API - Only Called from do_versions() */
1933
1934 /* Called from do_versions() in readfile.c to convert the old 'IPO/adrcode' system
1935  * to the new 'Animato/RNA' system.
1936  *
1937  * The basic method used here, is to loop over data-blocks which have IPO-data,
1938  * and add those IPO's to new AnimData blocks as Actions.
1939  * Action/NLA data only works well for Objects, so these only need to be checked for there.
1940  *
1941  * Data that has been converted should be freed immediately, which means that it is immediately
1942  * clear which data-blocks have yet to be converted, and also prevent freeing errors when we exit.
1943  */
1944 // XXX currently done after all file reading...
1945 void do_versions_ipos_to_animato(Main *bmain)
1946 {
1947   ListBase drivers = {NULL, NULL};
1948   ID *id;
1949
1950   if (bmain == NULL) {
1951     CLOG_ERROR(&LOG, "Argh! Main is NULL");
1952     return;
1953   }
1954
1955   /* only convert if version is right */
1956   if (bmain->versionfile >= 250) {
1957     CLOG_WARN(&LOG, "Animation data too new to convert (Version %d)", bmain->versionfile);
1958     return;
1959   }
1960   else if (G.debug & G_DEBUG) {
1961     printf("INFO: Converting to Animato...\n");
1962   }
1963
1964   /* ----------- Animation Attached to Data -------------- */
1965
1966   /* objects */
1967   for (id = bmain->objects.first; id; id = id->next) {
1968     Object *ob = (Object *)id;
1969     bPoseChannel *pchan;
1970     bConstraint *con;
1971     bConstraintChannel *conchan, *conchann;
1972
1973     if (G.debug & G_DEBUG) {
1974       printf("\tconverting ob %s\n", id->name + 2);
1975     }
1976
1977     /* check if object has any animation data */
1978     if (ob->nlastrips.first) {
1979       /* Add AnimData block */
1980       BKE_animdata_add_id(id);
1981
1982       /* IPO first to take into any non-NLA'd Object Animation */
1983       if (ob->ipo) {
1984         ipo_to_animdata(bmain, id, ob->ipo, NULL, NULL, NULL);
1985         /* No need to id_us_min ipo ID here, ipo_to_animdata already does it. */
1986         ob->ipo = NULL;
1987       }
1988
1989       /* Action is skipped since it'll be used by some strip in the NLA anyway,
1990        * causing errors with evaluation in the new evaluation pipeline
1991        */
1992       if (ob->action) {
1993         id_us_min(&ob->action->id);
1994         ob->action = NULL;
1995       }
1996
1997       /* finally NLA */
1998       nlastrips_to_animdata(id, &ob->nlastrips);
1999     }
2000     else if ((ob->ipo) || (ob->action)) {
2001       /* Add AnimData block */
2002       AnimData *adt = BKE_animdata_add_id(id);
2003
2004       /* Action first - so that Action name get conserved */
2005       if (ob->action) {
2006         action_to_animdata(id, ob->action);
2007
2008         /* only decrease usercount if this Action isn't now being used by AnimData */
2009         if (ob->action != adt->action) {
2010           id_us_min(&ob->action->id);
2011           ob->action = NULL;
2012         }
2013       }
2014
2015       /* IPO second... */
2016       if (ob->ipo) {
2017         ipo_to_animdata(bmain, id, ob->ipo, NULL, NULL, NULL);
2018         /* No need to id_us_min ipo ID here, ipo_to_animdata already does it. */
2019         ob->ipo = NULL;
2020       }
2021     }
2022
2023     /* check PoseChannels for constraints with local data */
2024     if (ob->pose) {
2025       /* Verify if there's AnimData block */
2026       BKE_animdata_add_id(id);
2027
2028       for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2029         for (con = pchan->constraints.first; con; con = con->next) {
2030           /* if constraint has own IPO, convert add these to Object
2031            * (NOTE: they're most likely to be drivers too)
2032            */
2033           if (con->ipo) {
2034             /* although this was the constraint's local IPO, we still need to provide pchan + con
2035              * so that drivers can be added properly...
2036              */
2037             ipo_to_animdata(bmain, id, con->ipo, pchan->name, con->name, NULL);
2038             id_us_min(&con->ipo->id);
2039             con->ipo = NULL;
2040           }
2041         }
2042       }
2043     }
2044
2045     /* check constraints for local IPO's */
2046     for (con = ob->constraints.first; con; con = con->next) {
2047       /* if constraint has own IPO, convert add these to Object
2048        * (NOTE: they're most likely to be drivers too)
2049        */
2050       if (con->ipo) {
2051         /* Verify if there's AnimData block, just in case */
2052         BKE_animdata_add_id(id);
2053
2054         /* although this was the constraint's local IPO, we still need to provide con
2055          * so that drivers can be added properly...
2056          */
2057         ipo_to_animdata(bmain, id, con->ipo, NULL, con->name, NULL);
2058         id_us_min(&con->ipo->id);
2059         con->ipo = NULL;
2060       }
2061
2062       /* check for Action Constraint */
2063       // XXX do we really want to do this here?
2064     }
2065
2066     /* check constraint channels - we need to remove them anyway... */
2067     if (ob->constraintChannels.first) {
2068       /* Verify if there's AnimData block */
2069       BKE_animdata_add_id(id);
2070
2071       for (conchan = ob->constraintChannels.first; conchan; conchan = conchann) {
2072         /* get pointer to next Constraint Channel */
2073         conchann = conchan->next;
2074
2075         /* convert Constraint Channel's IPO data */
2076         if (conchan->ipo) {
2077           ipo_to_animdata(bmain, id, conchan->ipo, NULL, conchan->name, NULL);
2078           id_us_min(&conchan->ipo->id);
2079           conchan->ipo = NULL;
2080         }
2081
2082         /* free Constraint Channel */
2083         BLI_freelinkN(&ob->constraintChannels, conchan);
2084       }
2085     }
2086
2087     /* object's action will always be object-rooted */
2088     {
2089       AnimData *adt = BKE_animdata_from_id(id);
2090       if (adt && adt->action) {
2091         adt->action->idroot = ID_OB;
2092       }
2093     }
2094   }
2095
2096   /* shapekeys */
2097   for (id = bmain->shapekeys.first; id; id = id->next) {
2098     Key *key = (Key *)id;
2099
2100     if (G.debug & G_DEBUG) {
2101       printf("\tconverting key %s\n", id->name + 2);
2102     }
2103
2104     /* we're only interested in the IPO
2105      * NOTE: for later, it might be good to port these over to Object instead, as many of these
2106      * are likely to be drivers, but it's hard to trace that from here, so move this to Ob loop?
2107      */
2108     if (key->ipo) {
2109       /* Add AnimData block */
2110       AnimData *adt = BKE_animdata_add_id(id);
2111
2112       /* Convert Shapekey data... */
2113       ipo_to_animdata(bmain, id, key->ipo, NULL, NULL, NULL);
2114
2115       if (adt->action) {
2116         adt->action->idroot = key->ipo->blocktype;
2117       }
2118
2119       id_us_min(&key->ipo->id);
2120       key->ipo = NULL;
2121     }
2122   }
2123
2124   /* materials */
2125   for (id = bmain->materials.first; id; id = id->next) {
2126     Material *ma = (Material *)id;
2127
2128     if (G.debug & G_DEBUG) {
2129       printf("\tconverting material %s\n", id->name + 2);
2130     }
2131
2132     /* we're only interested in the IPO */
2133     if (ma->ipo) {
2134       /* Add AnimData block */
2135       AnimData *adt = BKE_animdata_add_id(id);
2136
2137       /* Convert Material data... */
2138       ipo_to_animdata(bmain, id, ma->ipo, NULL, NULL, NULL);
2139
2140       if (adt->action) {
2141         adt->action->idroot = ma->ipo->blocktype;
2142       }
2143
2144       id_us_min(&ma->ipo->id);
2145       ma->ipo = NULL;
2146     }
2147   }
2148
2149   /* worlds */
2150   for (id = bmain->worlds.first; id; id = id->next) {
2151     World *wo = (World *)id;
2152
2153     if (G.debug & G_DEBUG) {
2154       printf("\tconverting world %s\n", id->name + 2);
2155     }
2156
2157     /* we're only interested in the IPO */
2158     if (wo->ipo) {
2159       /* Add AnimData block */
2160       AnimData *adt = BKE_animdata_add_id(id);
2161
2162       /* Convert World data... */
2163       ipo_to_animdata(bmain, id, wo->ipo, NULL, NULL, NULL);
2164
2165       if (adt->action) {
2166         adt->action->idroot = wo->ipo->blocktype;
2167       }
2168
2169       id_us_min(&wo->ipo->id);
2170       wo->ipo = NULL;
2171     }
2172   }
2173
2174   /* sequence strips */
2175   for (id = bmain->scenes.first; id; id = id->next) {
2176     Scene *scene = (Scene *)id;
2177     Editing *ed = scene->ed;
2178     if (ed && ed->seqbasep) {
2179       Sequence *seq;
2180
2181       AnimData *adt = BKE_animdata_add_id(id);
2182
2183       SEQ_BEGIN (ed, seq) {
2184         IpoCurve *icu = (seq->ipo) ? seq->ipo->curve.first : NULL;
2185         short adrcode = SEQ_FAC1;
2186
2187         if (G.debug & G_DEBUG) {
2188           printf("\tconverting sequence strip %s\n", seq->name + 2);
2189         }
2190
2191         if (ELEM(NULL, seq->ipo, icu)) {
2192           seq->flag |= SEQ_USE_EFFECT_DEFAULT_FADE;
2193           continue;
2194         }
2195
2196         /* patch adrcode, so that we can map
2197          * to different DNA variables later
2198          * (semi-hack (tm) )
2199          */
2200         switch (seq->type) {
2201           case SEQ_TYPE_IMAGE:
2202           case SEQ_TYPE_META:
2203           case SEQ_TYPE_SCENE:
2204           case SEQ_TYPE_MOVIE:
2205           case SEQ_TYPE_COLOR:
2206             adrcode = SEQ_FAC_OPACITY;
2207             break;
2208           case SEQ_TYPE_SPEED:
2209             adrcode = SEQ_FAC_SPEED;
2210             break;
2211         }
2212         icu->adrcode = adrcode;
2213
2214         /* convert IPO */
2215         ipo_to_animdata(bmain, (ID *)scene, seq->ipo, NULL, NULL, seq);
2216
2217         if (adt->action) {
2218           adt->action->idroot = ID_SCE; /* scene-rooted */
2219         }
2220
2221         id_us_min(&seq->ipo->id);
2222         seq->ipo = NULL;
2223       }
2224       SEQ_END;
2225     }
2226   }
2227
2228   /* textures */
2229   for (id = bmain->textures.first; id; id = id->next) {
2230     Tex *te = (Tex *)id;
2231
2232     if (G.debug & G_DEBUG) {
2233       printf("\tconverting texture %s\n", id->name + 2);
2234     }
2235
2236     /* we're only interested in the IPO */
2237     if (te->ipo) {
2238       /* Add AnimData block */
2239       AnimData *adt = BKE_animdata_add_id(id);
2240
2241       /* Convert Texture data... */
2242       ipo_to_animdata(bmain, id, te->ipo, NULL, NULL, NULL);
2243
2244       if (adt->action) {
2245         adt->action->idroot = te->ipo->blocktype;
2246       }
2247
2248       id_us_min(&te->ipo->id);
2249       te->ipo = NULL;
2250     }
2251   }
2252
2253   /* cameras */
2254   for (id = bmain->cameras.first; id; id = id->next) {
2255     Camera *ca = (Camera *)id;
2256
2257     if (G.debug & G_DEBUG) {
2258       printf("\tconverting camera %s\n", id->name + 2);
2259     }
2260
2261     /* we're only interested in the IPO */
2262     if (ca->ipo) {
2263       /* Add AnimData block */
2264       AnimData *adt = BKE_animdata_add_id(id);
2265
2266       /* Convert Camera data... */
2267       ipo_to_animdata(bmain, id, ca->ipo, NULL, NULL, NULL);
2268
2269       if (adt->action) {
2270         adt->action->idroot = ca->ipo->blocktype;
2271       }
2272
2273       id_us_min(&ca->ipo->id);
2274       ca->ipo = NULL;
2275     }
2276   }
2277
2278   /* lights */
2279   for (id = bmain->lights.first; id; id = id->next) {
2280     Light *la = (Light *)id;
2281
2282     if (G.debug & G_DEBUG) {
2283       printf("\tconverting light %s\n", id->name + 2);
2284     }
2285
2286     /* we're only interested in the IPO */
2287     if (la->ipo) {
2288       /* Add AnimData block */
2289       AnimData *adt = BKE_animdata_add_id(id);
2290
2291       /* Convert Light data... */
2292       ipo_to_animdata(bmain, id, la->ipo, NULL, NULL, NULL);
2293
2294       if (adt->action) {
2295         adt->action->idroot = la->ipo->blocktype;
2296       }
2297
2298       id_us_min(&la->ipo->id);
2299       la->ipo = NULL;
2300     }
2301   }
2302
2303   /* curves */
2304   for (id = bmain->curves.first; id; id = id->next) {
2305     Curve *cu = (Curve *)id;
2306
2307     if (G.debug & G_DEBUG) {
2308       printf("\tconverting curve %s\n", id->name + 2);
2309     }
2310
2311     /* we're only interested in the IPO */
2312     if (cu->ipo) {
2313       /* Add AnimData block */
2314       AnimData *adt = BKE_animdata_add_id(id);
2315
2316       /* Convert Curve data... */
2317       ipo_to_animdata(bmain, id, cu->ipo, NULL, NULL, NULL);
2318
2319       if (adt->action) {
2320         adt->action->idroot = cu->ipo->blocktype;
2321       }
2322
2323       id_us_min(&cu->ipo->id);
2324       cu->ipo = NULL;
2325     }
2326   }
2327
2328   /* --------- Unconverted Animation Data ------------------ */
2329   /* For Animation data which may not be directly connected (i.e. not linked) to any other
2330    * data, we need to perform a separate pass to make sure that they are converted to standalone
2331    * Actions which may then be able to be reused. This does mean that we will be going over data
2332    * that's already been converted, but there are no problems with that.
2333    *
2334    * The most common case for this will be Action Constraints, or IPO's with Fake-Users.
2335    * We collect all drivers that were found into a temporary collection, and free them in one go,
2336    * as they're impossible to resolve.
2337    */
2338
2339   /* actions */
2340   for (id = bmain->actions.first; id; id = id->next) {
2341     bAction *act = (bAction *)id;
2342
2343     if (G.debug & G_DEBUG) {
2344       printf("\tconverting action %s\n", id->name + 2);
2345     }
2346
2347     /* if old action, it will be object-only... */
2348     if (act->chanbase.first) {
2349       act->idroot = ID_OB;
2350     }
2351
2352     /* be careful! some of the actions we encounter will be converted ones... */
2353     action_to_animato(NULL, act, &act->groups, &act->curves, &drivers);
2354   }
2355
2356   /* ipo's */
2357   for (id = bmain->ipo.first; id; id = id->next) {
2358     Ipo *ipo = (Ipo *)id;
2359
2360     if (G.debug & G_DEBUG) {
2361       printf("\tconverting ipo %s\n", id->name + 2);
2362     }
2363
2364     /* most likely this IPO has already been processed, so check if any curves left to convert */
2365     if (ipo->curve.first) {
2366       bAction *new_act;
2367
2368       /* add a new action for this, and convert all data into that action */
2369       new_act = BKE_action_add(bmain, id->name + 2);
2370       ipo_to_animato(NULL, ipo, NULL, NULL, NULL, NULL, &new_act->curves, &drivers);
2371       new_act->idroot = ipo->blocktype;
2372     }
2373
2374     /* clear fake-users, and set user-count to zero to make sure it is cleared on file-save */
2375     ipo->id.us = 0;
2376     ipo->id.flag &= ~LIB_FAKEUSER;
2377   }
2378
2379   /* free unused drivers from actions + ipos */
2380   free_fcurves(&drivers);
2381
2382   if (G.debug & G_DEBUG) {
2383     printf("INFO: Animato convert done\n");
2384   }
2385 }