COLLADA branch: merge from trunk -r 25745:26429.
[blender.git] / source / blender / blenkernel / intern / nla.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Joshua Leung (full recode)
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <stdlib.h>
31 #include <stddef.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <math.h>
35 #include <float.h>
36
37 #include "MEM_guardedalloc.h"
38
39 #include "BLI_blenlib.h"
40 #include "BLI_ghash.h"
41
42 #include "DNA_anim_types.h"
43 #include "DNA_action_types.h"
44
45 #include "BKE_animsys.h"
46 #include "BKE_action.h"
47 #include "BKE_fcurve.h"
48 #include "BKE_nla.h"
49 #include "BKE_blender.h"
50 #include "BKE_library.h"
51 #include "BKE_object.h"
52 #include "BKE_utildefines.h"
53
54 #include "RNA_access.h"
55 #include "nla_private.h"
56
57
58 #ifdef HAVE_CONFIG_H
59 #include <config.h>
60 #endif
61
62
63 /* *************************************************** */
64 /* Data Management */
65
66 /* Freeing ------------------------------------------- */
67
68 /* Remove the given NLA strip from the NLA track it occupies, free the strip's data,
69  * and the strip itself. 
70  */
71 void free_nlastrip (ListBase *strips, NlaStrip *strip)
72 {
73         NlaStrip *cs, *csn;
74         
75         /* sanity checks */
76         if (strip == NULL)
77                 return;
78                 
79         /* free child-strips */
80         for (cs= strip->strips.first; cs; cs= csn) {
81                 csn= cs->next;
82                 free_nlastrip(&strip->strips, cs);
83         }
84                 
85         /* remove reference to action */
86         if (strip->act)
87                 strip->act->id.us--;
88                 
89         /* free remapping info */
90         //if (strip->remap)
91         //      BKE_animremap_free();
92         
93         /* free own F-Curves */
94         free_fcurves(&strip->fcurves);
95         
96         /* free own F-Modifiers */
97         free_fmodifiers(&strip->modifiers);
98         
99         /* free the strip itself */
100         if (strips)
101                 BLI_freelinkN(strips, strip);
102         else
103                 MEM_freeN(strip);
104 }
105
106 /* Remove the given NLA track from the set of NLA tracks, free the track's data,
107  * and the track itself.
108  */
109 void free_nlatrack (ListBase *tracks, NlaTrack *nlt)
110 {
111         NlaStrip *strip, *stripn;
112         
113         /* sanity checks */
114         if (nlt == NULL)
115                 return;
116                 
117         /* free strips */
118         for (strip= nlt->strips.first; strip; strip= stripn) {
119                 stripn= strip->next;
120                 free_nlastrip(&nlt->strips, strip);
121         }
122         
123         /* free NLA track itself now */
124         if (tracks)
125                 BLI_freelinkN(tracks, nlt);
126         else
127                 MEM_freeN(nlt);
128 }
129
130 /* Free the elements of type NLA Tracks provided in the given list, but do not free
131  * the list itself since that is not free-standing
132  */
133 void free_nladata (ListBase *tracks)
134 {
135         NlaTrack *nlt, *nltn;
136         
137         /* sanity checks */
138         if ELEM(NULL, tracks, tracks->first)
139                 return;
140                 
141         /* free tracks one by one */
142         for (nlt= tracks->first; nlt; nlt= nltn) {
143                 nltn= nlt->next;
144                 free_nlatrack(tracks, nlt);
145         }
146         
147         /* clear the list's pointers to be safe */
148         tracks->first= tracks->last= NULL;
149 }
150
151 /* Copying ------------------------------------------- */
152
153 /* Copy NLA strip */
154 NlaStrip *copy_nlastrip (NlaStrip *strip)
155 {
156         NlaStrip *strip_d;
157         NlaStrip *cs, *cs_d;
158         
159         /* sanity check */
160         if (strip == NULL)
161                 return NULL;
162                 
163         /* make a copy */
164         strip_d= MEM_dupallocN(strip);
165         strip_d->next= strip_d->prev= NULL;
166         
167         /* increase user-count of action */
168         if (strip_d->act)
169                 strip_d->act->id.us++;
170                 
171         /* copy F-Curves and modifiers */
172         copy_fcurves(&strip_d->fcurves, &strip->fcurves);
173         copy_fmodifiers(&strip_d->modifiers, &strip->modifiers);
174         
175         /* make a copy of all the child-strips, one at a time */
176         strip_d->strips.first= strip_d->strips.last= NULL;
177         
178         for (cs= strip->strips.first; cs; cs= cs->next) {
179                 cs_d= copy_nlastrip(cs);
180                 BLI_addtail(&strip_d->strips, cs_d);
181         }
182         
183         /* return the strip */
184         return strip_d;
185 }
186
187 /* Copy NLA Track */
188 NlaTrack *copy_nlatrack (NlaTrack *nlt)
189 {
190         NlaStrip *strip, *strip_d;
191         NlaTrack *nlt_d;
192         
193         /* sanity check */
194         if (nlt == NULL)
195                 return NULL;
196                 
197         /* make a copy */
198         nlt_d= MEM_dupallocN(nlt);
199         nlt_d->next= nlt_d->prev= NULL;
200         
201         /* make a copy of all the strips, one at a time */
202         nlt_d->strips.first= nlt_d->strips.last= NULL;
203         
204         for (strip= nlt->strips.first; strip; strip= strip->next) {
205                 strip_d= copy_nlastrip(strip);
206                 BLI_addtail(&nlt_d->strips, strip_d);
207         }
208         
209         /* return the copy */
210         return nlt_d;
211 }
212
213 /* Copy all NLA data */
214 void copy_nladata (ListBase *dst, ListBase *src)
215 {
216         NlaTrack *nlt, *nlt_d;
217         
218         /* sanity checks */
219         if ELEM(NULL, dst, src)
220                 return;
221                 
222         /* clear out the destination list first for precautions... */
223         dst->first= dst->last= NULL;
224                 
225         /* copy each NLA-track, one at a time */
226         for (nlt= src->first; nlt; nlt= nlt->next) {
227                 /* make a copy, and add the copy to the destination list */
228                 nlt_d= copy_nlatrack(nlt);
229                 BLI_addtail(dst, nlt_d);
230         }
231 }
232
233 /* Adding ------------------------------------------- */
234
235 /* Add a NLA Track to the given AnimData 
236  *      - prev: NLA-Track to add the new one after
237  */
238 NlaTrack *add_nlatrack (AnimData *adt, NlaTrack *prev)
239 {
240         NlaTrack *nlt;
241         
242         /* sanity checks */
243         if (adt == NULL)
244                 return NULL;
245                 
246         /* allocate new track */
247         nlt= MEM_callocN(sizeof(NlaTrack), "NlaTrack");
248         
249         /* set settings requiring the track to not be part of the stack yet */
250         nlt->flag = NLATRACK_SELECTED;
251         nlt->index= BLI_countlist(&adt->nla_tracks);
252         
253         /* add track to stack, and make it the active one */
254         if (prev)
255                 BLI_insertlinkafter(&adt->nla_tracks, prev, nlt);
256         else
257                 BLI_addtail(&adt->nla_tracks, nlt);
258         BKE_nlatrack_set_active(&adt->nla_tracks, nlt);
259         
260         /* must have unique name, but we need to seed this */
261         sprintf(nlt->name, "NlaTrack");
262         BLI_uniquename(&adt->nla_tracks, nlt, "NlaTrack", '.', offsetof(NlaTrack, name), 64);
263         
264         /* return the new track */
265         return nlt;
266 }
267
268 /* Add a NLA Strip referencing the given Action */
269 NlaStrip *add_nlastrip (bAction *act)
270 {
271         NlaStrip *strip;
272         
273         /* sanity checks */
274         if (act == NULL)
275                 return NULL;
276                 
277         /* allocate new strip */
278         strip= MEM_callocN(sizeof(NlaStrip), "NlaStrip");
279         
280         /* generic settings 
281          *      - selected flag to highlight this to the user
282          *      - auto-blends to ensure that blend in/out values are automatically 
283          *        determined by overlaps of strips
284          *      - (XXX) synchronisation of strip-length in accordance with changes to action-length
285          *        is not done though, since this should only really happens in editmode for strips now
286          *        though this decision is still subject to further review...
287          */
288         strip->flag = NLASTRIP_FLAG_SELECT|NLASTRIP_FLAG_AUTO_BLENDS;
289         
290         /* assign the action reference */
291         strip->act= act;
292         id_us_plus(&act->id);
293         
294         /* determine initial range 
295          *      - strip length cannot be 0... ever...
296          */
297         calc_action_range(strip->act, &strip->actstart, &strip->actend, 0);
298         
299         strip->start = strip->actstart;
300         strip->end = (IS_EQ(strip->actstart, strip->actend)) ?  (strip->actstart + 1.0f): (strip->actend);
301         
302         /* strip should be referenced as-is */
303         strip->scale= 1.0f;
304         strip->repeat = 1.0f;
305         
306         /* return the new strip */
307         return strip;
308 }
309
310 /* Add new NLA-strip to the top of the NLA stack - i.e. into the last track if space, or a new one otherwise */
311 NlaStrip *add_nlastrip_to_stack (AnimData *adt, bAction *act)
312 {
313         NlaStrip *strip;
314         NlaTrack *nlt;
315         
316         /* sanity checks */
317         if ELEM(NULL, adt, act)
318                 return NULL;
319         
320         /* create a new NLA strip */
321         strip= add_nlastrip(act);
322         if (strip == NULL)
323                 return NULL;
324         
325         /* firstly try adding strip to last track, but if that fails, add to a new track */
326         if (BKE_nlatrack_add_strip(adt->nla_tracks.last, strip) == 0) {
327                 /* trying to add to the last track failed (no track or no space), 
328                  * so add a new track to the stack, and add to that...
329                  */
330                 nlt= add_nlatrack(adt, NULL);
331                 BKE_nlatrack_add_strip(nlt, strip);
332         }
333         
334         /* automatically name it too */
335         BKE_nlastrip_validate_name(adt, strip);
336         
337         /* returns the strip added */
338         return strip;
339 }
340
341 /* *************************************************** */
342 /* NLA Evaluation <-> Editing Stuff */
343
344 /* Strip Mapping ------------------------------------- */
345
346 /* non clipped mapping for strip-time <-> global time (for Action-Clips)
347  *      invert = convert action-strip time to global time 
348  */
349 static float nlastrip_get_frame_actionclip (NlaStrip *strip, float cframe, short mode)
350 {
351         float actlength, repeat, scale;
352         
353         /* get number of repeats */
354         if (IS_EQ(strip->repeat, 0.0f)) strip->repeat = 1.0f;
355         repeat = strip->repeat;
356         
357         /* scaling */
358         if (IS_EQ(strip->scale, 0.0f)) strip->scale= 1.0f;
359         scale = (float)fabs(strip->scale); /* scale must be positive - we've got a special flag for reversing */
360         
361         /* length of referenced action */
362         actlength = strip->actend - strip->actstart;
363         if (IS_EQ(actlength, 0.0f)) actlength = 1.0f;
364         
365         /* reversed = play strip backwards */
366         if (strip->flag & NLASTRIP_FLAG_REVERSE) {
367                 // FIXME: this won't work right with Graph Editor?
368                 if (mode == NLATIME_CONVERT_MAP) {
369                         return strip->end - scale*(cframe - strip->actstart);
370                 }
371                 else if (mode == NLATIME_CONVERT_UNMAP) {
372                         return strip->actend - (strip->end - cframe) / scale;   
373                 }
374                 else /* if (mode == NLATIME_CONVERT_EVAL) */{
375                         if (IS_EQ(cframe, strip->end) && IS_EQ(strip->repeat, ((int)strip->repeat))) {
376                                 /* this case prevents the motion snapping back to the first frame at the end of the strip 
377                                  * by catching the case where repeats is a whole number, which means that the end of the strip
378                                  * could also be interpreted as the end of the start of a repeat
379                                  */
380                                 return strip->actstart;
381                         }
382                         else {
383                                 /* - the 'fmod(..., actlength*scale)' is needed to get the repeats working
384                                  * - the '/ scale' is needed to ensure that scaling influences the timing within the repeat
385                                  */
386                                 return strip->actend - fmod(cframe - strip->start, actlength*scale) / scale; 
387                         }
388                 }
389         }
390         else {
391                 if (mode == NLATIME_CONVERT_MAP) {
392                         return strip->start + scale*(cframe - strip->actstart);
393                 }
394                 else if (mode == NLATIME_CONVERT_UNMAP) {
395                         return strip->actstart + (cframe - strip->start) / scale;
396                 }
397                 else /* if (mode == NLATIME_CONVERT_EVAL) */{
398                         if (IS_EQ(cframe, strip->end) && IS_EQ(strip->repeat, ((int)strip->repeat))) {
399                                 /* this case prevents the motion snapping back to the first frame at the end of the strip 
400                                  * by catching the case where repeats is a whole number, which means that the end of the strip
401                                  * could also be interpreted as the end of the start of a repeat
402                                  */
403                                 return strip->actend;
404                         }
405                         else {
406                                 /* - the 'fmod(..., actlength*scale)' is needed to get the repeats working
407                                  * - the '/ scale' is needed to ensure that scaling influences the timing within the repeat
408                                  */
409                                 return strip->actstart + fmod(cframe - strip->start, actlength*scale) / scale; 
410                         }
411                 }
412         }
413 }
414
415 /* non clipped mapping for strip-time <-> global time (for Transitions)
416  *      invert = convert action-strip time to global time 
417  */
418 static float nlastrip_get_frame_transition (NlaStrip *strip, float cframe, short mode)
419 {
420         float length;
421         
422         /* length of strip */
423         length= strip->end - strip->start;
424         
425         /* reversed = play strip backwards */
426         if (strip->flag & NLASTRIP_FLAG_REVERSE) {
427                 if (mode == NLATIME_CONVERT_MAP)
428                         return strip->end - (length * cframe);
429                 else
430                         return (strip->end - cframe) / length;
431         }
432         else {
433                 if (mode == NLATIME_CONVERT_MAP)
434                         return (length * cframe) + strip->start;
435                 else
436                         return (cframe - strip->start) / length;
437         }
438 }
439
440 /* non clipped mapping for strip-time <-> global time
441  *      mode = eNlaTime_ConvertModes[] -> NLATIME_CONVERT_*
442  *
443  * only secure for 'internal' (i.e. within AnimSys evaluation) operations,
444  * but should not be directly relied on for stuff which interacts with editors
445  */
446 float nlastrip_get_frame (NlaStrip *strip, float cframe, short mode)
447 {
448         switch (strip->type) {
449                 case NLASTRIP_TYPE_META: /* meta - for now, does the same as transition (is really just an empty container) */
450                 case NLASTRIP_TYPE_TRANSITION: /* transition */
451                         return nlastrip_get_frame_transition(strip, cframe, mode);
452                 
453                 case NLASTRIP_TYPE_CLIP: /* action-clip (default) */
454                 default:
455                         return nlastrip_get_frame_actionclip(strip, cframe, mode);
456         }       
457 }
458
459
460 /* Non clipped mapping for strip-time <-> global time
461  *      mode = eNlaTime_ConvertModesp[] -> NLATIME_CONVERT_*
462  *
463  * Public API method - perform this mapping using the given AnimData block
464  * and perform any necessary sanity checks on the value
465  */
466 float BKE_nla_tweakedit_remap (AnimData *adt, float cframe, short mode)
467 {
468         NlaStrip *strip;
469         
470         /* sanity checks 
471          *      - obviously we've got to have some starting data
472          *      - when not in tweakmode, the active Action does not have any scaling applied :)
473          *      - when in tweakmode, if the no-mapping flag is set, do not map
474          */
475         if ((adt == NULL) || (adt->flag & ADT_NLA_EDIT_ON)==0 || (adt->flag & ADT_NLA_EDIT_NOMAP))
476                 return cframe;
477                 
478         /* if the active-strip info has been stored already, access this, otherwise look this up
479          * and store for (very probable) future usage
480          */
481         if (adt->actstrip == NULL) {
482                 NlaTrack *nlt= BKE_nlatrack_find_active(&adt->nla_tracks);
483                 adt->actstrip= BKE_nlastrip_find_active(nlt);
484         }
485         strip= adt->actstrip;
486         
487         /* sanity checks 
488          *      - in rare cases, we may not be able to find this strip for some reason (internal error)
489          *      - for now, if the user has defined a curve to control the time, this correction cannot be performed
490          *        reliably...
491          */
492         if ((strip == NULL) || (strip->flag & NLASTRIP_FLAG_USR_TIME))
493                 return cframe;
494                 
495         /* perform the correction now... */
496         return nlastrip_get_frame(strip, cframe, mode);
497 }
498
499 /* *************************************************** */
500 /* NLA API */
501
502 /* List of Strips ------------------------------------ */
503 /* (these functions are used for NLA-Tracks and also for nested/meta-strips) */
504
505 /* Check if there is any space in the given list to add the given strip */
506 short BKE_nlastrips_has_space (ListBase *strips, float start, float end)
507 {
508         NlaStrip *strip;
509         
510         /* sanity checks */
511         if ((strips == NULL) || IS_EQ(start, end))
512                 return 0;
513         if (start > end) {
514                 puts("BKE_nlastrips_has_space() error... start and end arguments swapped");
515                 SWAP(float, start, end);
516         }
517         
518         /* loop over NLA strips checking for any overlaps with this area... */
519         for (strip= strips->first; strip; strip= strip->next) {
520                 /* if start frame of strip is past the target end-frame, that means that
521                  * we've gone past the window we need to check for, so things are fine
522                  */
523                 if (strip->start > end)
524                         return 1;
525                 
526                 /* if the end of the strip is greater than either of the boundaries, the range
527                  * must fall within the extents of the strip
528                  */
529                 if ((strip->end > start) || (strip->end > end))
530                         return 0;
531         }
532         
533         /* if we are still here, we haven't encountered any overlapping strips */
534         return 1;
535 }
536
537 /* Rearrange the strips in the track so that they are always in order 
538  * (usually only needed after a strip has been moved) 
539  */
540 void BKE_nlastrips_sort_strips (ListBase *strips)
541 {
542         ListBase tmp = {NULL, NULL};
543         NlaStrip *strip, *sstrip, *stripn;
544         
545         /* sanity checks */
546         if ELEM(NULL, strips, strips->first)
547                 return;
548         
549         /* we simply perform insertion sort on this list, since it is assumed that per track,
550          * there are only likely to be at most 5-10 strips
551          */
552         for (strip= strips->first; strip; strip= stripn) {
553                 short not_added = 1;
554                 
555                 stripn= strip->next;
556                 
557                 /* remove this strip from the list, and add it to the new list, searching from the end of 
558                  * the list, assuming that the lists are in order 
559                  */
560                 BLI_remlink(strips, strip);
561                 
562                 for (sstrip= tmp.last; sstrip; sstrip= sstrip->prev) {
563                         /* check if add after */
564                         if (sstrip->end <= strip->start) {
565                                 BLI_insertlinkafter(&tmp, sstrip, strip);
566                                 not_added= 0;
567                                 break;
568                         }
569                 }
570                 
571                 /* add before first? */
572                 if (not_added)
573                         BLI_addhead(&tmp, strip);
574         }
575         
576         /* reassign the start and end points of the strips */
577         strips->first= tmp.first;
578         strips->last= tmp.last;
579 }
580
581 /* Add the given NLA-Strip to the given list of strips, assuming that it 
582  * isn't currently a member of another list
583  */
584 short BKE_nlastrips_add_strip (ListBase *strips, NlaStrip *strip)
585 {
586         NlaStrip *ns;
587         short not_added = 1;
588         
589         /* sanity checks */
590         if ELEM(NULL, strips, strip)
591                 return 0;
592                 
593         /* check if any space to add */
594         if (BKE_nlastrips_has_space(strips, strip->start, strip->end)==0)
595                 return 0;
596         
597         /* find the right place to add the strip to the nominated track */
598         for (ns= strips->first; ns; ns= ns->next) {
599                 /* if current strip occurs after the new strip, add it before */
600                 if (ns->start > strip->end) {
601                         BLI_insertlinkbefore(strips, ns, strip);
602                         not_added= 0;
603                         break;
604                 }
605         }
606         if (not_added) {
607                 /* just add to the end of the list of the strips then... */
608                 BLI_addtail(strips, strip);
609         }
610         
611         /* added... */
612         return 1;
613 }
614
615
616 /* Meta-Strips ------------------------------------ */
617
618 /* Convert 'islands' (i.e. continuous string of) selected strips to be
619  * contained within 'Meta-Strips' which act as strips which contain strips.
620  *      temp: are the meta-strips to be created 'temporary' ones used for transforms?
621  */
622 void BKE_nlastrips_make_metas (ListBase *strips, short temp)
623 {
624         NlaStrip *mstrip = NULL;
625         NlaStrip *strip, *stripn;
626         
627         /* sanity checks */
628         if ELEM(NULL, strips, strips->first)
629                 return;
630         
631         /* group all continuous chains of selected strips into meta-strips */
632         for (strip= strips->first; strip; strip= stripn) {
633                 stripn= strip->next;
634                 
635                 if (strip->flag & NLASTRIP_FLAG_SELECT) {
636                         /* if there is an existing meta-strip, add this strip to it, otherwise, create a new one */
637                         if (mstrip == NULL) {
638                                 /* add a new meta-strip, and add it before the current strip that it will replace... */
639                                 mstrip= MEM_callocN(sizeof(NlaStrip), "Meta-NlaStrip");
640                                 mstrip->type = NLASTRIP_TYPE_META;
641                                 BLI_insertlinkbefore(strips, strip, mstrip);
642                                 
643                                 /* set flags */
644                                 mstrip->flag = NLASTRIP_FLAG_SELECT;
645                                 
646                                 /* set temp flag if appropriate (i.e. for transform-type editing) */
647                                 if (temp)
648                                         mstrip->flag |= NLASTRIP_FLAG_TEMP_META;
649                                         
650                                 /* set default repeat/scale values to prevent warnings */
651                                 mstrip->repeat= mstrip->scale= 1.0f;
652                                 
653                                 /* make its start frame be set to the start frame of the current strip */
654                                 mstrip->start= strip->start;
655                         }
656                         
657                         /* remove the selected strips from the track, and add to the meta */
658                         BLI_remlink(strips, strip);
659                         BLI_addtail(&mstrip->strips, strip);
660                         
661                         /* expand the meta's dimensions to include the newly added strip- i.e. its last frame */
662                         mstrip->end= strip->end;
663                 }
664                 else {
665                         /* current strip wasn't selected, so the end of 'island' of selected strips has been reached,
666                          * so stop adding strips to the current meta
667                          */
668                         mstrip= NULL;
669                 }
670         }
671 }
672
673 /* Split a meta-strip into a set of normal strips */
674 void BKE_nlastrips_clear_metastrip (ListBase *strips, NlaStrip *strip)
675 {
676         NlaStrip *cs, *csn;
677         
678         /* sanity check */
679         if ELEM(NULL, strips, strip)
680                 return;
681         
682         /* move each one of the meta-strip's children before the meta-strip
683          * in the list of strips after unlinking them from the meta-strip
684          */
685         for (cs= strip->strips.first; cs; cs= csn) {
686                 csn= cs->next;
687                 BLI_remlink(&strip->strips, cs);
688                 BLI_insertlinkbefore(strips, strip, cs);
689         }
690         
691         /* free the meta-strip now */
692         BLI_freelinkN(strips, strip);
693 }
694
695 /* Remove meta-strips (i.e. flatten the list of strips) from the top-level of the list of strips
696  *      sel: only consider selected meta-strips, otherwise all meta-strips are removed
697  *      onlyTemp: only remove the 'temporary' meta-strips used for transforms
698  */
699 void BKE_nlastrips_clear_metas (ListBase *strips, short onlySel, short onlyTemp)
700 {
701         NlaStrip *strip, *stripn;
702         
703         /* sanity checks */
704         if ELEM(NULL, strips, strips->first)
705                 return;
706         
707         /* remove meta-strips fitting the criteria of the arguments */
708         for (strip= strips->first; strip; strip= stripn) {
709                 stripn= strip->next;
710                 
711                 /* check if strip is a meta-strip */
712                 if (strip->type == NLASTRIP_TYPE_META) {
713                         /* if check if selection and 'temporary-only' considerations are met */
714                         if ((onlySel==0) || (strip->flag & NLASTRIP_FLAG_SELECT)) {
715                                 if ((!onlyTemp) || (strip->flag & NLASTRIP_FLAG_TEMP_META)) {
716                                         BKE_nlastrips_clear_metastrip(strips, strip);
717                                 }
718                         }
719                 }
720         }
721 }
722
723 /* Add the given NLA-Strip to the given Meta-Strip, assuming that the
724  * strip isn't attached to anyy list of strips 
725  */
726 short BKE_nlameta_add_strip (NlaStrip *mstrip, NlaStrip *strip)
727 {
728         /* sanity checks */
729         if ELEM(NULL, mstrip, strip)
730                 return 0;
731                 
732         /* firstly, check if the meta-strip has space for this */
733         if (BKE_nlastrips_has_space(&mstrip->strips, strip->start, strip->end) == 0)
734                 return 0;
735                 
736         /* check if this would need to be added to the ends of the meta,
737          * and subsequently, if the neighbouring strips allow us enough room
738          */
739         if (strip->start < mstrip->start) {
740                 /* check if strip to the left (if it exists) ends before the 
741                  * start of the strip we're trying to add 
742                  */
743                 if ((mstrip->prev == NULL) || (mstrip->prev->end <= strip->start)) {
744                         /* add strip to start of meta's list, and expand dimensions */
745                         BLI_addhead(&mstrip->strips, strip);
746                         mstrip->start= strip->start;
747                         
748                         return 1;
749                 }
750                 else /* failed... no room before */
751                         return 0;
752         }
753         else if (strip->end > mstrip->end) {
754                 /* check if strip to the right (if it exists) starts before the 
755                  * end of the strip we're trying to add 
756                  */
757                 if ((mstrip->next == NULL) || (mstrip->next->start >= strip->end)) {
758                         /* add strip to end of meta's list, and expand dimensions */
759                         BLI_addtail(&mstrip->strips, strip);
760                         mstrip->end= strip->end;
761                         
762                         return 1;
763                 }
764                 else /* failed... no room after */
765                         return 0;
766         }
767         else {
768                 /* just try to add to the meta-strip (no dimension changes needed) */
769                 return BKE_nlastrips_add_strip(&mstrip->strips, strip);
770         }
771 }
772
773 /* Adjust the settings of NLA-Strips contained within a Meta-Strip (recursively), 
774  * until the Meta-Strips children all fit within the Meta-Strip's new dimensions
775  */
776 void BKE_nlameta_flush_transforms (NlaStrip *mstrip) 
777 {
778         NlaStrip *strip;
779         float oStart, oEnd, offset;
780         float oLen, nLen;
781         short scaleChanged= 0;
782         
783         /* sanity checks 
784          *      - strip must exist
785          *      - strip must be a meta-strip with some contents
786          */
787         if ELEM(NULL, mstrip, mstrip->strips.first)
788                 return;
789         if (mstrip->type != NLASTRIP_TYPE_META)
790                 return;
791                 
792         /* get the original start/end points, and calculate the start-frame offset
793          *      - these are simply the start/end frames of the child strips, 
794          *        since we assume they weren't transformed yet
795          */
796         oStart= ((NlaStrip *)mstrip->strips.first)->start;
797         oEnd= ((NlaStrip *)mstrip->strips.last)->end;
798         offset= mstrip->start - oStart;
799         
800         /* optimisation:
801          * don't flush if nothing changed yet
802          *      TODO: maybe we need a flag to say always flush?
803          */
804         if (IS_EQ(oStart, mstrip->start) && IS_EQ(oEnd, mstrip->end))
805                 return;
806         
807         /* check if scale changed */
808         oLen = oEnd - oStart;
809         nLen = mstrip->end - mstrip->start;
810         if (IS_EQ(nLen, oLen) == 0)
811                 scaleChanged= 1;
812         
813         /* for each child-strip, calculate new start/end points based on this new info */
814         for (strip= mstrip->strips.first; strip; strip= strip->next) {
815                 if (scaleChanged) {
816                         PointerRNA ptr;
817                         float p1, p2, nStart, nEnd;
818                         
819                         /* compute positions of endpoints relative to old extents of strip */
820                         p1= (strip->start - oStart) / oLen;
821                         p2= (strip->end - oStart) / oLen;
822                         
823                         /* compute the new strip endpoints using the proportions */
824                         nStart= (p1 * nLen) + mstrip->start;
825                         nEnd= (p2 * nLen) + mstrip->start;
826                         
827                         /* firstly, apply the new positions manually, then apply using RNA 
828                          *      - first time is to make sure no truncation errors from one endpoint not being 
829                          *        set yet occur
830                          *      - second time is to make sure scale is computed properly...
831                          */
832                         strip->start= nStart;
833                         strip->end= nEnd;
834                         
835                         RNA_pointer_create(NULL, &RNA_NlaStrip, strip, &ptr);
836                         RNA_float_set(&ptr, "start_frame", nStart);
837                         RNA_float_set(&ptr, "end_frame", nEnd);
838                 }
839                 else {
840                         /* just apply the changes in offset to both ends of the strip */
841                         strip->start += offset;
842                         strip->end += offset;
843                 }
844                 
845                 /* finally, make sure the strip's children (if it is a meta-itself), get updated */
846                 BKE_nlameta_flush_transforms(strip);
847         }
848 }
849
850 /* NLA-Tracks ---------------------------------------- */
851
852 /* Find the active NLA-track for the given stack */
853 NlaTrack *BKE_nlatrack_find_active (ListBase *tracks)
854 {
855         NlaTrack *nlt;
856         
857         /* sanity check */
858         if ELEM(NULL, tracks, tracks->first)
859                 return NULL;
860                 
861         /* try to find the first active track */
862         for (nlt= tracks->first; nlt; nlt= nlt->next) {
863                 if (nlt->flag & NLATRACK_ACTIVE)
864                         return nlt;
865         }
866         
867         /* none found */
868         return NULL;
869 }
870
871 /* Toggle the 'solo' setting for the given NLA-track, making sure that it is the only one
872  * that has this status in its AnimData block.
873  */
874 void BKE_nlatrack_solo_toggle (AnimData *adt, NlaTrack *nlt)
875 {
876         NlaTrack *nt;
877         
878         /* sanity check */
879         if ELEM(NULL, adt, adt->nla_tracks.first)
880                 return;
881                 
882         /* firstly, make sure 'solo' flag for all tracks is disabled */
883         for (nt= adt->nla_tracks.first; nt; nt= nt->next) {
884                 if (nt != nlt)
885                         nt->flag &= ~NLATRACK_SOLO;
886         }
887                 
888         /* now, enable 'solo' for the given track if appropriate */
889         if (nlt) {
890                 /* toggle solo status */
891                 nlt->flag ^= NLATRACK_SOLO;
892                 
893                 /* set or clear solo-status on AnimData */
894                 if (nlt->flag & NLATRACK_SOLO)
895                         adt->flag |= ADT_NLA_SOLO_TRACK;
896                 else
897                         adt->flag &= ~ADT_NLA_SOLO_TRACK;
898         }
899         else
900                 adt->flag &= ~ADT_NLA_SOLO_TRACK;
901 }
902
903 /* Make the given NLA-track the active one for the given stack. If no track is provided, 
904  * this function can be used to simply deactivate all the NLA tracks in the given stack too.
905  */
906 void BKE_nlatrack_set_active (ListBase *tracks, NlaTrack *nlt_a)
907 {
908         NlaTrack *nlt;
909         
910         /* sanity check */
911         if ELEM(NULL, tracks, tracks->first)
912                 return;
913         
914         /* deactive all the rest */
915         for (nlt= tracks->first; nlt; nlt= nlt->next) 
916                 nlt->flag &= ~NLATRACK_ACTIVE;
917                 
918         /* set the given one as the active one */
919         if (nlt_a)
920                 nlt_a->flag |= NLATRACK_ACTIVE;
921 }
922
923 /* Check if there is any space in the given track to add a strip of the given length */
924 short BKE_nlatrack_has_space (NlaTrack *nlt, float start, float end)
925 {
926         /* sanity checks */
927         if ((nlt == NULL) || IS_EQ(start, end))
928                 return 0;
929         if (start > end) {
930                 puts("BKE_nlatrack_has_space() error... start and end arguments swapped");
931                 SWAP(float, start, end);
932         }
933         
934         /* check if there's any space left in the track for a strip of the given length */
935         return BKE_nlastrips_has_space(&nlt->strips, start, end);
936 }
937
938 /* Rearrange the strips in the track so that they are always in order 
939  * (usually only needed after a strip has been moved) 
940  */
941 void BKE_nlatrack_sort_strips (NlaTrack *nlt)
942 {
943         /* sanity checks */
944         if ELEM(NULL, nlt, nlt->strips.first)
945                 return;
946         
947         /* sort the strips with a more generic function */
948         BKE_nlastrips_sort_strips(&nlt->strips);
949 }
950
951 /* Add the given NLA-Strip to the given NLA-Track, assuming that it 
952  * isn't currently attached to another one 
953  */
954 short BKE_nlatrack_add_strip (NlaTrack *nlt, NlaStrip *strip)
955 {
956         /* sanity checks */
957         if ELEM(NULL, nlt, strip)
958                 return 0;
959                 
960         /* try to add the strip to the track using a more generic function */
961         return BKE_nlastrips_add_strip(&nlt->strips, strip);
962 }
963
964 /* NLA Strips -------------------------------------- */
965
966 /* Find the active NLA-strip within the given track */
967 NlaStrip *BKE_nlastrip_find_active (NlaTrack *nlt)
968 {
969         NlaStrip *strip;
970         
971         /* sanity check */
972         if ELEM(NULL, nlt, nlt->strips.first)
973                 return NULL;
974                 
975         /* try to find the first active strip */
976         for (strip= nlt->strips.first; strip; strip= strip->next) {
977                 if (strip->flag & NLASTRIP_FLAG_ACTIVE)
978                         return strip;
979         }
980         
981         /* none found */
982         return NULL;
983 }
984
985 /* Make the given NLA-Strip the active one within the given block */
986 void BKE_nlastrip_set_active (AnimData *adt, NlaStrip *strip)
987 {
988         NlaTrack *nlt;
989         NlaStrip *nls;
990         
991         /* sanity checks */
992         if (adt == NULL)
993                 return;
994         
995         /* loop over tracks, deactivating*/
996         for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) {
997                 for (nls= nlt->strips.first; nls; nls= nls->next)  {
998                         if (nls != strip)
999                                 nls->flag &= ~NLASTRIP_FLAG_ACTIVE;
1000                         else
1001                                 nls->flag |= NLASTRIP_FLAG_ACTIVE;
1002                 }
1003         }
1004 }
1005
1006
1007 /* Does the given NLA-strip fall within the given bounds (times)? */
1008 short BKE_nlastrip_within_bounds (NlaStrip *strip, float min, float max)
1009 {
1010         const float stripLen= (strip) ? strip->end - strip->start : 0.0f;
1011         const float boundsLen= (float)fabs(max - min);
1012         
1013         /* sanity checks */
1014         if ((strip == NULL) || IS_EQ(stripLen, 0.0f) || IS_EQ(boundsLen, 0.0f))
1015                 return 0;
1016         
1017         /* only ok if at least part of the strip is within the bounding window
1018          *      - first 2 cases cover when the strip length is less than the bounding area
1019          *      - second 2 cases cover when the strip length is greater than the bounding area
1020          */
1021         if ( (stripLen < boundsLen) && 
1022                  !(IN_RANGE(strip->start, min, max) ||
1023                    IN_RANGE(strip->end, min, max)) )
1024         {
1025                 return 0;
1026         }
1027         if ( (stripLen > boundsLen) && 
1028                  !(IN_RANGE(min, strip->start, strip->end) ||
1029                    IN_RANGE(max, strip->start, strip->end)) )
1030         {
1031                 return 0;
1032         }
1033         
1034         /* should be ok! */
1035         return 1;
1036 }
1037
1038 /* Recalculate the start and end frames for the current strip, after changing
1039  * the extents of the action or the mapping (repeats or scale factor) info
1040  */
1041 void BKE_nlastrip_recalculate_bounds (NlaStrip *strip)
1042 {
1043         float actlen, mapping;
1044         
1045         /* sanity checks
1046          *      - must have a strip
1047          *      - can only be done for action clips
1048          */
1049         if ((strip == NULL) || (strip->type != NLASTRIP_TYPE_CLIP))
1050                 return;
1051                 
1052         /* calculate new length factors */
1053         actlen= strip->actend - strip->actstart;
1054         if (IS_EQ(actlen, 0.0f)) actlen= 1.0f;
1055         
1056         mapping= strip->scale * strip->repeat;
1057         
1058         /* adjust endpoint of strip in response to this */
1059         if (IS_EQ(mapping, 0.0f) == 0)
1060                 strip->end = (actlen * mapping) + strip->start;
1061 }
1062
1063 /* Is the given NLA-strip the first one to occur for the given AnimData block */
1064 // TODO: make this an api method if necesary, but need to add prefix first
1065 static short nlastrip_is_first (AnimData *adt, NlaStrip *strip)
1066 {
1067         NlaTrack *nlt;
1068         NlaStrip *ns;
1069         
1070         /* sanity checks */
1071         if ELEM(NULL, adt, strip)
1072                 return 0;
1073                 
1074         /* check if strip has any strips before it */
1075         if (strip->prev)
1076                 return 0;
1077                 
1078         /* check other tracks to see if they have a strip that's earlier */
1079         // TODO: or should we check that the strip's track is also the first?
1080         for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) {
1081                 /* only check the first strip, assuming that they're all in order */
1082                 ns= nlt->strips.first;
1083                 if (ns) {
1084                         if (ns->start < strip->start)
1085                                 return 0;
1086                 }
1087         }       
1088         
1089         /* should be first now */
1090         return 1;
1091 }
1092
1093 /* Animated Strips ------------------------------------------- */
1094
1095 /* Check if the given NLA-Track has any strips with own F-Curves */
1096 short BKE_nlatrack_has_animated_strips (NlaTrack *nlt)
1097 {
1098         NlaStrip *strip;
1099         
1100         /* sanity checks */
1101         if ELEM(NULL, nlt, nlt->strips.first)
1102                 return 0;
1103                 
1104         /* check each strip for F-Curves only (don't care about whether the flags are set) */
1105         for (strip= nlt->strips.first; strip; strip= strip->next) {
1106                 if (strip->fcurves.first)
1107                         return 1;
1108         }
1109         
1110         /* none found */
1111         return 0;
1112 }
1113
1114 /* Check if given NLA-Tracks have any strips with own F-Curves */
1115 short BKE_nlatracks_have_animated_strips (ListBase *tracks)
1116 {
1117         NlaTrack *nlt;
1118         
1119         /* sanity checks */
1120         if ELEM(NULL, tracks, tracks->first)
1121                 return 0;
1122                 
1123         /* check each track, stopping on the first hit */
1124         for (nlt= tracks->first; nlt; nlt= nlt->next) {
1125                 if (BKE_nlatrack_has_animated_strips(nlt))
1126                         return 1;
1127         }
1128         
1129         /* none found */
1130         return 0;
1131 }
1132
1133 /* Validate the NLA-Strips 'control' F-Curves based on the flags set*/
1134 void BKE_nlastrip_validate_fcurves (NlaStrip *strip) 
1135 {
1136         FCurve *fcu;
1137         
1138         /* sanity checks */
1139         if (strip == NULL)
1140                 return;
1141         
1142         /* if controlling influence... */
1143         if (strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) {
1144                 /* try to get F-Curve */
1145                 fcu= list_find_fcurve(&strip->fcurves, "influence", 0);
1146                 
1147                 /* add one if not found */
1148                 if (fcu == NULL) {
1149                         /* make new F-Curve */
1150                         fcu= MEM_callocN(sizeof(FCurve), "NlaStrip FCurve");
1151                         BLI_addtail(&strip->fcurves, fcu);
1152                         
1153                         /* set default flags */
1154                         fcu->flag = (FCURVE_VISIBLE|FCURVE_AUTO_HANDLES|FCURVE_SELECTED);
1155                         
1156                         /* store path - make copy, and store that */
1157                         fcu->rna_path= BLI_strdupn("influence", 9);
1158                         
1159                         // TODO: insert a few keyframes to ensure default behaviour?
1160                 }
1161         }
1162         
1163         /* if controlling time... */
1164         if (strip->flag & NLASTRIP_FLAG_USR_TIME) {
1165                 /* try to get F-Curve */
1166                 fcu= list_find_fcurve(&strip->fcurves, "strip_time", 0);
1167                 
1168                 /* add one if not found */
1169                 if (fcu == NULL) {
1170                         /* make new F-Curve */
1171                         fcu= MEM_callocN(sizeof(FCurve), "NlaStrip FCurve");
1172                         BLI_addtail(&strip->fcurves, fcu);
1173                         
1174                         /* set default flags */
1175                         fcu->flag = (FCURVE_VISIBLE|FCURVE_AUTO_HANDLES|FCURVE_SELECTED);
1176                         
1177                         /* store path - make copy, and store that */
1178                         fcu->rna_path= BLI_strdupn("strip_time", 10);
1179                         
1180                         // TODO: insert a few keyframes to ensure default behaviour?
1181                 }
1182         }
1183 }
1184
1185 /* Sanity Validation ------------------------------------ */
1186
1187 /* Find (and set) a unique name for a strip from the whole AnimData block 
1188  * Uses a similar method to the BLI method, but is implemented differently
1189  * as we need to ensure that the name is unique over several lists of tracks,
1190  * not just a single track.
1191  */
1192 void BKE_nlastrip_validate_name (AnimData *adt, NlaStrip *strip)
1193 {
1194         GHash *gh;
1195         NlaStrip *tstrip;
1196         NlaTrack *nlt;
1197         
1198         /* sanity checks */
1199         if ELEM(NULL, adt, strip)
1200                 return;
1201                 
1202         /* give strip a default name if none already */
1203         if (strip->name[0]==0) {
1204                 switch (strip->type) {
1205                         case NLASTRIP_TYPE_CLIP: /* act-clip */
1206                                 sprintf(strip->name, "Act: %s", (strip->act)?(strip->act->id.name+2):("<None>"));
1207                                 break;
1208                         case NLASTRIP_TYPE_TRANSITION: /* transition */
1209                                 sprintf(strip->name, "Transition");
1210                                 break;
1211                         case NLASTRIP_TYPE_META: /* meta */
1212                                 sprintf(strip->name, "Meta");
1213                                 break;
1214                         default:
1215                                 sprintf(strip->name, "NLA Strip");
1216                                 break;
1217                 }
1218         }
1219         
1220         /* build a hash-table of all the strips in the tracks 
1221          *      - this is easier than iterating over all the tracks+strips hierarchy everytime
1222          *        (and probably faster)
1223          */
1224         gh= BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp);
1225         
1226         for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) {
1227                 for (tstrip= nlt->strips.first; tstrip; tstrip= tstrip->next) {
1228                         /* don't add the strip of interest */
1229                         if (tstrip == strip) 
1230                                 continue;
1231                         
1232                         /* use the name of the strip as the key, and the strip as the value, since we're mostly interested in the keys */
1233                         BLI_ghash_insert(gh, tstrip->name, tstrip);
1234                 }
1235         }
1236         
1237         /* if the hash-table has a match for this name, try other names... 
1238          *      - in an extreme case, it might not be able to find a name, but then everything else in Blender would fail too :)
1239          */
1240         if (BLI_ghash_haskey(gh, strip->name)) {
1241                 char tempname[128];
1242                 int     number = 1;
1243                 char *dot;
1244                 
1245                 /* Strip off the suffix */
1246                 dot = strchr(strip->name, '.');
1247                 if (dot) *dot=0;
1248                 
1249                 /* Try different possibilities */
1250                 for (number = 1; number <= 999; number++) {
1251                         /* assemble alternative name */
1252                         BLI_snprintf(tempname, 128, "%s%c%03d", strip->name, ".", number);
1253                         
1254                         /* if hash doesn't have this, set it */
1255                         if (BLI_ghash_haskey(gh, tempname) == 0) {
1256                                 BLI_strncpy(strip->name, tempname, sizeof(strip->name));
1257                                 break;
1258                         }
1259                 }
1260         }
1261         
1262         /* free the hash... */
1263         BLI_ghash_free(gh, NULL, NULL);
1264 }
1265
1266 /* ---- */
1267
1268 /* Get strips which overlap the given one at the start/end of its range 
1269  *      - strip: strip that we're finding overlaps for
1270  *      - track: nla-track that the overlapping strips should be found from
1271  *      - start, end: frames for the offending endpoints
1272  */
1273 static void nlastrip_get_endpoint_overlaps (NlaStrip *strip, NlaTrack *track, float **start, float **end)
1274 {
1275         NlaStrip *nls;
1276         
1277         /* find strips that overlap over the start/end of the given strip,
1278          * but which don't cover the entire length 
1279          */
1280         // TODO: this scheme could get quite slow for doing this on many strips...
1281         for (nls= track->strips.first; nls; nls= nls->next) {
1282                 /* check if strip overlaps (extends over or exactly on) the entire range of the strip we're validating */
1283                 if ((nls->start <= strip->start) && (nls->end >= strip->end)) {
1284                         *start= NULL;
1285                         *end= NULL;
1286                         return;
1287                 }
1288                 
1289                 /* check if strip doesn't even occur anywhere near... */
1290                 if (nls->end < strip->start)
1291                         continue; /* skip checking this strip... not worthy of mention */
1292                 if (nls->start > strip->end)
1293                         return; /* the range we're after has already passed */
1294                         
1295                 /* if this strip is not part of an island of continuous strips, it can be used
1296                  *      - this check needs to be done for each end of the strip we try and use...
1297                  */
1298                 if ((nls->next == NULL) || IS_EQ(nls->next->start, nls->end)==0) {
1299                         if ((nls->end > strip->start) && (nls->end < strip->end))
1300                                 *start= &nls->end;
1301                 }
1302                 if ((nls->prev == NULL) || IS_EQ(nls->prev->end, nls->start)==0) {
1303                         if ((nls->start < strip->end) && (nls->start > strip->start))
1304                                 *end= &nls->start;
1305                 }
1306         }
1307 }
1308
1309 /* Determine auto-blending for the given strip */
1310 void BKE_nlastrip_validate_autoblends (NlaTrack *nlt, NlaStrip *nls)
1311 {
1312         float *ps=NULL, *pe=NULL;
1313         float *ns=NULL, *ne=NULL;
1314         
1315         /* sanity checks */
1316         if ELEM(NULL, nls, nlt)
1317                 return;
1318         if ((nlt->prev == NULL) && (nlt->next == NULL))
1319                 return;
1320         if ((nls->flag & NLASTRIP_FLAG_AUTO_BLENDS)==0)
1321                 return;
1322         
1323         /* get test ranges */
1324         if (nlt->prev)
1325                 nlastrip_get_endpoint_overlaps(nls, nlt->prev, &ps, &pe);
1326         if (nlt->next)
1327                 nlastrip_get_endpoint_overlaps(nls, nlt->next, &ns, &ne);
1328                 
1329         /* set overlaps for this strip 
1330          *      - don't use the values obtained though if the end in question 
1331          *        is directly followed/preceeded by another strip, forming an 
1332          *        'island' of continuous strips
1333          */
1334         if ( (ps || ns) && ((nls->prev == NULL) || IS_EQ(nls->prev->end, nls->start)==0) ) 
1335         {
1336                 /* start overlaps - pick the largest overlap */
1337                 if ( ((ps && ns) && (*ps > *ns)) || (ps) )
1338                         nls->blendin= *ps - nls->start;
1339                 else
1340                         nls->blendin= *ns - nls->start;
1341         }
1342         else /* no overlap allowed/needed */
1343                 nls->blendin= 0.0f;
1344                 
1345         if ( (pe || ne) && ((nls->next == NULL) || IS_EQ(nls->next->start, nls->end)==0) ) 
1346         {
1347                 /* end overlaps - pick the largest overlap */
1348                 if ( ((pe && ne) && (*pe > *ne)) || (pe) )
1349                         nls->blendout= nls->end - *pe;
1350                 else
1351                         nls->blendout= nls->end - *ne;
1352         }
1353         else /* no overlap allowed/needed */
1354                 nls->blendout= 0.0f;
1355 }
1356
1357 /* Ensure that auto-blending and other settings are set correctly */
1358 void BKE_nla_validate_state (AnimData *adt)
1359 {
1360         NlaStrip *strip, *fstrip=NULL;
1361         NlaTrack *nlt;
1362         
1363         /* sanity checks */
1364         if ELEM(NULL, adt, adt->nla_tracks.first)
1365                 return;
1366                 
1367         /* adjust blending values for auto-blending, and also do an initial pass to find the earliest strip */
1368         for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) {
1369                 for (strip= nlt->strips.first; strip; strip= strip->next) {
1370                         /* auto-blending first */
1371                         BKE_nlastrip_validate_autoblends(nlt, strip);
1372                         
1373                         /* extend mode - find first strip */
1374                         if ((fstrip == NULL) || (strip->start < fstrip->start))
1375                                 fstrip= strip;
1376                 }
1377         }
1378         
1379         /* second pass over the strips to adjust the extend-mode to fix any problems */
1380         for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) {
1381                 for (strip= nlt->strips.first; strip; strip= strip->next) {
1382                         /* apart from 'nothing' option which user has to explicitly choose, we don't really know if 
1383                          * we should be overwriting the extend setting (but assume that's what the user wanted)
1384                          */
1385                         // TODO: 1 solution is to tie this in with auto-blending...
1386                         if (strip->extendmode != NLASTRIP_EXTEND_NOTHING) {
1387                                 if (strip == fstrip)
1388                                         strip->extendmode= NLASTRIP_EXTEND_HOLD;
1389                                 else
1390                                         strip->extendmode= NLASTRIP_EXTEND_HOLD_FORWARD;
1391                         }
1392                 }
1393         }
1394 }
1395
1396 /* Core Tools ------------------------------------------- */
1397
1398 /* For the given AnimData block, add the active action to the NLA
1399  * stack (i.e. 'push-down' action). The UI should only allow this 
1400  * for normal editing only (i.e. not in editmode for some strip's action),
1401  * so no checks for this are performed.
1402  */
1403 // TODO: maybe we should have checks for this too...
1404 void BKE_nla_action_pushdown (AnimData *adt)
1405 {
1406         NlaStrip *strip;
1407         
1408         /* sanity checks */
1409         // TODO: need to report the error for this
1410         if ELEM(NULL, adt, adt->action) 
1411                 return;
1412                 
1413         /* if the action is empty, we also shouldn't try to add to stack, 
1414          * as that will cause us grief down the track
1415          */
1416         // TODO: what about modifiers?
1417         if (action_has_motion(adt->action) == 0) {
1418                 printf("BKE_nla_action_pushdown(): action has no data \n");
1419                 return;
1420         }
1421         
1422         /* add a new NLA strip to the track, which references the active action */
1423         strip= add_nlastrip_to_stack(adt, adt->action);
1424         
1425         /* do other necessary work on strip */  
1426         if (strip) {
1427                 /* clear reference to action now that we've pushed it onto the stack */
1428                 adt->action->id.us--;
1429                 adt->action= NULL;
1430                 
1431                 /* if the strip is the first one in the track it lives in, check if there
1432                  * are strips in any other tracks that may be before this, and set the extend
1433                  * mode accordingly
1434                  */
1435                 if (nlastrip_is_first(adt, strip) == 0) {
1436                         /* not first, so extend mode can only be NLASTRIP_EXTEND_HOLD_FORWARD not NLASTRIP_EXTEND_HOLD,
1437                          * so that it doesn't override strips in previous tracks
1438                          */
1439                         // FIXME: this needs to be more automated, since user can rearrange strips
1440                         strip->extendmode= NLASTRIP_EXTEND_HOLD_FORWARD;
1441                 }
1442                 
1443                 /* make strip the active one... */
1444                 BKE_nlastrip_set_active(adt, strip);
1445         }
1446 }
1447
1448
1449 /* Find the active strip + track combo, and set them up as the tweaking track,
1450  * and return if successful or not.
1451  */
1452 short BKE_nla_tweakmode_enter (AnimData *adt)
1453 {
1454         NlaTrack *nlt, *activeTrack=NULL;
1455         NlaStrip *strip, *activeStrip=NULL;
1456         
1457         /* verify that data is valid */
1458         if ELEM(NULL, adt, adt->nla_tracks.first)
1459                 return 0;
1460                 
1461         /* if block is already in tweakmode, just leave, but we should report 
1462          * that this block is in tweakmode (as our returncode)
1463          */
1464         if (adt->flag & ADT_NLA_EDIT_ON)
1465                 return 1;
1466                 
1467         /* go over the tracks, finding the active one, and its active strip
1468          *      - if we cannot find both, then there's nothing to do
1469          */
1470         for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) {
1471                 /* check if active */
1472                 if (nlt->flag & NLATRACK_ACTIVE) {
1473                         /* store reference to this active track */
1474                         activeTrack= nlt;
1475                         
1476                         /* now try to find active strip */
1477                         activeStrip= BKE_nlastrip_find_active(nlt);
1478                         break;
1479                 }       
1480         }
1481         if ELEM3(NULL, activeTrack, activeStrip, activeStrip->act) {
1482                 printf("NLA tweakmode enter - neither active requirement found \n");
1483                 return 0;
1484         }
1485                 
1486         /* go over all the tracks up to the active one, tagging each strip that uses the same 
1487          * action as the active strip, but leaving everything else alone
1488          */
1489         for (nlt= activeTrack->prev; nlt; nlt= nlt->prev) {
1490                 for (strip= nlt->strips.first; strip; strip= strip->next) {
1491                         if (strip->act == activeStrip->act)
1492                                 strip->flag |= NLASTRIP_FLAG_TWEAKUSER;
1493                         else
1494                                 strip->flag &= ~NLASTRIP_FLAG_TWEAKUSER;
1495                 }
1496         }
1497         
1498         
1499         /* go over all the tracks after AND INCLUDING the active one, tagging them as being disabled 
1500          *      - the active track needs to also be tagged, otherwise, it'll overlap with the tweaks going on
1501          */
1502         for (nlt= activeTrack; nlt; nlt= nlt->next)
1503                 nlt->flag |= NLATRACK_DISABLED;
1504         
1505         /* handle AnimData level changes:
1506          *      - 'real' active action to temp storage (no need to change user-counts)
1507          *      - action of active strip set to be the 'active action', and have its usercount incremented
1508          *      - editing-flag for this AnimData block should also get turned on (for more efficient restoring)
1509          *      - take note of the active strip for mapping-correction of keyframes in the action being edited
1510          */
1511         adt->tmpact= adt->action;
1512         adt->action= activeStrip->act;
1513         adt->actstrip= activeStrip;
1514         id_us_plus(&activeStrip->act->id);
1515         adt->flag |= ADT_NLA_EDIT_ON;
1516         
1517         /* done! */
1518         return 1;
1519 }
1520
1521 /* Exit tweakmode for this AnimData block */
1522 void BKE_nla_tweakmode_exit (AnimData *adt)
1523 {
1524         NlaStrip *strip;
1525         NlaTrack *nlt;
1526         
1527         /* verify that data is valid */
1528         if ELEM(NULL, adt, adt->nla_tracks.first)
1529                 return;
1530                 
1531         /* hopefully the flag is correct - skip if not on */
1532         if ((adt->flag & ADT_NLA_EDIT_ON) == 0)
1533                 return;
1534                 
1535         // TODO: need to sync the user-strip with the new state of the action!
1536                 
1537         /* for all Tracks, clear the 'disabled' flag
1538          * for all Strips, clear the 'tweak-user' flag
1539          */
1540         for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) {
1541                 nlt->flag &= ~NLATRACK_DISABLED;
1542                 
1543                 for (strip= nlt->strips.first; strip; strip= strip->next) 
1544                         strip->flag &= ~NLASTRIP_FLAG_TWEAKUSER;
1545         }
1546         
1547         /* handle AnimData level changes:
1548          *      - 'temporary' active action needs its usercount decreased, since we're removing this reference
1549          *      - 'real' active action is restored from storage
1550          *      - storage pointer gets cleared (to avoid having bad notes hanging around)
1551          *      - editing-flag for this AnimData block should also get turned off
1552          *      - clear pointer to active strip
1553          */
1554         if (adt->action) adt->action->id.us--;
1555         adt->action= adt->tmpact;
1556         adt->tmpact= NULL;
1557         adt->actstrip= NULL;
1558         adt->flag &= ~ADT_NLA_EDIT_ON;
1559 }
1560
1561 /* *************************************************** */