970be7e65a
Selection range is +/-7 pixels to actual clicked position, but strip selection was biased towards rightmost strip. To make selection more intuitive, select closest strip to clicked position, and stop iterating when strip intersects clicked pixel. Reviewed By: sybren Differential Revision: https://developer.blender.org/D15728
2299 lines
65 KiB
C
2299 lines
65 KiB
C
/* SPDX-License-Identifier: GPL-2.0-or-later
|
|
* Copyright 2009 Blender Foundation, Joshua Leung. All rights reserved. */
|
|
|
|
/** \file
|
|
* \ingroup bke
|
|
*/
|
|
|
|
#include <float.h>
|
|
#include <math.h>
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "CLG_log.h"
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "BLI_ghash.h"
|
|
#include "BLI_listbase.h"
|
|
#include "BLI_string.h"
|
|
#include "BLI_string_utils.h"
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "BLT_translation.h"
|
|
|
|
#include "DNA_anim_types.h"
|
|
#include "DNA_scene_types.h"
|
|
#include "DNA_sound_types.h"
|
|
#include "DNA_speaker_types.h"
|
|
|
|
#include "BKE_action.h"
|
|
#include "BKE_fcurve.h"
|
|
#include "BKE_global.h"
|
|
#include "BKE_lib_id.h"
|
|
#include "BKE_lib_query.h"
|
|
#include "BKE_main.h"
|
|
#include "BKE_nla.h"
|
|
#include "BKE_sound.h"
|
|
|
|
#include "BLO_read_write.h"
|
|
|
|
#include "RNA_access.h"
|
|
#include "RNA_prototypes.h"
|
|
|
|
#include "nla_private.h"
|
|
|
|
static CLG_LogRef LOG = {"bke.nla"};
|
|
|
|
/**
|
|
* Find the active track and strip.
|
|
*
|
|
* The active strip may or may not be on the active track.
|
|
*/
|
|
static void nla_tweakmode_find_active(const ListBase /* NlaTrack */ *nla_tracks,
|
|
NlaTrack **r_track_of_active_strip,
|
|
NlaStrip **r_active_strip);
|
|
|
|
/* *************************************************** */
|
|
/* Data Management */
|
|
|
|
/* Freeing ------------------------------------------- */
|
|
|
|
void BKE_nlastrip_free(ListBase *strips, NlaStrip *strip, bool do_id_user)
|
|
{
|
|
NlaStrip *cs, *csn;
|
|
|
|
/* sanity checks */
|
|
if (strip == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* free child-strips */
|
|
for (cs = strip->strips.first; cs; cs = csn) {
|
|
csn = cs->next;
|
|
BKE_nlastrip_free(&strip->strips, cs, do_id_user);
|
|
}
|
|
|
|
/* remove reference to action */
|
|
if (strip->act != NULL && do_id_user) {
|
|
id_us_min(&strip->act->id);
|
|
}
|
|
|
|
/* free remapping info */
|
|
// if (strip->remap)
|
|
// BKE_animremap_free();
|
|
|
|
/* free own F-Curves */
|
|
BKE_fcurves_free(&strip->fcurves);
|
|
|
|
/* free own F-Modifiers */
|
|
free_fmodifiers(&strip->modifiers);
|
|
|
|
/* free the strip itself */
|
|
if (strips) {
|
|
BLI_freelinkN(strips, strip);
|
|
}
|
|
else {
|
|
MEM_freeN(strip);
|
|
}
|
|
}
|
|
|
|
void BKE_nlatrack_free(ListBase *tracks, NlaTrack *nlt, bool do_id_user)
|
|
{
|
|
NlaStrip *strip, *stripn;
|
|
|
|
/* sanity checks */
|
|
if (nlt == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* free strips */
|
|
for (strip = nlt->strips.first; strip; strip = stripn) {
|
|
stripn = strip->next;
|
|
BKE_nlastrip_free(&nlt->strips, strip, do_id_user);
|
|
}
|
|
|
|
/* free NLA track itself now */
|
|
if (tracks) {
|
|
BLI_freelinkN(tracks, nlt);
|
|
}
|
|
else {
|
|
MEM_freeN(nlt);
|
|
}
|
|
}
|
|
|
|
void BKE_nla_tracks_free(ListBase *tracks, bool do_id_user)
|
|
{
|
|
NlaTrack *nlt, *nltn;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, tracks, tracks->first)) {
|
|
return;
|
|
}
|
|
|
|
/* free tracks one by one */
|
|
for (nlt = tracks->first; nlt; nlt = nltn) {
|
|
nltn = nlt->next;
|
|
BKE_nlatrack_free(tracks, nlt, do_id_user);
|
|
}
|
|
|
|
/* clear the list's pointers to be safe */
|
|
BLI_listbase_clear(tracks);
|
|
}
|
|
|
|
/* Copying ------------------------------------------- */
|
|
|
|
NlaStrip *BKE_nlastrip_copy(Main *bmain,
|
|
NlaStrip *strip,
|
|
const bool use_same_action,
|
|
const int flag)
|
|
{
|
|
NlaStrip *strip_d;
|
|
NlaStrip *cs, *cs_d;
|
|
|
|
const bool do_id_user = (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0;
|
|
|
|
/* sanity check */
|
|
if (strip == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* make a copy */
|
|
strip_d = MEM_dupallocN(strip);
|
|
strip_d->next = strip_d->prev = NULL;
|
|
|
|
/* handle action */
|
|
if (strip_d->act) {
|
|
if (use_same_action) {
|
|
if (do_id_user) {
|
|
/* increase user-count of action */
|
|
id_us_plus(&strip_d->act->id);
|
|
}
|
|
}
|
|
else {
|
|
/* use a copy of the action instead (user count shouldn't have changed yet) */
|
|
BKE_id_copy_ex(bmain, &strip_d->act->id, (ID **)&strip_d->act, flag);
|
|
}
|
|
}
|
|
|
|
/* copy F-Curves and modifiers */
|
|
BKE_fcurves_copy(&strip_d->fcurves, &strip->fcurves);
|
|
copy_fmodifiers(&strip_d->modifiers, &strip->modifiers);
|
|
|
|
/* make a copy of all the child-strips, one at a time */
|
|
BLI_listbase_clear(&strip_d->strips);
|
|
|
|
for (cs = strip->strips.first; cs; cs = cs->next) {
|
|
cs_d = BKE_nlastrip_copy(bmain, cs, use_same_action, flag);
|
|
BLI_addtail(&strip_d->strips, cs_d);
|
|
}
|
|
|
|
/* return the strip */
|
|
return strip_d;
|
|
}
|
|
|
|
NlaTrack *BKE_nlatrack_copy(Main *bmain,
|
|
NlaTrack *nlt,
|
|
const bool use_same_actions,
|
|
const int flag)
|
|
{
|
|
NlaStrip *strip, *strip_d;
|
|
NlaTrack *nlt_d;
|
|
|
|
/* sanity check */
|
|
if (nlt == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* make a copy */
|
|
nlt_d = MEM_dupallocN(nlt);
|
|
nlt_d->next = nlt_d->prev = NULL;
|
|
|
|
/* make a copy of all the strips, one at a time */
|
|
BLI_listbase_clear(&nlt_d->strips);
|
|
|
|
for (strip = nlt->strips.first; strip; strip = strip->next) {
|
|
strip_d = BKE_nlastrip_copy(bmain, strip, use_same_actions, flag);
|
|
BLI_addtail(&nlt_d->strips, strip_d);
|
|
}
|
|
|
|
/* return the copy */
|
|
return nlt_d;
|
|
}
|
|
|
|
void BKE_nla_tracks_copy(Main *bmain, ListBase *dst, const ListBase *src, const int flag)
|
|
{
|
|
NlaTrack *nlt, *nlt_d;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, dst, src)) {
|
|
return;
|
|
}
|
|
|
|
/* clear out the destination list first for precautions... */
|
|
BLI_listbase_clear(dst);
|
|
|
|
/* copy each NLA-track, one at a time */
|
|
for (nlt = src->first; nlt; nlt = nlt->next) {
|
|
/* make a copy, and add the copy to the destination list */
|
|
/* XXX: we need to fix this sometime. */
|
|
nlt_d = BKE_nlatrack_copy(bmain, nlt, true, flag);
|
|
BLI_addtail(dst, nlt_d);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find `active_strip` in `strips_source`, then return the strip with the same
|
|
* index from `strips_dest`.
|
|
*/
|
|
static NlaStrip *find_active_strip_from_listbase(const NlaStrip *active_strip,
|
|
const ListBase /* NlaStrip */ *strips_source,
|
|
const ListBase /* NlaStrip */ *strips_dest)
|
|
{
|
|
BLI_assert_msg(BLI_listbase_count(strips_source) == BLI_listbase_count(strips_dest),
|
|
"Expecting the same number of source and destination strips");
|
|
|
|
NlaStrip *strip_dest = strips_dest->first;
|
|
LISTBASE_FOREACH (const NlaStrip *, strip_source, strips_source) {
|
|
if (strip_dest == NULL) {
|
|
/* The tracks are assumed to have an equal number of strips, but this is
|
|
* not the case. Not sure when this might happen, but it's better to not
|
|
* crash. */
|
|
break;
|
|
}
|
|
if (strip_source == active_strip) {
|
|
return strip_dest;
|
|
}
|
|
|
|
const bool src_is_meta = strip_source->type == NLASTRIP_TYPE_META;
|
|
const bool dst_is_meta = strip_dest->type == NLASTRIP_TYPE_META;
|
|
BLI_assert_msg(src_is_meta == dst_is_meta,
|
|
"Expecting topology of source and destination strips to be equal");
|
|
if (src_is_meta && dst_is_meta) {
|
|
NlaStrip *found_in_meta = find_active_strip_from_listbase(
|
|
active_strip, &strip_source->strips, &strip_dest->strips);
|
|
if (found_in_meta != NULL) {
|
|
return found_in_meta;
|
|
}
|
|
}
|
|
|
|
strip_dest = strip_dest->next;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Set adt_dest->actstrip to the strip with the same index as
|
|
* adt_source->actstrip. Note that this always sets `adt_dest->actstrip`; sets
|
|
* to NULL when `adt_source->actstrip` cannot be found. */
|
|
static void update_active_strip(AnimData *adt_dest,
|
|
NlaTrack *track_dest,
|
|
const AnimData *adt_source,
|
|
const NlaTrack *track_source)
|
|
{
|
|
BLI_assert(BLI_listbase_count(&track_source->strips) == BLI_listbase_count(&track_dest->strips));
|
|
|
|
NlaStrip *active_strip = find_active_strip_from_listbase(
|
|
adt_source->actstrip, &track_source->strips, &track_dest->strips);
|
|
adt_dest->actstrip = active_strip;
|
|
}
|
|
|
|
/* Set adt_dest->act_track to the track with the same index as adt_source->act_track. */
|
|
static void update_active_track(AnimData *adt_dest, const AnimData *adt_source)
|
|
{
|
|
adt_dest->act_track = NULL;
|
|
adt_dest->actstrip = NULL;
|
|
if (adt_source->act_track == NULL && adt_source->actstrip == NULL) {
|
|
return;
|
|
}
|
|
|
|
BLI_assert(BLI_listbase_count(&adt_source->nla_tracks) ==
|
|
BLI_listbase_count(&adt_dest->nla_tracks));
|
|
|
|
NlaTrack *track_dest = adt_dest->nla_tracks.first;
|
|
LISTBASE_FOREACH (NlaTrack *, track_source, &adt_source->nla_tracks) {
|
|
if (track_source == adt_source->act_track) {
|
|
adt_dest->act_track = track_dest;
|
|
}
|
|
|
|
/* Only search for the active strip if it hasn't been found yet. */
|
|
if (adt_dest->actstrip == NULL && adt_source->actstrip != NULL) {
|
|
update_active_strip(adt_dest, track_dest, adt_source, track_source);
|
|
}
|
|
|
|
track_dest = track_dest->next;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
{
|
|
const bool source_has_actstrip = adt_source->actstrip != NULL;
|
|
const bool dest_has_actstrip = adt_dest->actstrip != NULL;
|
|
BLI_assert_msg(source_has_actstrip == dest_has_actstrip,
|
|
"Active strip did not copy correctly");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void BKE_nla_tracks_copy_from_adt(Main *bmain,
|
|
AnimData *adt_dest,
|
|
const AnimData *adt_source,
|
|
const int flag)
|
|
{
|
|
adt_dest->act_track = NULL;
|
|
adt_dest->actstrip = NULL;
|
|
|
|
BKE_nla_tracks_copy(bmain, &adt_dest->nla_tracks, &adt_source->nla_tracks, flag);
|
|
update_active_track(adt_dest, adt_source);
|
|
}
|
|
|
|
/* Adding ------------------------------------------- */
|
|
|
|
NlaTrack *BKE_nlatrack_add(AnimData *adt, NlaTrack *prev, const bool is_liboverride)
|
|
{
|
|
NlaTrack *nlt;
|
|
|
|
/* sanity checks */
|
|
if (adt == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* allocate new track */
|
|
nlt = MEM_callocN(sizeof(NlaTrack), "NlaTrack");
|
|
|
|
/* set settings requiring the track to not be part of the stack yet */
|
|
nlt->flag = NLATRACK_SELECTED | NLATRACK_OVERRIDELIBRARY_LOCAL;
|
|
nlt->index = BLI_listbase_count(&adt->nla_tracks);
|
|
|
|
/* In liboverride case, we only add local tracks after all those coming from the linked data,
|
|
* so we need to find the first local track. */
|
|
if (is_liboverride && prev != NULL && (prev->flag & NLATRACK_OVERRIDELIBRARY_LOCAL) == 0) {
|
|
NlaTrack *first_local = prev->next;
|
|
for (; first_local != NULL && (first_local->flag & NLATRACK_OVERRIDELIBRARY_LOCAL) == 0;
|
|
first_local = first_local->next) {
|
|
}
|
|
prev = first_local != NULL ? first_local->prev : NULL;
|
|
}
|
|
/* Add track to stack, and make it the active one. */
|
|
if (prev != NULL) {
|
|
BLI_insertlinkafter(&adt->nla_tracks, prev, nlt);
|
|
}
|
|
else {
|
|
BLI_addtail(&adt->nla_tracks, nlt);
|
|
}
|
|
BKE_nlatrack_set_active(&adt->nla_tracks, nlt);
|
|
|
|
/* must have unique name, but we need to seed this */
|
|
strcpy(nlt->name, "NlaTrack");
|
|
BLI_uniquename(
|
|
&adt->nla_tracks, nlt, DATA_("NlaTrack"), '.', offsetof(NlaTrack, name), sizeof(nlt->name));
|
|
|
|
/* return the new track */
|
|
return nlt;
|
|
}
|
|
|
|
NlaStrip *BKE_nlastrip_new(bAction *act)
|
|
{
|
|
NlaStrip *strip;
|
|
|
|
/* sanity checks */
|
|
if (act == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* allocate new strip */
|
|
strip = MEM_callocN(sizeof(NlaStrip), "NlaStrip");
|
|
|
|
/* generic settings
|
|
* - selected flag to highlight this to the user
|
|
* - (XXX) disabled Auto-Blends, as this was often causing some unwanted effects
|
|
*/
|
|
strip->flag = NLASTRIP_FLAG_SELECT | NLASTRIP_FLAG_SYNC_LENGTH;
|
|
|
|
/* Disable sync for actions with a manual frame range, since it only syncs to range anyway. */
|
|
if (act->flag & ACT_FRAME_RANGE) {
|
|
strip->flag &= ~NLASTRIP_FLAG_SYNC_LENGTH;
|
|
}
|
|
|
|
/* Enable cyclic time for known cyclic actions. */
|
|
if (BKE_action_is_cyclic(act)) {
|
|
strip->flag |= NLASTRIP_FLAG_USR_TIME_CYCLIC;
|
|
}
|
|
|
|
/* assign the action reference */
|
|
strip->act = act;
|
|
id_us_plus(&act->id);
|
|
|
|
/* determine initial range
|
|
* - strip length cannot be 0... ever...
|
|
*/
|
|
BKE_action_get_frame_range(strip->act, &strip->actstart, &strip->actend);
|
|
|
|
strip->start = strip->actstart;
|
|
strip->end = IS_EQF(strip->actstart, strip->actend) ? (strip->actstart + 1.0f) : strip->actend;
|
|
|
|
/* strip should be referenced as-is */
|
|
strip->scale = 1.0f;
|
|
strip->repeat = 1.0f;
|
|
|
|
/* return the new strip */
|
|
return strip;
|
|
}
|
|
|
|
NlaStrip *BKE_nlastack_add_strip(AnimData *adt, bAction *act, const bool is_liboverride)
|
|
{
|
|
NlaStrip *strip;
|
|
NlaTrack *nlt;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, adt, act)) {
|
|
return NULL;
|
|
}
|
|
|
|
/* create a new NLA strip */
|
|
strip = BKE_nlastrip_new(act);
|
|
if (strip == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* firstly try adding strip to last track, but if that fails, add to a new track */
|
|
if (BKE_nlatrack_add_strip(adt->nla_tracks.last, strip, is_liboverride) == 0) {
|
|
/* trying to add to the last track failed (no track or no space),
|
|
* so add a new track to the stack, and add to that...
|
|
*/
|
|
nlt = BKE_nlatrack_add(adt, NULL, is_liboverride);
|
|
BKE_nlatrack_add_strip(nlt, strip, is_liboverride);
|
|
BLI_strncpy(nlt->name, act->id.name + 2, sizeof(nlt->name));
|
|
}
|
|
|
|
/* automatically name it too */
|
|
BKE_nlastrip_validate_name(adt, strip);
|
|
|
|
/* returns the strip added */
|
|
return strip;
|
|
}
|
|
|
|
NlaStrip *BKE_nla_add_soundstrip(Main *bmain, Scene *scene, Speaker *speaker)
|
|
{
|
|
NlaStrip *strip = MEM_callocN(sizeof(NlaStrip), "NlaSoundStrip");
|
|
|
|
/* if speaker has a sound, set the strip length to the length of the sound,
|
|
* otherwise default to length of 10 frames
|
|
*/
|
|
#ifdef WITH_AUDASPACE
|
|
if (speaker->sound) {
|
|
SoundInfo info;
|
|
if (BKE_sound_info_get(bmain, speaker->sound, &info)) {
|
|
strip->end = (float)ceil((double)info.length * FPS);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
strip->end = 10.0f;
|
|
/* quiet compiler warnings */
|
|
UNUSED_VARS(bmain, scene, speaker);
|
|
}
|
|
|
|
/* general settings */
|
|
strip->type = NLASTRIP_TYPE_SOUND;
|
|
|
|
strip->flag = NLASTRIP_FLAG_SELECT;
|
|
strip->extendmode = NLASTRIP_EXTEND_NOTHING; /* nothing to extend... */
|
|
|
|
/* strip should be referenced as-is */
|
|
strip->scale = 1.0f;
|
|
strip->repeat = 1.0f;
|
|
|
|
/* return this strip */
|
|
return strip;
|
|
}
|
|
|
|
void BKE_nla_strip_foreach_id(NlaStrip *strip, LibraryForeachIDData *data)
|
|
{
|
|
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, strip->act, IDWALK_CB_USER);
|
|
|
|
LISTBASE_FOREACH (FCurve *, fcu, &strip->fcurves) {
|
|
BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data, BKE_fcurve_foreach_id(fcu, data));
|
|
}
|
|
|
|
LISTBASE_FOREACH (NlaStrip *, substrip, &strip->strips) {
|
|
BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data, BKE_nla_strip_foreach_id(substrip, data));
|
|
}
|
|
}
|
|
|
|
/* *************************************************** */
|
|
/* NLA Evaluation <-> Editing Stuff */
|
|
|
|
/* Strip Mapping ------------------------------------- */
|
|
|
|
/* non clipped mapping for strip-time <-> global time (for Action-Clips)
|
|
* invert = convert action-strip time to global time
|
|
*/
|
|
static float nlastrip_get_frame_actionclip(NlaStrip *strip, float cframe, short mode)
|
|
{
|
|
float actlength, scale;
|
|
// float repeat; // UNUSED
|
|
|
|
/* get number of repeats */
|
|
if (IS_EQF(strip->repeat, 0.0f)) {
|
|
strip->repeat = 1.0f;
|
|
}
|
|
// repeat = strip->repeat; /* UNUSED */
|
|
|
|
/* scaling */
|
|
if (IS_EQF(strip->scale, 0.0f)) {
|
|
strip->scale = 1.0f;
|
|
}
|
|
|
|
/* Scale must be positive - we've got a special flag for reversing. */
|
|
scale = fabsf(strip->scale);
|
|
|
|
/* length of referenced action */
|
|
actlength = strip->actend - strip->actstart;
|
|
if (IS_EQF(actlength, 0.0f)) {
|
|
actlength = 1.0f;
|
|
}
|
|
|
|
/* reversed = play strip backwards */
|
|
if (strip->flag & NLASTRIP_FLAG_REVERSE) {
|
|
/* FIXME: this won't work right with Graph Editor? */
|
|
if (mode == NLATIME_CONVERT_MAP) {
|
|
return strip->end - scale * (cframe - strip->actstart);
|
|
}
|
|
if (mode == NLATIME_CONVERT_UNMAP) {
|
|
return (strip->end + (strip->actstart * scale - cframe)) / scale;
|
|
}
|
|
/* if (mode == NLATIME_CONVERT_EVAL) */
|
|
if (IS_EQF((float)cframe, strip->end) && IS_EQF(strip->repeat, floorf(strip->repeat))) {
|
|
/* This case prevents the motion snapping back to the first frame at the end of the strip
|
|
* by catching the case where repeats is a whole number, which means that the end of the
|
|
* strip could also be interpreted as the end of the start of a repeat. */
|
|
return strip->actstart;
|
|
}
|
|
|
|
/* - the 'fmod(..., actlength * scale)' is needed to get the repeats working
|
|
* - the '/ scale' is needed to ensure that scaling influences the timing within the repeat
|
|
*/
|
|
return strip->actend - fmodf(cframe - strip->start, actlength * scale) / scale;
|
|
}
|
|
|
|
if (mode == NLATIME_CONVERT_MAP) {
|
|
return strip->start + scale * (cframe - strip->actstart);
|
|
}
|
|
if (mode == NLATIME_CONVERT_UNMAP) {
|
|
return strip->actstart + (cframe - strip->start) / scale;
|
|
}
|
|
/* if (mode == NLATIME_CONVERT_EVAL) */
|
|
if (IS_EQF(cframe, strip->end) && IS_EQF(strip->repeat, floorf(strip->repeat))) {
|
|
/* This case prevents the motion snapping back to the first frame at the end of the strip
|
|
* by catching the case where repeats is a whole number, which means that the end of the
|
|
* strip could also be interpreted as the end of the start of a repeat. */
|
|
return strip->actend;
|
|
}
|
|
|
|
/* - the 'fmod(..., actlength * scale)' is needed to get the repeats working
|
|
* - the '/ scale' is needed to ensure that scaling influences the timing within the repeat
|
|
*/
|
|
return strip->actstart + fmodf(cframe - strip->start, actlength * scale) / scale;
|
|
}
|
|
|
|
/* non clipped mapping for strip-time <-> global time (for Transitions)
|
|
* invert = convert action-strip time to global time
|
|
*/
|
|
static float nlastrip_get_frame_transition(NlaStrip *strip, float cframe, short mode)
|
|
{
|
|
float length;
|
|
|
|
/* length of strip */
|
|
length = strip->end - strip->start;
|
|
|
|
/* reversed = play strip backwards */
|
|
if (strip->flag & NLASTRIP_FLAG_REVERSE) {
|
|
if (mode == NLATIME_CONVERT_MAP) {
|
|
return strip->end - (length * cframe);
|
|
}
|
|
|
|
return (strip->end - cframe) / length;
|
|
}
|
|
|
|
if (mode == NLATIME_CONVERT_MAP) {
|
|
return (length * cframe) + strip->start;
|
|
}
|
|
|
|
return (cframe - strip->start) / length;
|
|
}
|
|
|
|
float nlastrip_get_frame(NlaStrip *strip, float cframe, short mode)
|
|
{
|
|
switch (strip->type) {
|
|
case NLASTRIP_TYPE_META: /* Meta - for now, does the same as transition
|
|
* (is really just an empty container). */
|
|
case NLASTRIP_TYPE_TRANSITION: /* transition */
|
|
return nlastrip_get_frame_transition(strip, cframe, mode);
|
|
|
|
case NLASTRIP_TYPE_CLIP: /* action-clip (default) */
|
|
default:
|
|
return nlastrip_get_frame_actionclip(strip, cframe, mode);
|
|
}
|
|
}
|
|
|
|
float BKE_nla_tweakedit_remap(AnimData *adt, float cframe, short mode)
|
|
{
|
|
NlaStrip *strip;
|
|
|
|
/* Sanity checks:
|
|
* - Obviously we've got to have some starting data.
|
|
* - When not in tweak-mode, the active Action does not have any scaling applied :)
|
|
* - When in tweak-mode, if the no-mapping flag is set, do not map.
|
|
*/
|
|
if ((adt == NULL) || (adt->flag & ADT_NLA_EDIT_ON) == 0 || (adt->flag & ADT_NLA_EDIT_NOMAP)) {
|
|
return cframe;
|
|
}
|
|
|
|
/* if the active-strip info has been stored already, access this, otherwise look this up
|
|
* and store for (very probable) future usage
|
|
*/
|
|
if (adt->act_track == NULL) {
|
|
if (adt->actstrip) {
|
|
adt->act_track = BKE_nlatrack_find_tweaked(adt);
|
|
}
|
|
else {
|
|
adt->act_track = BKE_nlatrack_find_active(&adt->nla_tracks);
|
|
}
|
|
}
|
|
if (adt->actstrip == NULL) {
|
|
adt->actstrip = BKE_nlastrip_find_active(adt->act_track);
|
|
}
|
|
strip = adt->actstrip;
|
|
|
|
/* Sanity checks:
|
|
* - In rare cases, we may not be able to find this strip for some reason (internal error)
|
|
* - For now, if the user has defined a curve to control the time, this correction cannot be
|
|
* performed reliably.
|
|
*/
|
|
if ((strip == NULL) || (strip->flag & NLASTRIP_FLAG_USR_TIME)) {
|
|
return cframe;
|
|
}
|
|
|
|
/* perform the correction now... */
|
|
return nlastrip_get_frame(strip, cframe, mode);
|
|
}
|
|
|
|
/* *************************************************** */
|
|
/* NLA API */
|
|
|
|
/* List of Strips ------------------------------------ */
|
|
/* (these functions are used for NLA-Tracks and also for nested/meta-strips) */
|
|
|
|
bool BKE_nlastrips_has_space(ListBase *strips, float start, float end)
|
|
{
|
|
NlaStrip *strip;
|
|
|
|
/* sanity checks */
|
|
if ((strips == NULL) || IS_EQF(start, end)) {
|
|
return false;
|
|
}
|
|
if (start > end) {
|
|
puts("BKE_nlastrips_has_space() error... start and end arguments swapped");
|
|
SWAP(float, start, end);
|
|
}
|
|
|
|
/* loop over NLA strips checking for any overlaps with this area... */
|
|
for (strip = strips->first; strip; strip = strip->next) {
|
|
/* if start frame of strip is past the target end-frame, that means that
|
|
* we've gone past the window we need to check for, so things are fine
|
|
*/
|
|
if (strip->start >= end) {
|
|
return true;
|
|
}
|
|
|
|
/* if the end of the strip is greater than either of the boundaries, the range
|
|
* must fall within the extents of the strip
|
|
*/
|
|
if ((strip->end > start) || (strip->end > end)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* if we are still here, we haven't encountered any overlapping strips */
|
|
return true;
|
|
}
|
|
|
|
void BKE_nlastrips_sort_strips(ListBase *strips)
|
|
{
|
|
ListBase tmp = {NULL, NULL};
|
|
NlaStrip *strip, *sstrip, *stripn;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, strips, strips->first)) {
|
|
return;
|
|
}
|
|
|
|
/* we simply perform insertion sort on this list, since it is assumed that per track,
|
|
* there are only likely to be at most 5-10 strips
|
|
*/
|
|
for (strip = strips->first; strip; strip = stripn) {
|
|
short not_added = 1;
|
|
|
|
stripn = strip->next;
|
|
|
|
/* remove this strip from the list, and add it to the new list, searching from the end of
|
|
* the list, assuming that the lists are in order
|
|
*/
|
|
BLI_remlink(strips, strip);
|
|
|
|
for (sstrip = tmp.last; sstrip; sstrip = sstrip->prev) {
|
|
/* check if add after */
|
|
if (sstrip->end <= strip->start) {
|
|
BLI_insertlinkafter(&tmp, sstrip, strip);
|
|
not_added = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* add before first? */
|
|
if (not_added) {
|
|
BLI_addhead(&tmp, strip);
|
|
}
|
|
}
|
|
|
|
/* reassign the start and end points of the strips */
|
|
strips->first = tmp.first;
|
|
strips->last = tmp.last;
|
|
}
|
|
|
|
bool BKE_nlastrips_add_strip(ListBase *strips, NlaStrip *strip)
|
|
{
|
|
NlaStrip *ns;
|
|
bool not_added = true;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, strips, strip)) {
|
|
return false;
|
|
}
|
|
|
|
/* check if any space to add */
|
|
if (BKE_nlastrips_has_space(strips, strip->start, strip->end) == 0) {
|
|
return false;
|
|
}
|
|
|
|
/* find the right place to add the strip to the nominated track */
|
|
for (ns = strips->first; ns; ns = ns->next) {
|
|
/* if current strip occurs after the new strip, add it before */
|
|
if (ns->start >= strip->end) {
|
|
BLI_insertlinkbefore(strips, ns, strip);
|
|
not_added = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (not_added) {
|
|
/* just add to the end of the list of the strips then... */
|
|
BLI_addtail(strips, strip);
|
|
}
|
|
|
|
/* added... */
|
|
return true;
|
|
}
|
|
|
|
/* Meta-Strips ------------------------------------ */
|
|
|
|
void BKE_nlastrips_make_metas(ListBase *strips, bool is_temp)
|
|
{
|
|
NlaStrip *mstrip = NULL;
|
|
NlaStrip *strip, *stripn;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, strips, strips->first)) {
|
|
return;
|
|
}
|
|
|
|
/* group all continuous chains of selected strips into meta-strips */
|
|
for (strip = strips->first; strip; strip = stripn) {
|
|
stripn = strip->next;
|
|
|
|
if (strip->flag & NLASTRIP_FLAG_SELECT) {
|
|
/* if there is an existing meta-strip, add this strip to it, otherwise, create a new one */
|
|
if (mstrip == NULL) {
|
|
/* add a new meta-strip, and add it before the current strip that it will replace... */
|
|
mstrip = MEM_callocN(sizeof(NlaStrip), "Meta-NlaStrip");
|
|
mstrip->type = NLASTRIP_TYPE_META;
|
|
BLI_insertlinkbefore(strips, strip, mstrip);
|
|
|
|
/* set flags */
|
|
mstrip->flag = NLASTRIP_FLAG_SELECT;
|
|
|
|
/* set temp flag if appropriate (i.e. for transform-type editing) */
|
|
if (is_temp) {
|
|
mstrip->flag |= NLASTRIP_FLAG_TEMP_META;
|
|
}
|
|
|
|
/* set default repeat/scale values to prevent warnings */
|
|
mstrip->repeat = mstrip->scale = 1.0f;
|
|
|
|
/* make its start frame be set to the start frame of the current strip */
|
|
mstrip->start = strip->start;
|
|
}
|
|
|
|
/* remove the selected strips from the track, and add to the meta */
|
|
BLI_remlink(strips, strip);
|
|
BLI_addtail(&mstrip->strips, strip);
|
|
|
|
/* expand the meta's dimensions to include the newly added strip- i.e. its last frame */
|
|
mstrip->end = strip->end;
|
|
}
|
|
else {
|
|
/* current strip wasn't selected, so the end of 'island' of selected strips has been reached,
|
|
* so stop adding strips to the current meta
|
|
*/
|
|
mstrip = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void BKE_nlastrips_clear_metastrip(ListBase *strips, NlaStrip *strip)
|
|
{
|
|
NlaStrip *cs, *csn;
|
|
|
|
/* sanity check */
|
|
if (ELEM(NULL, strips, strip)) {
|
|
return;
|
|
}
|
|
|
|
/* move each one of the meta-strip's children before the meta-strip
|
|
* in the list of strips after unlinking them from the meta-strip
|
|
*/
|
|
for (cs = strip->strips.first; cs; cs = csn) {
|
|
csn = cs->next;
|
|
BLI_remlink(&strip->strips, cs);
|
|
BLI_insertlinkbefore(strips, strip, cs);
|
|
}
|
|
|
|
/* free the meta-strip now */
|
|
BKE_nlastrip_free(strips, strip, true);
|
|
}
|
|
|
|
void BKE_nlastrips_clear_metas(ListBase *strips, bool only_sel, bool only_temp)
|
|
{
|
|
NlaStrip *strip, *stripn;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, strips, strips->first)) {
|
|
return;
|
|
}
|
|
|
|
/* remove meta-strips fitting the criteria of the arguments */
|
|
for (strip = strips->first; strip; strip = stripn) {
|
|
stripn = strip->next;
|
|
|
|
/* check if strip is a meta-strip */
|
|
if (strip->type == NLASTRIP_TYPE_META) {
|
|
/* if check if selection and 'temporary-only' considerations are met */
|
|
if ((!only_sel) || (strip->flag & NLASTRIP_FLAG_SELECT)) {
|
|
if ((!only_temp) || (strip->flag & NLASTRIP_FLAG_TEMP_META)) {
|
|
BKE_nlastrips_clear_metastrip(strips, strip);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool BKE_nlameta_add_strip(NlaStrip *mstrip, NlaStrip *strip)
|
|
{
|
|
/* sanity checks */
|
|
if (ELEM(NULL, mstrip, strip)) {
|
|
return false;
|
|
}
|
|
|
|
/* firstly, check if the meta-strip has space for this */
|
|
if (BKE_nlastrips_has_space(&mstrip->strips, strip->start, strip->end) == 0) {
|
|
return false;
|
|
}
|
|
|
|
/* check if this would need to be added to the ends of the meta,
|
|
* and subsequently, if the neighboring strips allow us enough room
|
|
*/
|
|
if (strip->start < mstrip->start) {
|
|
/* check if strip to the left (if it exists) ends before the
|
|
* start of the strip we're trying to add
|
|
*/
|
|
if ((mstrip->prev == NULL) || (mstrip->prev->end <= strip->start)) {
|
|
/* add strip to start of meta's list, and expand dimensions */
|
|
BLI_addhead(&mstrip->strips, strip);
|
|
mstrip->start = strip->start;
|
|
|
|
return true;
|
|
}
|
|
/* failed... no room before */
|
|
return false;
|
|
}
|
|
if (strip->end > mstrip->end) {
|
|
/* check if strip to the right (if it exists) starts before the
|
|
* end of the strip we're trying to add
|
|
*/
|
|
if ((mstrip->next == NULL) || (mstrip->next->start >= strip->end)) {
|
|
/* add strip to end of meta's list, and expand dimensions */
|
|
BLI_addtail(&mstrip->strips, strip);
|
|
mstrip->end = strip->end;
|
|
|
|
return true;
|
|
}
|
|
/* failed... no room after */
|
|
return false;
|
|
}
|
|
|
|
/* just try to add to the meta-strip (no dimension changes needed) */
|
|
return BKE_nlastrips_add_strip(&mstrip->strips, strip);
|
|
}
|
|
|
|
void BKE_nlameta_flush_transforms(NlaStrip *mstrip)
|
|
{
|
|
NlaStrip *strip;
|
|
float oStart, oEnd, offset;
|
|
float oLen, nLen;
|
|
short scaleChanged = 0;
|
|
|
|
/* sanity checks
|
|
* - strip must exist
|
|
* - strip must be a meta-strip with some contents
|
|
*/
|
|
if (ELEM(NULL, mstrip, mstrip->strips.first)) {
|
|
return;
|
|
}
|
|
if (mstrip->type != NLASTRIP_TYPE_META) {
|
|
return;
|
|
}
|
|
|
|
/* get the original start/end points, and calculate the start-frame offset
|
|
* - these are simply the start/end frames of the child strips,
|
|
* since we assume they weren't transformed yet
|
|
*/
|
|
oStart = ((NlaStrip *)mstrip->strips.first)->start;
|
|
oEnd = ((NlaStrip *)mstrip->strips.last)->end;
|
|
offset = mstrip->start - oStart;
|
|
|
|
/* optimization:
|
|
* don't flush if nothing changed yet
|
|
* TODO: maybe we need a flag to say always flush?
|
|
*/
|
|
if (IS_EQF(oStart, mstrip->start) && IS_EQF(oEnd, mstrip->end)) {
|
|
return;
|
|
}
|
|
|
|
/* check if scale changed */
|
|
oLen = oEnd - oStart;
|
|
nLen = mstrip->end - mstrip->start;
|
|
if (IS_EQF(nLen, oLen) == 0) {
|
|
scaleChanged = 1;
|
|
}
|
|
|
|
/* for each child-strip, calculate new start/end points based on this new info */
|
|
for (strip = mstrip->strips.first; strip; strip = strip->next) {
|
|
if (scaleChanged) {
|
|
float p1, p2;
|
|
|
|
/* compute positions of endpoints relative to old extents of strip */
|
|
p1 = (strip->start - oStart) / oLen;
|
|
p2 = (strip->end - oStart) / oLen;
|
|
|
|
/* Apply new strip endpoints using the proportions,
|
|
* then wait for second pass to flush scale properly. */
|
|
strip->start = (p1 * nLen) + mstrip->start;
|
|
strip->end = (p2 * nLen) + mstrip->start;
|
|
}
|
|
else {
|
|
/* just apply the changes in offset to both ends of the strip */
|
|
strip->start += offset;
|
|
strip->end += offset;
|
|
}
|
|
}
|
|
|
|
/* apply a second pass over child strips, to finish up unfinished business */
|
|
for (strip = mstrip->strips.first; strip; strip = strip->next) {
|
|
/* only if scale changed, need to perform RNA updates */
|
|
if (scaleChanged) {
|
|
PointerRNA ptr;
|
|
|
|
/* use RNA updates to compute scale properly */
|
|
RNA_pointer_create(NULL, &RNA_NlaStrip, strip, &ptr);
|
|
|
|
RNA_float_set(&ptr, "frame_start", strip->start);
|
|
RNA_float_set(&ptr, "frame_end", strip->end);
|
|
}
|
|
|
|
/* finally, make sure the strip's children (if it is a meta-itself), get updated */
|
|
BKE_nlameta_flush_transforms(strip);
|
|
}
|
|
}
|
|
|
|
/* NLA-Tracks ---------------------------------------- */
|
|
|
|
NlaTrack *BKE_nlatrack_find_active(ListBase *tracks)
|
|
{
|
|
NlaTrack *nlt;
|
|
|
|
/* sanity check */
|
|
if (ELEM(NULL, tracks, tracks->first)) {
|
|
return NULL;
|
|
}
|
|
|
|
/* try to find the first active track */
|
|
for (nlt = tracks->first; nlt; nlt = nlt->next) {
|
|
if (nlt->flag & NLATRACK_ACTIVE) {
|
|
return nlt;
|
|
}
|
|
}
|
|
|
|
/* none found */
|
|
return NULL;
|
|
}
|
|
|
|
NlaTrack *BKE_nlatrack_find_tweaked(AnimData *adt)
|
|
{
|
|
NlaTrack *nlt;
|
|
|
|
/* sanity check */
|
|
if (adt == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* Since the track itself gets disabled, we want the first disabled... */
|
|
for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
|
|
if (nlt->flag & (NLATRACK_ACTIVE | NLATRACK_DISABLED)) {
|
|
/* For good measure, make sure that strip actually exists there */
|
|
if (BLI_findindex(&nlt->strips, adt->actstrip) != -1) {
|
|
return nlt;
|
|
}
|
|
if (G.debug & G_DEBUG) {
|
|
printf("%s: Active strip (%p, %s) not in NLA track found (%p, %s)\n",
|
|
__func__,
|
|
adt->actstrip,
|
|
(adt->actstrip) ? adt->actstrip->name : "<None>",
|
|
nlt,
|
|
nlt->name);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Not found! */
|
|
return NULL;
|
|
}
|
|
|
|
void BKE_nlatrack_solo_toggle(AnimData *adt, NlaTrack *nlt)
|
|
{
|
|
NlaTrack *nt;
|
|
|
|
/* sanity check */
|
|
if (ELEM(NULL, adt, adt->nla_tracks.first)) {
|
|
return;
|
|
}
|
|
|
|
/* firstly, make sure 'solo' flag for all tracks is disabled */
|
|
for (nt = adt->nla_tracks.first; nt; nt = nt->next) {
|
|
if (nt != nlt) {
|
|
nt->flag &= ~NLATRACK_SOLO;
|
|
}
|
|
}
|
|
|
|
/* now, enable 'solo' for the given track if appropriate */
|
|
if (nlt) {
|
|
/* toggle solo status */
|
|
nlt->flag ^= NLATRACK_SOLO;
|
|
|
|
/* set or clear solo-status on AnimData */
|
|
if (nlt->flag & NLATRACK_SOLO) {
|
|
adt->flag |= ADT_NLA_SOLO_TRACK;
|
|
}
|
|
else {
|
|
adt->flag &= ~ADT_NLA_SOLO_TRACK;
|
|
}
|
|
}
|
|
else {
|
|
adt->flag &= ~ADT_NLA_SOLO_TRACK;
|
|
}
|
|
}
|
|
|
|
void BKE_nlatrack_set_active(ListBase *tracks, NlaTrack *nlt_a)
|
|
{
|
|
NlaTrack *nlt;
|
|
|
|
/* sanity check */
|
|
if (ELEM(NULL, tracks, tracks->first)) {
|
|
return;
|
|
}
|
|
|
|
/* deactivate all the rest */
|
|
for (nlt = tracks->first; nlt; nlt = nlt->next) {
|
|
nlt->flag &= ~NLATRACK_ACTIVE;
|
|
}
|
|
|
|
/* set the given one as the active one */
|
|
if (nlt_a) {
|
|
nlt_a->flag |= NLATRACK_ACTIVE;
|
|
}
|
|
}
|
|
|
|
bool BKE_nlatrack_has_space(NlaTrack *nlt, float start, float end)
|
|
{
|
|
/* sanity checks
|
|
* - track must exist
|
|
* - track must be editable
|
|
* - bounds cannot be equal (0-length is nasty)
|
|
*/
|
|
if ((nlt == NULL) || (nlt->flag & NLATRACK_PROTECTED) || IS_EQF(start, end)) {
|
|
return false;
|
|
}
|
|
|
|
if (start > end) {
|
|
puts("BKE_nlatrack_has_space() error... start and end arguments swapped");
|
|
SWAP(float, start, end);
|
|
}
|
|
|
|
/* check if there's any space left in the track for a strip of the given length */
|
|
return BKE_nlastrips_has_space(&nlt->strips, start, end);
|
|
}
|
|
|
|
void BKE_nlatrack_sort_strips(NlaTrack *nlt)
|
|
{
|
|
/* sanity checks */
|
|
if (ELEM(NULL, nlt, nlt->strips.first)) {
|
|
return;
|
|
}
|
|
|
|
/* sort the strips with a more generic function */
|
|
BKE_nlastrips_sort_strips(&nlt->strips);
|
|
}
|
|
|
|
bool BKE_nlatrack_add_strip(NlaTrack *nlt, NlaStrip *strip, const bool is_liboverride)
|
|
{
|
|
/* sanity checks */
|
|
if (ELEM(NULL, nlt, strip)) {
|
|
return false;
|
|
}
|
|
|
|
/* Do not allow adding strips if this track is locked, or not a local one in liboverride case. */
|
|
if (nlt->flag & NLATRACK_PROTECTED ||
|
|
(is_liboverride && (nlt->flag & NLATRACK_OVERRIDELIBRARY_LOCAL) == 0)) {
|
|
return false;
|
|
}
|
|
|
|
/* try to add the strip to the track using a more generic function */
|
|
return BKE_nlastrips_add_strip(&nlt->strips, strip);
|
|
}
|
|
|
|
bool BKE_nlatrack_get_bounds(NlaTrack *nlt, float bounds[2])
|
|
{
|
|
NlaStrip *strip;
|
|
|
|
/* initialize bounds */
|
|
if (bounds) {
|
|
bounds[0] = bounds[1] = 0.0f;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, nlt, nlt->strips.first)) {
|
|
return false;
|
|
}
|
|
|
|
/* lower bound is first strip's start frame */
|
|
strip = nlt->strips.first;
|
|
bounds[0] = strip->start;
|
|
|
|
/* upper bound is last strip's end frame */
|
|
strip = nlt->strips.last;
|
|
bounds[1] = strip->end;
|
|
|
|
/* done */
|
|
return true;
|
|
}
|
|
|
|
bool BKE_nlatrack_is_nonlocal_in_liboverride(const ID *id, const NlaTrack *nlt)
|
|
{
|
|
return (ID_IS_OVERRIDE_LIBRARY(id) &&
|
|
(nlt == NULL || (nlt->flag & NLATRACK_OVERRIDELIBRARY_LOCAL) == 0));
|
|
}
|
|
|
|
/* NLA Strips -------------------------------------- */
|
|
|
|
static NlaStrip *nlastrip_find_active(ListBase /* NlaStrip */ *strips)
|
|
{
|
|
LISTBASE_FOREACH (NlaStrip *, strip, strips) {
|
|
if (strip->flag & NLASTRIP_FLAG_ACTIVE) {
|
|
return strip;
|
|
}
|
|
|
|
if (strip->type != NLASTRIP_TYPE_META) {
|
|
continue;
|
|
}
|
|
|
|
NlaStrip *inner_active = nlastrip_find_active(&strip->strips);
|
|
if (inner_active != NULL) {
|
|
return inner_active;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
float BKE_nlastrip_compute_frame_from_previous_strip(NlaStrip *strip)
|
|
{
|
|
float limit_prev = MINAFRAMEF;
|
|
|
|
/* Find the previous end frame, with a special case if the previous strip was a transition : */
|
|
if (strip->prev) {
|
|
if (strip->prev->type == NLASTRIP_TYPE_TRANSITION) {
|
|
limit_prev = strip->prev->start + NLASTRIP_MIN_LEN_THRESH;
|
|
}
|
|
else {
|
|
limit_prev = strip->prev->end;
|
|
}
|
|
}
|
|
|
|
return limit_prev;
|
|
}
|
|
|
|
float BKE_nlastrip_compute_frame_to_next_strip(NlaStrip *strip)
|
|
{
|
|
float limit_next = MAXFRAMEF;
|
|
|
|
/* Find the next begin frame, with a special case if the next strip's a transition : */
|
|
if (strip->next) {
|
|
if (strip->next->type == NLASTRIP_TYPE_TRANSITION) {
|
|
limit_next = strip->next->end - NLASTRIP_MIN_LEN_THRESH;
|
|
}
|
|
else {
|
|
limit_next = strip->next->start;
|
|
}
|
|
}
|
|
|
|
return limit_next;
|
|
}
|
|
|
|
NlaStrip *BKE_nlastrip_next_in_track(struct NlaStrip *strip, bool skip_transitions)
|
|
{
|
|
NlaStrip *next = strip->next;
|
|
while (next != NULL) {
|
|
if (skip_transitions && (next->type & NLASTRIP_TYPE_TRANSITION)) {
|
|
next = next->next;
|
|
}
|
|
else {
|
|
return next;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
NlaStrip *BKE_nlastrip_prev_in_track(struct NlaStrip *strip, bool skip_transitions)
|
|
{
|
|
NlaStrip *prev = strip->prev;
|
|
while (prev != NULL) {
|
|
if (skip_transitions && (prev->type & NLASTRIP_TYPE_TRANSITION)) {
|
|
prev = prev->prev;
|
|
}
|
|
else {
|
|
return prev;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
NlaStrip *BKE_nlastrip_find_active(NlaTrack *nlt)
|
|
{
|
|
if (nlt == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
return nlastrip_find_active(&nlt->strips);
|
|
}
|
|
|
|
void BKE_nlastrip_set_active(AnimData *adt, NlaStrip *strip)
|
|
{
|
|
NlaTrack *nlt;
|
|
NlaStrip *nls;
|
|
|
|
/* sanity checks */
|
|
if (adt == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* Loop over tracks, deactivating. */
|
|
for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
|
|
for (nls = nlt->strips.first; nls; nls = nls->next) {
|
|
if (nls != strip) {
|
|
nls->flag &= ~NLASTRIP_FLAG_ACTIVE;
|
|
}
|
|
else {
|
|
nls->flag |= NLASTRIP_FLAG_ACTIVE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool BKE_nlastrip_within_bounds(NlaStrip *strip, float min, float max)
|
|
{
|
|
const float stripLen = (strip) ? strip->end - strip->start : 0.0f;
|
|
const float boundsLen = fabsf(max - min);
|
|
|
|
/* sanity checks */
|
|
if ((strip == NULL) || IS_EQF(stripLen, 0.0f) || IS_EQF(boundsLen, 0.0f)) {
|
|
return false;
|
|
}
|
|
|
|
/* only ok if at least part of the strip is within the bounding window
|
|
* - first 2 cases cover when the strip length is less than the bounding area
|
|
* - second 2 cases cover when the strip length is greater than the bounding area
|
|
*/
|
|
if ((stripLen < boundsLen) &&
|
|
!(IN_RANGE(strip->start, min, max) || IN_RANGE(strip->end, min, max))) {
|
|
return false;
|
|
}
|
|
if ((stripLen > boundsLen) &&
|
|
!(IN_RANGE(min, strip->start, strip->end) || IN_RANGE(max, strip->start, strip->end))) {
|
|
return false;
|
|
}
|
|
|
|
/* should be ok! */
|
|
return true;
|
|
}
|
|
|
|
float BKE_nlastrip_distance_to_frame(const NlaStrip *strip, const float timeline_frame)
|
|
{
|
|
if (timeline_frame < strip->start) {
|
|
return strip->start - timeline_frame;
|
|
}
|
|
if (strip->end < timeline_frame) {
|
|
return timeline_frame - strip->end;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
/* Ensure that strip doesn't overlap those around it after resizing
|
|
* by offsetting those which follow. */
|
|
static void nlastrip_fix_resize_overlaps(NlaStrip *strip)
|
|
{
|
|
/* next strips - do this first, since we're often just getting longer */
|
|
if (strip->next) {
|
|
NlaStrip *nls = strip->next;
|
|
float offset = 0.0f;
|
|
|
|
if (nls->type == NLASTRIP_TYPE_TRANSITION) {
|
|
/* transition strips should grow/shrink to accommodate the resized strip,
|
|
* but if the strip's bounds now exceed the transition, we're forced to
|
|
* offset everything to maintain the balance
|
|
*/
|
|
if (strip->end <= nls->start) {
|
|
/* grow the transition to fill the void */
|
|
nls->start = strip->end;
|
|
}
|
|
else if (strip->end < nls->end) {
|
|
/* shrink the transition to give the strip room */
|
|
nls->start = strip->end;
|
|
}
|
|
else {
|
|
/* Shrink transition down to 1 frame long (so that it can still be found),
|
|
* then offset everything else by the remaining deficit to give the strip room. */
|
|
nls->start = nls->end - 1.0f;
|
|
|
|
/* XXX: review whether preventing fractional values is good here... */
|
|
offset = ceilf(strip->end - nls->start);
|
|
|
|
/* apply necessary offset to ensure that the strip has enough space */
|
|
for (; nls; nls = nls->next) {
|
|
nls->start += offset;
|
|
nls->end += offset;
|
|
}
|
|
}
|
|
}
|
|
else if (strip->end > nls->start) {
|
|
/* NOTE: need to ensure we don't have a fractional frame offset, even if that leaves a gap,
|
|
* otherwise it will be very hard to get rid of later
|
|
*/
|
|
offset = ceilf(strip->end - nls->start);
|
|
|
|
/* apply to times of all strips in this direction */
|
|
for (; nls; nls = nls->next) {
|
|
nls->start += offset;
|
|
nls->end += offset;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* previous strips - same routine as before */
|
|
/* NOTE: when strip bounds are recalculated, this is not considered! */
|
|
if (strip->prev) {
|
|
NlaStrip *nls = strip->prev;
|
|
float offset = 0.0f;
|
|
|
|
if (nls->type == NLASTRIP_TYPE_TRANSITION) {
|
|
/* transition strips should grow/shrink to accommodate the resized strip,
|
|
* but if the strip's bounds now exceed the transition, we're forced to
|
|
* offset everything to maintain the balance
|
|
*/
|
|
if (strip->start >= nls->end) {
|
|
/* grow the transition to fill the void */
|
|
nls->end = strip->start;
|
|
}
|
|
else if (strip->start > nls->start) {
|
|
/* shrink the transition to give the strip room */
|
|
nls->end = strip->start;
|
|
}
|
|
else {
|
|
/* Shrink transition down to 1 frame long (so that it can still be found),
|
|
* then offset everything else by the remaining deficit to give the strip room. */
|
|
nls->end = nls->start + 1.0f;
|
|
|
|
/* XXX: review whether preventing fractional values is good here... */
|
|
offset = ceilf(nls->end - strip->start);
|
|
|
|
/* apply necessary offset to ensure that the strip has enough space */
|
|
for (; nls; nls = nls->prev) {
|
|
nls->start -= offset;
|
|
nls->end -= offset;
|
|
}
|
|
}
|
|
}
|
|
else if (strip->start < nls->end) {
|
|
/* NOTE: need to ensure we don't have a fractional frame offset, even if that leaves a gap,
|
|
* otherwise it will be very hard to get rid of later
|
|
*/
|
|
offset = ceilf(nls->end - strip->start);
|
|
|
|
/* apply to times of all strips in this direction */
|
|
for (; nls; nls = nls->prev) {
|
|
nls->start -= offset;
|
|
nls->end -= offset;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void BKE_nlastrip_recalculate_bounds_sync_action(NlaStrip *strip)
|
|
{
|
|
float prev_actstart;
|
|
|
|
if (strip == NULL || strip->type != NLASTRIP_TYPE_CLIP) {
|
|
return;
|
|
}
|
|
|
|
prev_actstart = strip->actstart;
|
|
|
|
BKE_action_get_frame_range(strip->act, &strip->actstart, &strip->actend);
|
|
|
|
/* Set start such that key's do not visually move, to preserve the overall animation result. */
|
|
strip->start += (strip->actstart - prev_actstart) * strip->scale;
|
|
|
|
BKE_nlastrip_recalculate_bounds(strip);
|
|
}
|
|
void BKE_nlastrip_recalculate_bounds(NlaStrip *strip)
|
|
{
|
|
float actlen, mapping;
|
|
|
|
/* sanity checks
|
|
* - must have a strip
|
|
* - can only be done for action clips
|
|
*/
|
|
if ((strip == NULL) || (strip->type != NLASTRIP_TYPE_CLIP)) {
|
|
return;
|
|
}
|
|
|
|
/* calculate new length factors */
|
|
actlen = strip->actend - strip->actstart;
|
|
if (IS_EQF(actlen, 0.0f)) {
|
|
actlen = 1.0f;
|
|
}
|
|
|
|
mapping = strip->scale * strip->repeat;
|
|
|
|
/* adjust endpoint of strip in response to this */
|
|
if (IS_EQF(mapping, 0.0f) == 0) {
|
|
strip->end = (actlen * mapping) + strip->start;
|
|
}
|
|
|
|
/* make sure we don't overlap our neighbors */
|
|
nlastrip_fix_resize_overlaps(strip);
|
|
}
|
|
|
|
/* Animated Strips ------------------------------------------- */
|
|
|
|
bool BKE_nlatrack_has_animated_strips(NlaTrack *nlt)
|
|
{
|
|
NlaStrip *strip;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, nlt, nlt->strips.first)) {
|
|
return false;
|
|
}
|
|
|
|
/* check each strip for F-Curves only (don't care about whether the flags are set) */
|
|
for (strip = nlt->strips.first; strip; strip = strip->next) {
|
|
if (strip->fcurves.first) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/* none found */
|
|
return false;
|
|
}
|
|
|
|
bool BKE_nlatracks_have_animated_strips(ListBase *tracks)
|
|
{
|
|
NlaTrack *nlt;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, tracks, tracks->first)) {
|
|
return false;
|
|
}
|
|
|
|
/* check each track, stopping on the first hit */
|
|
for (nlt = tracks->first; nlt; nlt = nlt->next) {
|
|
if (BKE_nlatrack_has_animated_strips(nlt)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/* none found */
|
|
return false;
|
|
}
|
|
|
|
void BKE_nlastrip_validate_fcurves(NlaStrip *strip)
|
|
{
|
|
FCurve *fcu;
|
|
|
|
/* sanity checks */
|
|
if (strip == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* if controlling influence... */
|
|
if (strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) {
|
|
/* try to get F-Curve */
|
|
fcu = BKE_fcurve_find(&strip->fcurves, "influence", 0);
|
|
|
|
/* add one if not found */
|
|
if (fcu == NULL) {
|
|
/* make new F-Curve */
|
|
fcu = BKE_fcurve_create();
|
|
BLI_addtail(&strip->fcurves, fcu);
|
|
|
|
/* set default flags */
|
|
fcu->flag = (FCURVE_VISIBLE | FCURVE_SELECTED);
|
|
fcu->auto_smoothing = U.auto_smoothing_new;
|
|
|
|
/* store path - make copy, and store that */
|
|
fcu->rna_path = BLI_strdupn("influence", 9);
|
|
|
|
/* insert keyframe to ensure current value stays on first refresh */
|
|
fcu->bezt = MEM_callocN(sizeof(BezTriple), "nlastrip influence bezt");
|
|
fcu->totvert = 1;
|
|
|
|
fcu->bezt->vec[1][0] = strip->start;
|
|
fcu->bezt->vec[1][1] = strip->influence;
|
|
|
|
/* Respect User Preferences for default interpolation and handles. */
|
|
fcu->bezt->h1 = fcu->bezt->h2 = U.keyhandles_new;
|
|
fcu->bezt->ipo = U.ipo_new;
|
|
}
|
|
}
|
|
|
|
/* if controlling time... */
|
|
if (strip->flag & NLASTRIP_FLAG_USR_TIME) {
|
|
/* try to get F-Curve */
|
|
fcu = BKE_fcurve_find(&strip->fcurves, "strip_time", 0);
|
|
|
|
/* add one if not found */
|
|
if (fcu == NULL) {
|
|
/* make new F-Curve */
|
|
fcu = BKE_fcurve_create();
|
|
BLI_addtail(&strip->fcurves, fcu);
|
|
|
|
/* set default flags */
|
|
fcu->flag = (FCURVE_VISIBLE | FCURVE_SELECTED);
|
|
fcu->auto_smoothing = U.auto_smoothing_new;
|
|
|
|
/* store path - make copy, and store that */
|
|
fcu->rna_path = BLI_strdupn("strip_time", 10);
|
|
|
|
/* TODO: insert a few keyframes to ensure default behavior? */
|
|
}
|
|
}
|
|
}
|
|
|
|
bool BKE_nlastrip_has_curves_for_property(const PointerRNA *ptr, const PropertyRNA *prop)
|
|
{
|
|
/* sanity checks */
|
|
if (ELEM(NULL, ptr, prop)) {
|
|
return false;
|
|
}
|
|
|
|
/* 1) Must be NLA strip */
|
|
if (ptr->type == &RNA_NlaStrip) {
|
|
/* 2) Must be one of the predefined properties */
|
|
static PropertyRNA *prop_influence = NULL;
|
|
static PropertyRNA *prop_time = NULL;
|
|
static bool needs_init = true;
|
|
|
|
/* Init the properties on first use */
|
|
if (needs_init) {
|
|
prop_influence = RNA_struct_type_find_property(&RNA_NlaStrip, "influence");
|
|
prop_time = RNA_struct_type_find_property(&RNA_NlaStrip, "strip_time");
|
|
|
|
needs_init = false;
|
|
}
|
|
|
|
/* Check if match */
|
|
if (ELEM(prop, prop_influence, prop_time)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/* No criteria met */
|
|
return false;
|
|
}
|
|
|
|
/* Sanity Validation ------------------------------------ */
|
|
|
|
static bool nla_editbone_name_check(void *arg, const char *name)
|
|
{
|
|
return BLI_ghash_haskey((GHash *)arg, (const void *)name);
|
|
}
|
|
|
|
void BKE_nlastrip_validate_name(AnimData *adt, NlaStrip *strip)
|
|
{
|
|
GHash *gh;
|
|
NlaStrip *tstrip;
|
|
NlaTrack *nlt;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, adt, strip)) {
|
|
return;
|
|
}
|
|
|
|
/* give strip a default name if none already */
|
|
if (strip->name[0] == 0) {
|
|
switch (strip->type) {
|
|
case NLASTRIP_TYPE_CLIP: /* act-clip */
|
|
BLI_strncpy(strip->name,
|
|
(strip->act) ? (strip->act->id.name + 2) : ("<No Action>"),
|
|
sizeof(strip->name));
|
|
break;
|
|
case NLASTRIP_TYPE_TRANSITION: /* transition */
|
|
BLI_strncpy(strip->name, "Transition", sizeof(strip->name));
|
|
break;
|
|
case NLASTRIP_TYPE_META: /* meta */
|
|
BLI_strncpy(strip->name, "Meta", sizeof(strip->name));
|
|
break;
|
|
default:
|
|
BLI_strncpy(strip->name, "NLA Strip", sizeof(strip->name));
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* build a hash-table of all the strips in the tracks
|
|
* - this is easier than iterating over all the tracks+strips hierarchy every time
|
|
* (and probably faster)
|
|
*/
|
|
gh = BLI_ghash_str_new("nlastrip_validate_name gh");
|
|
|
|
for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
|
|
for (tstrip = nlt->strips.first; tstrip; tstrip = tstrip->next) {
|
|
/* don't add the strip of interest */
|
|
if (tstrip == strip) {
|
|
continue;
|
|
}
|
|
|
|
/* Use the name of the strip as the key, and the strip as the value,
|
|
* since we're mostly interested in the keys. */
|
|
BLI_ghash_insert(gh, tstrip->name, tstrip);
|
|
}
|
|
}
|
|
|
|
/* If the hash-table has a match for this name, try other names...
|
|
* - In an extreme case, it might not be able to find a name,
|
|
* but then everything else in Blender would fail too :).
|
|
*/
|
|
BLI_uniquename_cb(nla_editbone_name_check,
|
|
(void *)gh,
|
|
DATA_("NlaStrip"),
|
|
'.',
|
|
strip->name,
|
|
sizeof(strip->name));
|
|
|
|
/* free the hash... */
|
|
BLI_ghash_free(gh, NULL, NULL);
|
|
}
|
|
|
|
/* ---- */
|
|
|
|
/* Get strips which overlap the given one at the start/end of its range
|
|
* - strip: strip that we're finding overlaps for
|
|
* - track: nla-track that the overlapping strips should be found from
|
|
* - start, end: frames for the offending endpoints
|
|
*/
|
|
static void nlastrip_get_endpoint_overlaps(NlaStrip *strip,
|
|
NlaTrack *track,
|
|
float **start,
|
|
float **end)
|
|
{
|
|
NlaStrip *nls;
|
|
|
|
/* find strips that overlap over the start/end of the given strip,
|
|
* but which don't cover the entire length
|
|
*/
|
|
/* TODO: this scheme could get quite slow for doing this on many strips... */
|
|
for (nls = track->strips.first; nls; nls = nls->next) {
|
|
/* Check if strip overlaps (extends over or exactly on)
|
|
* the entire range of the strip we're validating. */
|
|
if ((nls->start <= strip->start) && (nls->end >= strip->end)) {
|
|
*start = NULL;
|
|
*end = NULL;
|
|
return;
|
|
}
|
|
|
|
/* check if strip doesn't even occur anywhere near... */
|
|
if (nls->end < strip->start) {
|
|
continue; /* skip checking this strip... not worthy of mention */
|
|
}
|
|
if (nls->start > strip->end) {
|
|
return; /* the range we're after has already passed */
|
|
}
|
|
|
|
/* if this strip is not part of an island of continuous strips, it can be used
|
|
* - this check needs to be done for each end of the strip we try and use...
|
|
*/
|
|
if ((nls->next == NULL) || IS_EQF(nls->next->start, nls->end) == 0) {
|
|
if ((nls->end > strip->start) && (nls->end < strip->end)) {
|
|
*start = &nls->end;
|
|
}
|
|
}
|
|
if ((nls->prev == NULL) || IS_EQF(nls->prev->end, nls->start) == 0) {
|
|
if ((nls->start < strip->end) && (nls->start > strip->start)) {
|
|
*end = &nls->start;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Determine auto-blending for the given strip */
|
|
static void BKE_nlastrip_validate_autoblends(NlaTrack *nlt, NlaStrip *nls)
|
|
{
|
|
float *ps = NULL, *pe = NULL;
|
|
float *ns = NULL, *ne = NULL;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, nls, nlt)) {
|
|
return;
|
|
}
|
|
if ((nlt->prev == NULL) && (nlt->next == NULL)) {
|
|
return;
|
|
}
|
|
if ((nls->flag & NLASTRIP_FLAG_AUTO_BLENDS) == 0) {
|
|
return;
|
|
}
|
|
|
|
/* get test ranges */
|
|
if (nlt->prev) {
|
|
nlastrip_get_endpoint_overlaps(nls, nlt->prev, &ps, &pe);
|
|
}
|
|
if (nlt->next) {
|
|
nlastrip_get_endpoint_overlaps(nls, nlt->next, &ns, &ne);
|
|
}
|
|
|
|
/* set overlaps for this strip
|
|
* - don't use the values obtained though if the end in question
|
|
* is directly followed/preceded by another strip, forming an
|
|
* 'island' of continuous strips
|
|
*/
|
|
if ((ps || ns) && ((nls->prev == NULL) || IS_EQF(nls->prev->end, nls->start) == 0)) {
|
|
/* start overlaps - pick the largest overlap */
|
|
if (((ps && ns) && (*ps > *ns)) || (ps)) {
|
|
nls->blendin = *ps - nls->start;
|
|
}
|
|
else {
|
|
nls->blendin = *ns - nls->start;
|
|
}
|
|
}
|
|
else { /* no overlap allowed/needed */
|
|
nls->blendin = 0.0f;
|
|
}
|
|
|
|
if ((pe || ne) && ((nls->next == NULL) || IS_EQF(nls->next->start, nls->end) == 0)) {
|
|
/* end overlaps - pick the largest overlap */
|
|
if (((pe && ne) && (*pe > *ne)) || (pe)) {
|
|
nls->blendout = nls->end - *pe;
|
|
}
|
|
else {
|
|
nls->blendout = nls->end - *ne;
|
|
}
|
|
}
|
|
else { /* no overlap allowed/needed */
|
|
nls->blendout = 0.0f;
|
|
}
|
|
}
|
|
|
|
void BKE_nla_validate_state(AnimData *adt)
|
|
{
|
|
NlaStrip *strip = NULL;
|
|
NlaTrack *nlt;
|
|
|
|
/* sanity checks */
|
|
if (ELEM(NULL, adt, adt->nla_tracks.first)) {
|
|
return;
|
|
}
|
|
|
|
/* Adjust blending values for auto-blending,
|
|
* and also do an initial pass to find the earliest strip. */
|
|
for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
|
|
for (strip = nlt->strips.first; strip; strip = strip->next) {
|
|
/* auto-blending first */
|
|
BKE_nlastrip_validate_autoblends(nlt, strip);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Action Stashing -------------------------------------- */
|
|
|
|
/* name of stashed tracks - the translation stuff is included here to save extra work */
|
|
#define STASH_TRACK_NAME DATA_("[Action Stash]")
|
|
|
|
bool BKE_nla_action_is_stashed(AnimData *adt, bAction *act)
|
|
{
|
|
NlaTrack *nlt;
|
|
NlaStrip *strip;
|
|
|
|
for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
|
|
if (strstr(nlt->name, STASH_TRACK_NAME)) {
|
|
for (strip = nlt->strips.first; strip; strip = strip->next) {
|
|
if (strip->act == act) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool BKE_nla_action_stash(AnimData *adt, const bool is_liboverride)
|
|
{
|
|
NlaTrack *prev_track = NULL;
|
|
NlaTrack *nlt;
|
|
NlaStrip *strip;
|
|
|
|
/* sanity check */
|
|
if (ELEM(NULL, adt, adt->action)) {
|
|
CLOG_ERROR(&LOG, "Invalid argument - %p %p", adt, adt->action);
|
|
return false;
|
|
}
|
|
|
|
/* do not add if it is already stashed */
|
|
if (BKE_nla_action_is_stashed(adt, adt->action)) {
|
|
return false;
|
|
}
|
|
|
|
/* create a new track, and add this immediately above the previous stashing track */
|
|
for (prev_track = adt->nla_tracks.last; prev_track; prev_track = prev_track->prev) {
|
|
if (strstr(prev_track->name, STASH_TRACK_NAME)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
nlt = BKE_nlatrack_add(adt, prev_track, is_liboverride);
|
|
BLI_assert(nlt != NULL);
|
|
|
|
/* We need to ensure that if there wasn't any previous instance,
|
|
* it must go to be bottom of the stack. */
|
|
if (prev_track == NULL) {
|
|
BLI_remlink(&adt->nla_tracks, nlt);
|
|
BLI_addhead(&adt->nla_tracks, nlt);
|
|
}
|
|
|
|
BLI_strncpy(nlt->name, STASH_TRACK_NAME, sizeof(nlt->name));
|
|
BLI_uniquename(
|
|
&adt->nla_tracks, nlt, STASH_TRACK_NAME, '.', offsetof(NlaTrack, name), sizeof(nlt->name));
|
|
|
|
/* add the action as a strip in this new track
|
|
* NOTE: a new user is created here
|
|
*/
|
|
strip = BKE_nlastrip_new(adt->action);
|
|
BLI_assert(strip != NULL);
|
|
|
|
BKE_nlatrack_add_strip(nlt, strip, is_liboverride);
|
|
BKE_nlastrip_validate_name(adt, strip);
|
|
|
|
/* mark the stash track and strip so that they doesn't disturb the stack animation,
|
|
* and are unlikely to draw attention to itself (or be accidentally bumped around)
|
|
*
|
|
* NOTE: this must be done *after* adding the strip to the track, or else
|
|
* the strip locking will prevent the strip from getting added
|
|
*/
|
|
nlt->flag |= (NLATRACK_MUTED | NLATRACK_PROTECTED);
|
|
strip->flag &= ~(NLASTRIP_FLAG_SELECT | NLASTRIP_FLAG_ACTIVE);
|
|
|
|
/* also mark the strip for auto syncing the length, so that the strips accurately
|
|
* reflect the length of the action
|
|
* XXX: we could do with some extra flags here to prevent repeats/scaling options from working!
|
|
*/
|
|
strip->flag |= NLASTRIP_FLAG_SYNC_LENGTH;
|
|
|
|
/* succeeded */
|
|
return true;
|
|
}
|
|
|
|
/* Core Tools ------------------------------------------- */
|
|
|
|
void BKE_nla_action_pushdown(AnimData *adt, const bool is_liboverride)
|
|
{
|
|
NlaStrip *strip;
|
|
|
|
/* sanity checks */
|
|
/* TODO: need to report the error for this */
|
|
if (ELEM(NULL, adt, adt->action)) {
|
|
return;
|
|
}
|
|
|
|
/* if the action is empty, we also shouldn't try to add to stack,
|
|
* as that will cause us grief down the track
|
|
*/
|
|
/* TODO: what about modifiers? */
|
|
if (action_has_motion(adt->action) == 0) {
|
|
CLOG_ERROR(&LOG, "action has no data");
|
|
return;
|
|
}
|
|
|
|
/* add a new NLA strip to the track, which references the active action */
|
|
strip = BKE_nlastack_add_strip(adt, adt->action, is_liboverride);
|
|
if (strip == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* clear reference to action now that we've pushed it onto the stack */
|
|
id_us_min(&adt->action->id);
|
|
adt->action = NULL;
|
|
|
|
/* copy current "action blending" settings from adt to the strip,
|
|
* as it was keyframed with these settings, so omitting them will
|
|
* change the effect [T54233]
|
|
*/
|
|
strip->blendmode = adt->act_blendmode;
|
|
strip->influence = adt->act_influence;
|
|
strip->extendmode = adt->act_extendmode;
|
|
|
|
if (adt->act_influence < 1.0f) {
|
|
/* enable "user-controlled" influence (which will insert a default keyframe)
|
|
* so that the influence doesn't get lost on the new update
|
|
*
|
|
* NOTE: An alternative way would have been to instead hack the influence
|
|
* to not get always get reset to full strength if NLASTRIP_FLAG_USR_INFLUENCE
|
|
* is disabled but auto-blending isn't being used. However, that approach
|
|
* is a bit hacky/hard to discover, and may cause backwards compatibility issues,
|
|
* so it's better to just do it this way.
|
|
*/
|
|
strip->flag |= NLASTRIP_FLAG_USR_INFLUENCE;
|
|
BKE_nlastrip_validate_fcurves(strip);
|
|
}
|
|
|
|
/* make strip the active one... */
|
|
BKE_nlastrip_set_active(adt, strip);
|
|
}
|
|
|
|
static void nla_tweakmode_find_active(const ListBase /* NlaTrack */ *nla_tracks,
|
|
NlaTrack **r_track_of_active_strip,
|
|
NlaStrip **r_active_strip)
|
|
{
|
|
NlaTrack *nlt, *activeTrack = NULL;
|
|
NlaStrip *strip, *activeStrip = NULL;
|
|
|
|
/* go over the tracks, finding the active one, and its active strip
|
|
* - if we cannot find both, then there's nothing to do
|
|
*/
|
|
for (nlt = nla_tracks->first; nlt; nlt = nlt->next) {
|
|
/* check if active */
|
|
if (nlt->flag & NLATRACK_ACTIVE) {
|
|
/* store reference to this active track */
|
|
activeTrack = nlt;
|
|
|
|
/* now try to find active strip */
|
|
activeStrip = BKE_nlastrip_find_active(nlt);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* There are situations where we may have multiple strips selected and we want to enter
|
|
* tweak-mode on all of those at once. Usually in those cases,
|
|
* it will usually just be a single strip per AnimData.
|
|
* In such cases, compromise and take the last selected track and/or last selected strip, T28468.
|
|
*/
|
|
if (activeTrack == NULL) {
|
|
/* try last selected track for active strip */
|
|
for (nlt = nla_tracks->last; nlt; nlt = nlt->prev) {
|
|
if (nlt->flag & NLATRACK_SELECTED) {
|
|
/* assume this is the active track */
|
|
activeTrack = nlt;
|
|
|
|
/* try to find active strip */
|
|
activeStrip = BKE_nlastrip_find_active(nlt);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ((activeTrack) && (activeStrip == NULL)) {
|
|
/* No active strip in active or last selected track;
|
|
* compromise for first selected (assuming only single). */
|
|
for (strip = activeTrack->strips.first; strip; strip = strip->next) {
|
|
if (strip->flag & (NLASTRIP_FLAG_SELECT | NLASTRIP_FLAG_ACTIVE)) {
|
|
activeStrip = strip;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
*r_track_of_active_strip = activeTrack;
|
|
*r_active_strip = activeStrip;
|
|
}
|
|
|
|
bool BKE_nla_tweakmode_enter(AnimData *adt)
|
|
{
|
|
NlaTrack *nlt, *activeTrack = NULL;
|
|
NlaStrip *strip, *activeStrip = NULL;
|
|
|
|
/* verify that data is valid */
|
|
if (ELEM(NULL, adt, adt->nla_tracks.first)) {
|
|
return false;
|
|
}
|
|
|
|
/* If block is already in tweak-mode, just leave, but we should report
|
|
* that this block is in tweak-mode (as our return-code). */
|
|
if (adt->flag & ADT_NLA_EDIT_ON) {
|
|
return true;
|
|
}
|
|
|
|
nla_tweakmode_find_active(&adt->nla_tracks, &activeTrack, &activeStrip);
|
|
|
|
if (ELEM(NULL, activeTrack, activeStrip, activeStrip->act)) {
|
|
if (G.debug & G_DEBUG) {
|
|
printf("NLA tweak-mode enter - neither active requirement found\n");
|
|
printf("\tactiveTrack = %p, activeStrip = %p\n", (void *)activeTrack, (void *)activeStrip);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Go over all the tracks, tagging each strip that uses the same
|
|
* action as the active strip, but leaving everything else alone.
|
|
*/
|
|
for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
|
|
for (strip = nlt->strips.first; strip; strip = strip->next) {
|
|
if (strip->act == activeStrip->act) {
|
|
strip->flag |= NLASTRIP_FLAG_TWEAKUSER;
|
|
}
|
|
else {
|
|
strip->flag &= ~NLASTRIP_FLAG_TWEAKUSER;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Untag tweaked track. This leads to non tweaked actions being drawn differently than the
|
|
* tweaked action. */
|
|
activeStrip->flag &= ~NLASTRIP_FLAG_TWEAKUSER;
|
|
|
|
/* go over all the tracks after AND INCLUDING the active one, tagging them as being disabled
|
|
* - the active track needs to also be tagged, otherwise, it'll overlap with the tweaks going on
|
|
*/
|
|
activeTrack->flag |= NLATRACK_DISABLED;
|
|
if ((adt->flag & ADT_NLA_EVAL_UPPER_TRACKS) == 0) {
|
|
for (nlt = activeTrack->next; nlt; nlt = nlt->next) {
|
|
nlt->flag |= NLATRACK_DISABLED;
|
|
}
|
|
}
|
|
|
|
/* handle AnimData level changes:
|
|
* - 'real' active action to temp storage (no need to change user-counts).
|
|
* - Action of active strip set to be the 'active action', and have its user-count incremented.
|
|
* - Editing-flag for this AnimData block should also get turned on
|
|
* (for more efficient restoring).
|
|
* - Take note of the active strip for mapping-correction of keyframes
|
|
* in the action being edited.
|
|
*/
|
|
adt->tmpact = adt->action;
|
|
adt->action = activeStrip->act;
|
|
adt->act_track = activeTrack;
|
|
adt->actstrip = activeStrip;
|
|
id_us_plus(&activeStrip->act->id);
|
|
adt->flag |= ADT_NLA_EDIT_ON;
|
|
|
|
/* done! */
|
|
return true;
|
|
}
|
|
|
|
void BKE_nla_tweakmode_exit(AnimData *adt)
|
|
{
|
|
NlaStrip *strip;
|
|
NlaTrack *nlt;
|
|
|
|
/* verify that data is valid */
|
|
if (ELEM(NULL, adt, adt->nla_tracks.first)) {
|
|
return;
|
|
}
|
|
|
|
/* hopefully the flag is correct - skip if not on */
|
|
if ((adt->flag & ADT_NLA_EDIT_ON) == 0) {
|
|
return;
|
|
}
|
|
|
|
/* sync the length of the user-strip with the new state of the action
|
|
* but only if the user has explicitly asked for this to happen
|
|
* (see T34645 for things to be careful about)
|
|
*/
|
|
if ((adt->actstrip) && (adt->actstrip->flag & NLASTRIP_FLAG_SYNC_LENGTH)) {
|
|
strip = adt->actstrip;
|
|
|
|
/* must be action-clip only (transitions don't have scale) */
|
|
if ((strip->type == NLASTRIP_TYPE_CLIP) && (strip->act)) {
|
|
BKE_nlastrip_recalculate_bounds_sync_action(strip);
|
|
}
|
|
}
|
|
|
|
/* for all Tracks, clear the 'disabled' flag
|
|
* for all Strips, clear the 'tweak-user' flag
|
|
*/
|
|
for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
|
|
nlt->flag &= ~NLATRACK_DISABLED;
|
|
|
|
for (strip = nlt->strips.first; strip; strip = strip->next) {
|
|
/* sync strip extents if this strip uses the same action */
|
|
if ((adt->actstrip) && (adt->actstrip->act == strip->act) &&
|
|
(strip->flag & NLASTRIP_FLAG_SYNC_LENGTH)) {
|
|
BKE_nlastrip_recalculate_bounds_sync_action(strip);
|
|
}
|
|
|
|
/* clear tweakuser flag */
|
|
strip->flag &= ~NLASTRIP_FLAG_TWEAKUSER;
|
|
}
|
|
}
|
|
|
|
/* handle AnimData level changes:
|
|
* - 'temporary' active action needs its user-count decreased,
|
|
* since we're removing this reference
|
|
* - 'real' active action is restored from storage
|
|
* - storage pointer gets cleared (to avoid having bad notes hanging around)
|
|
* - editing-flag for this AnimData block should also get turned off
|
|
* - clear pointer to active strip
|
|
*/
|
|
if (adt->action) {
|
|
id_us_min(&adt->action->id);
|
|
}
|
|
adt->action = adt->tmpact;
|
|
adt->tmpact = NULL;
|
|
adt->act_track = NULL;
|
|
adt->actstrip = NULL;
|
|
adt->flag &= ~ADT_NLA_EDIT_ON;
|
|
}
|
|
|
|
static void blend_write_nla_strips(BlendWriter *writer, ListBase *strips)
|
|
{
|
|
BLO_write_struct_list(writer, NlaStrip, strips);
|
|
LISTBASE_FOREACH (NlaStrip *, strip, strips) {
|
|
/* write the strip's F-Curves and modifiers */
|
|
BKE_fcurve_blend_write(writer, &strip->fcurves);
|
|
BKE_fmodifiers_blend_write(writer, &strip->modifiers);
|
|
|
|
/* write the strip's children */
|
|
blend_write_nla_strips(writer, &strip->strips);
|
|
}
|
|
}
|
|
|
|
static void blend_data_read_nla_strips(BlendDataReader *reader, ListBase *strips)
|
|
{
|
|
LISTBASE_FOREACH (NlaStrip *, strip, strips) {
|
|
/* strip's child strips */
|
|
BLO_read_list(reader, &strip->strips);
|
|
blend_data_read_nla_strips(reader, &strip->strips);
|
|
|
|
/* strip's F-Curves */
|
|
BLO_read_list(reader, &strip->fcurves);
|
|
BKE_fcurve_blend_read_data(reader, &strip->fcurves);
|
|
|
|
/* strip's F-Modifiers */
|
|
BLO_read_list(reader, &strip->modifiers);
|
|
BKE_fmodifiers_blend_read_data(reader, &strip->modifiers, NULL);
|
|
}
|
|
}
|
|
|
|
static void blend_lib_read_nla_strips(BlendLibReader *reader, ID *id, ListBase *strips)
|
|
{
|
|
LISTBASE_FOREACH (NlaStrip *, strip, strips) {
|
|
/* check strip's children */
|
|
blend_lib_read_nla_strips(reader, id, &strip->strips);
|
|
|
|
/* check strip's F-Curves */
|
|
BKE_fcurve_blend_read_lib(reader, id, &strip->fcurves);
|
|
|
|
/* reassign the counted-reference to action */
|
|
BLO_read_id_address(reader, id->lib, &strip->act);
|
|
}
|
|
}
|
|
|
|
static void blend_read_expand_nla_strips(BlendExpander *expander, ListBase *strips)
|
|
{
|
|
LISTBASE_FOREACH (NlaStrip *, strip, strips) {
|
|
/* check child strips */
|
|
blend_read_expand_nla_strips(expander, &strip->strips);
|
|
|
|
/* check F-Curves */
|
|
BKE_fcurve_blend_read_expand(expander, &strip->fcurves);
|
|
|
|
/* check F-Modifiers */
|
|
BKE_fmodifiers_blend_read_expand(expander, &strip->modifiers);
|
|
|
|
/* relink referenced action */
|
|
BLO_expand(expander, strip->act);
|
|
}
|
|
}
|
|
|
|
void BKE_nla_blend_write(BlendWriter *writer, ListBase *tracks)
|
|
{
|
|
/* write all the tracks */
|
|
LISTBASE_FOREACH (NlaTrack *, nlt, tracks) {
|
|
/* write the track first */
|
|
BLO_write_struct(writer, NlaTrack, nlt);
|
|
|
|
/* write the track's strips */
|
|
blend_write_nla_strips(writer, &nlt->strips);
|
|
}
|
|
}
|
|
|
|
void BKE_nla_blend_read_data(BlendDataReader *reader, ListBase *tracks)
|
|
{
|
|
LISTBASE_FOREACH (NlaTrack *, nlt, tracks) {
|
|
/* relink list of strips */
|
|
BLO_read_list(reader, &nlt->strips);
|
|
|
|
/* relink strip data */
|
|
blend_data_read_nla_strips(reader, &nlt->strips);
|
|
}
|
|
}
|
|
|
|
void BKE_nla_blend_read_lib(BlendLibReader *reader, ID *id, ListBase *tracks)
|
|
{
|
|
/* we only care about the NLA strips inside the tracks */
|
|
LISTBASE_FOREACH (NlaTrack *, nlt, tracks) {
|
|
/* If linking from a library, clear 'local' library override flag. */
|
|
if (ID_IS_LINKED(id)) {
|
|
nlt->flag &= ~NLATRACK_OVERRIDELIBRARY_LOCAL;
|
|
}
|
|
|
|
blend_lib_read_nla_strips(reader, id, &nlt->strips);
|
|
}
|
|
}
|
|
|
|
void BKE_nla_blend_read_expand(struct BlendExpander *expander, struct ListBase *tracks)
|
|
{
|
|
/* nla-data - referenced actions */
|
|
LISTBASE_FOREACH (NlaTrack *, nlt, tracks) {
|
|
blend_read_expand_nla_strips(expander, &nlt->strips);
|
|
}
|
|
}
|