Differential D5379 Diff 16721 source/blender/blenkernel/intern/anim_sys.c

Changeset View

Standalone View

source/blender/blenkernel/intern/anim_sys.c

Show First 20 Lines • Show All 1,876 Lines • ▼ Show 20 Lines	static void animsys_write_orig_anim_rna(PointerRNA *ptr,
}		}
}		}

/**		/**
* Evaluate all the F-Curves in the given list		* Evaluate all the F-Curves in the given list
* This performs a set of standard checks. If extra checks are required,		* This performs a set of standard checks. If extra checks are required,
* separate code should be used.		* separate code should be used.
*/		*/
static void animsys_evaluate_fcurves(Depsgraph *depsgraph,		static void animsys_evaluate_fcurves(PointerRNA *ptr,
PointerRNA *ptr,
ListBase *list,		ListBase *list,
float ctime)		float ctime,
		bool flush_to_original)
{		{
const bool is_active_depsgraph = DEG_is_active(depsgraph);
/* Calculate then execute each curve. */		/* Calculate then execute each curve. */
for (FCurve *fcu = list->first; fcu; fcu = fcu->next) {		for (FCurve *fcu = list->first; fcu; fcu = fcu->next) {
/* Check if this F-Curve doesn't belong to a muted group. */		/* Check if this F-Curve doesn't belong to a muted group. */
if ((fcu->grp != NULL) && (fcu->grp->flag & AGRP_MUTED)) {		if ((fcu->grp != NULL) && (fcu->grp->flag & AGRP_MUTED)) {
continue;		continue;
}		}
/* Check if this curve should be skipped. */		/* Check if this curve should be skipped. */
if ((fcu->flag & (FCURVE_MUTED \| FCURVE_DISABLED))) {		if ((fcu->flag & (FCURVE_MUTED \| FCURVE_DISABLED))) {
continue;		continue;
}		}
/* Skip empty curves, as if muted. */		/* Skip empty curves, as if muted. */
if (BKE_fcurve_is_empty(fcu)) {		if (BKE_fcurve_is_empty(fcu)) {
continue;		continue;
}		}
PathResolvedRNA anim_rna;		PathResolvedRNA anim_rna;
if (animsys_store_rna_setting(ptr, fcu->rna_path, fcu->array_index, &anim_rna)) {		if (animsys_store_rna_setting(ptr, fcu->rna_path, fcu->array_index, &anim_rna)) {
const float curval = calculate_fcurve(&anim_rna, fcu, ctime);		const float curval = calculate_fcurve(&anim_rna, fcu, ctime);
animsys_write_rna_setting(&anim_rna, curval);		animsys_write_rna_setting(&anim_rna, curval);
if (is_active_depsgraph) {		if (flush_to_original) {
animsys_write_orig_anim_rna(ptr, fcu->rna_path, fcu->array_index, curval);		animsys_write_orig_anim_rna(ptr, fcu->rna_path, fcu->array_index, curval);
}		}
}		}
}		}
}		}

/* ***************************************** */		/* ***************************************** */
/* Driver Evaluation */		/* Driver Evaluation */
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines	if ((fcu->flag & (FCURVE_MUTED \| FCURVE_DISABLED)) == 0 && !BKE_fcurve_is_empty(fcu)) {
const float curval = calculate_fcurve(&anim_rna, fcu, ctime);		const float curval = calculate_fcurve(&anim_rna, fcu, ctime);
animsys_write_rna_setting(&anim_rna, curval);		animsys_write_rna_setting(&anim_rna, curval);
}		}
}		}
}		}
}		}

/* Evaluate Action (F-Curve Bag) */		/* Evaluate Action (F-Curve Bag) */
static void animsys_evaluate_action_ex(Depsgraph *depsgraph,		static void animsys_evaluate_action_ex(PointerRNA *ptr,
PointerRNA *ptr,
bAction *act,		bAction *act,
float ctime)		float ctime,
		const bool flush_to_original)
{		{
/* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */		/* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
if (act == NULL) {		if (act == NULL) {
return;		return;
}		}

action_idcode_patch_check(ptr->id.data, act);		action_idcode_patch_check(ptr->id.data, act);

/* calculate then execute each curve */		/* calculate then execute each curve */
animsys_evaluate_fcurves(depsgraph, ptr, &act->curves, ctime);		animsys_evaluate_fcurves(ptr, &act->curves, ctime, flush_to_original);
}		}

void animsys_evaluate_action(Depsgraph depsgraph, PointerRNA ptr, bAction *act, float ctime)		void animsys_evaluate_action(PointerRNA *ptr,
		bAction *act,
		float ctime,
		const bool flush_to_original)
{		{
animsys_evaluate_action_ex(depsgraph, ptr, act, ctime);		animsys_evaluate_action_ex(ptr, act, ctime, flush_to_original);
}		}

/* ***************************************** */		/* ***************************************** */
/* NLA System - Evaluation */		/* NLA System - Evaluation */

/* calculate influence of strip based for given frame based on blendin/out values */		/* calculate influence of strip based for given frame based on blendin/out values */
static float nlastrip_get_influence(NlaStrip *strip, float cframe)		static float nlastrip_get_influence(NlaStrip *strip, float cframe)
{		{
Show All 12 Lines	static float nlastrip_get_influence(NlaStrip *strip, float cframe)
}		}
else {		else {
/* in the middle of the strip, we should be full strength */		/* in the middle of the strip, we should be full strength */
return 1.0f;		return 1.0f;
}		}
}		}

/* evaluate the evaluation time and influence for the strip, storing the results in the strip */		/* evaluate the evaluation time and influence for the strip, storing the results in the strip */
static void nlastrip_evaluate_controls(Depsgraph depsgraph, NlaStrip strip, float ctime)		static void nlastrip_evaluate_controls(NlaStrip *strip, float ctime, const bool flush_to_original)
{		{
/* now strip's evaluate F-Curves for these settings (if applicable) */		/* now strip's evaluate F-Curves for these settings (if applicable) */
if (strip->fcurves.first) {		if (strip->fcurves.first) {
PointerRNA strip_ptr;		PointerRNA strip_ptr;

/* create RNA-pointer needed to set values */		/* create RNA-pointer needed to set values */
RNA_pointer_create(NULL, &RNA_NlaStrip, strip, &strip_ptr);		RNA_pointer_create(NULL, &RNA_NlaStrip, strip, &strip_ptr);

/* execute these settings as per normal */		/* execute these settings as per normal */
animsys_evaluate_fcurves(depsgraph, &strip_ptr, &strip->fcurves, ctime);		animsys_evaluate_fcurves(&strip_ptr, &strip->fcurves, ctime, flush_to_original);
}		}

/* analytically generate values for influence and time (if applicable)		/* analytically generate values for influence and time (if applicable)
* - we do this after the F-Curves have been evaluated to override the effects of those		* - we do this after the F-Curves have been evaluated to override the effects of those
* in case the override has been turned off.		* in case the override has been turned off.
*/		*/
if ((strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) == 0) {		if ((strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) == 0) {
strip->influence = nlastrip_get_influence(strip, ctime);		strip->influence = nlastrip_get_influence(strip, ctime);
Show All 16 Lines	static void nlastrip_evaluate_controls(NlaStrip *strip, float ctime, const bool flush_to_original)
/* NOTE: if we add any more of these special cases, we better group them up nicely... */		/* NOTE: if we add any more of these special cases, we better group them up nicely... */
if ((strip->flag & NLASTRIP_FLAG_USR_TIME) && (strip->flag & NLASTRIP_FLAG_USR_TIME_CYCLIC)) {		if ((strip->flag & NLASTRIP_FLAG_USR_TIME) && (strip->flag & NLASTRIP_FLAG_USR_TIME_CYCLIC)) {
strip->strip_time = fmod(strip->strip_time - strip->actstart, strip->actend - strip->actstart);		strip->strip_time = fmod(strip->strip_time - strip->actstart, strip->actend - strip->actstart);
}		}
}		}

/* gets the strip active at the current time for a list of strips for evaluation purposes */		/* gets the strip active at the current time for a list of strips for evaluation purposes */
NlaEvalStrip *nlastrips_ctime_get_strip(		NlaEvalStrip *nlastrips_ctime_get_strip(
Depsgraph depsgraph, ListBase list, ListBase *strips, short index, float ctime)		ListBase list, ListBase strips, short index, float ctime, const bool flush_to_original)
{		{
NlaStrip strip, estrip = NULL;		NlaStrip strip, estrip = NULL;
NlaEvalStrip *nes;		NlaEvalStrip *nes;
short side = 0;		short side = 0;

/* loop over strips, checking if they fall within the range */		/* loop over strips, checking if they fall within the range */
for (strip = strips->first; strip; strip = strip->next) {		for (strip = strips->first; strip; strip = strip->next) {
/* check if current time occurs within this strip */		/* check if current time occurs within this strip */
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines	NlaEvalStrip *nlastrips_ctime_get_strip(
}		}

/* evaluate strip's evaluation controls		/* evaluate strip's evaluation controls
* - skip if no influence (i.e. same effect as muting the strip)		* - skip if no influence (i.e. same effect as muting the strip)
* - negative influence is not supported yet... how would that be defined?		* - negative influence is not supported yet... how would that be defined?
*/		*/
/* TODO: this sounds a bit hacky having a few isolated F-Curves		/* TODO: this sounds a bit hacky having a few isolated F-Curves
* stuck on some data it operates on... */		* stuck on some data it operates on... */
nlastrip_evaluate_controls(depsgraph, estrip, ctime);		nlastrip_evaluate_controls(estrip, ctime, flush_to_original);
if (estrip->influence <= 0.0f) {		if (estrip->influence <= 0.0f) {
return NULL;		return NULL;
}		}

/* check if strip has valid data to evaluate,		/* check if strip has valid data to evaluate,
* and/or perform any additional type-specific actions		* and/or perform any additional type-specific actions
*/		*/
switch (estrip->type) {		switch (estrip->type) {
case NLASTRIP_TYPE_CLIP:		case NLASTRIP_TYPE_CLIP:
/* clip must have some action to evaluate */		/* clip must have some action to evaluate */
if (estrip->act == NULL) {		if (estrip->act == NULL) {
return NULL;		return NULL;
}		}
break;		break;
case NLASTRIP_TYPE_TRANSITION:		case NLASTRIP_TYPE_TRANSITION:
/* there must be strips to transition from and to (i.e. prev and next required) */		/* there must be strips to transition from and to (i.e. prev and next required) */
if (ELEM(NULL, estrip->prev, estrip->next)) {		if (ELEM(NULL, estrip->prev, estrip->next)) {
return NULL;		return NULL;
}		}

/* evaluate controls for the relevant extents of the bordering strips... */		/* evaluate controls for the relevant extents of the bordering strips... */
nlastrip_evaluate_controls(depsgraph, estrip->prev, estrip->start);		nlastrip_evaluate_controls(estrip->prev, estrip->start, flush_to_original);
nlastrip_evaluate_controls(depsgraph, estrip->next, estrip->end);		nlastrip_evaluate_controls(estrip->next, estrip->end, flush_to_original);
break;		break;
}		}

/* add to list of strips we need to evaluate */		/* add to list of strips we need to evaluate */
nes = MEM_callocN(sizeof(NlaEvalStrip), "NlaEvalStrip");		nes = MEM_callocN(sizeof(NlaEvalStrip), "NlaEvalStrip");

nes->strip = estrip;		nes->strip = estrip;
nes->strip_mode = side;		nes->strip_mode = side;
▲ Show 20 Lines • Show All 903 Lines • ▼ Show 20 Lines	static void nlastrip_evaluate_actionclip(PointerRNA *ptr,

nlaeval_blend_flush(&blend);		nlaeval_blend_flush(&blend);

/* unlink this strip's modifiers from the parent's modifiers again */		/* unlink this strip's modifiers from the parent's modifiers again */
nlaeval_fmodifiers_split_stacks(&strip->modifiers, modifiers);		nlaeval_fmodifiers_split_stacks(&strip->modifiers, modifiers);
}		}

/* evaluate transition strip */		/* evaluate transition strip */
static void nlastrip_evaluate_transition(Depsgraph *depsgraph,		static void nlastrip_evaluate_transition(PointerRNA *ptr,
PointerRNA *ptr,
NlaEvalData *channels,		NlaEvalData *channels,
ListBase *modifiers,		ListBase *modifiers,
NlaEvalStrip *nes,		NlaEvalStrip *nes,
NlaEvalSnapshot *snapshot)		NlaEvalSnapshot *snapshot,
		const bool flush_to_original)
{		{
ListBase tmp_modifiers = {NULL, NULL};		ListBase tmp_modifiers = {NULL, NULL};
NlaEvalSnapshot snapshot1, snapshot2;		NlaEvalSnapshot snapshot1, snapshot2;
NlaEvalStrip tmp_nes;		NlaEvalStrip tmp_nes;
NlaStrip s1, s2;		NlaStrip s1, s2;

/* join this strip's modifiers to the parent's modifiers (own modifiers first) */		/* join this strip's modifiers to the parent's modifiers (own modifiers first) */
nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &nes->strip->modifiers, modifiers);		nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &nes->strip->modifiers, modifiers);
Show All 24 Lines	static void nlastrip_evaluate_transition(PointerRNA *ptr,
tmp_nes = *nes;		tmp_nes = *nes;

/* evaluate these strips into a temp-buffer (tmp_channels) */		/* evaluate these strips into a temp-buffer (tmp_channels) */
/* FIXME: modifier evaluation here needs some work... */		/* FIXME: modifier evaluation here needs some work... */
/* first strip */		/* first strip */
tmp_nes.strip_mode = NES_TIME_TRANSITION_START;		tmp_nes.strip_mode = NES_TIME_TRANSITION_START;
tmp_nes.strip = s1;		tmp_nes.strip = s1;
nlaeval_snapshot_init(&snapshot1, channels, snapshot);		nlaeval_snapshot_init(&snapshot1, channels, snapshot);
nlastrip_evaluate(depsgraph, ptr, channels, &tmp_modifiers, &tmp_nes, &snapshot1);		nlastrip_evaluate(ptr, channels, &tmp_modifiers, &tmp_nes, &snapshot1, flush_to_original);

/* second strip */		/* second strip */
tmp_nes.strip_mode = NES_TIME_TRANSITION_END;		tmp_nes.strip_mode = NES_TIME_TRANSITION_END;
tmp_nes.strip = s2;		tmp_nes.strip = s2;
nlaeval_snapshot_init(&snapshot2, channels, snapshot);		nlaeval_snapshot_init(&snapshot2, channels, snapshot);
nlastrip_evaluate(depsgraph, ptr, channels, &tmp_modifiers, &tmp_nes, &snapshot2);		nlastrip_evaluate(ptr, channels, &tmp_modifiers, &tmp_nes, &snapshot2, flush_to_original);

/* accumulate temp-buffer and full-buffer, using the 'real' strip */		/* accumulate temp-buffer and full-buffer, using the 'real' strip */
nlaeval_snapshot_mix_and_free(channels, snapshot, &snapshot1, &snapshot2, nes->strip_time);		nlaeval_snapshot_mix_and_free(channels, snapshot, &snapshot1, &snapshot2, nes->strip_time);

/* unlink this strip's modifiers from the parent's modifiers again */		/* unlink this strip's modifiers from the parent's modifiers again */
nlaeval_fmodifiers_split_stacks(&nes->strip->modifiers, modifiers);		nlaeval_fmodifiers_split_stacks(&nes->strip->modifiers, modifiers);
}		}

/* evaluate meta-strip */		/* evaluate meta-strip */
static void nlastrip_evaluate_meta(Depsgraph *depsgraph,		static void nlastrip_evaluate_meta(PointerRNA *ptr,
PointerRNA *ptr,
NlaEvalData *channels,		NlaEvalData *channels,
ListBase *modifiers,		ListBase *modifiers,
NlaEvalStrip *nes,		NlaEvalStrip *nes,
NlaEvalSnapshot *snapshot)		NlaEvalSnapshot *snapshot,
		const bool flush_to_original)
{		{
ListBase tmp_modifiers = {NULL, NULL};		ListBase tmp_modifiers = {NULL, NULL};
NlaStrip *strip = nes->strip;		NlaStrip *strip = nes->strip;
NlaEvalStrip *tmp_nes;		NlaEvalStrip *tmp_nes;
float evaltime;		float evaltime;

/* meta-strip was calculated normally to have some time to be evaluated at		/* meta-strip was calculated normally to have some time to be evaluated at
* and here we 'look inside' the meta strip, treating it as a decorated window to		* and here we 'look inside' the meta strip, treating it as a decorated window to
* it's child strips, which get evaluated as if they were some tracks on a strip		* it's child strips, which get evaluated as if they were some tracks on a strip
* (but with some extra modifiers to apply).		* (but with some extra modifiers to apply).
*		*
* NOTE: keep this in sync with animsys_evaluate_nla()		* NOTE: keep this in sync with animsys_evaluate_nla()
*/		*/

/* join this strip's modifiers to the parent's modifiers (own modifiers first) */		/* join this strip's modifiers to the parent's modifiers (own modifiers first) */
nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &strip->modifiers, modifiers);		nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &strip->modifiers, modifiers);

/* find the child-strip to evaluate */		/* find the child-strip to evaluate */
evaltime = (nes->strip_time * (strip->end - strip->start)) + strip->start;		evaltime = (nes->strip_time * (strip->end - strip->start)) + strip->start;
tmp_nes = nlastrips_ctime_get_strip(depsgraph, NULL, &strip->strips, -1, evaltime);		tmp_nes = nlastrips_ctime_get_strip(NULL, &strip->strips, -1, evaltime, flush_to_original);

/* directly evaluate child strip into accumulation buffer...		/* directly evaluate child strip into accumulation buffer...
* - there's no need to use a temporary buffer (as it causes issues [T40082])		* - there's no need to use a temporary buffer (as it causes issues [T40082])
*/		*/
if (tmp_nes) {		if (tmp_nes) {
nlastrip_evaluate(depsgraph, ptr, channels, &tmp_modifiers, tmp_nes, snapshot);		nlastrip_evaluate(ptr, channels, &tmp_modifiers, tmp_nes, snapshot, flush_to_original);

/* free temp eval-strip */		/* free temp eval-strip */
MEM_freeN(tmp_nes);		MEM_freeN(tmp_nes);
}		}

/* unlink this strip's modifiers from the parent's modifiers again */		/* unlink this strip's modifiers from the parent's modifiers again */
nlaeval_fmodifiers_split_stacks(&strip->modifiers, modifiers);		nlaeval_fmodifiers_split_stacks(&strip->modifiers, modifiers);
}		}

/* evaluates the given evaluation strip */		/* evaluates the given evaluation strip */
void nlastrip_evaluate(Depsgraph *depsgraph,		void nlastrip_evaluate(PointerRNA *ptr,
PointerRNA *ptr,
NlaEvalData *channels,		NlaEvalData *channels,
ListBase *modifiers,		ListBase *modifiers,
NlaEvalStrip *nes,		NlaEvalStrip *nes,
NlaEvalSnapshot *snapshot)		NlaEvalSnapshot *snapshot,
		const bool flush_to_original)
{		{
NlaStrip *strip = nes->strip;		NlaStrip *strip = nes->strip;

/* To prevent potential infinite recursion problems		/* To prevent potential infinite recursion problems
* (i.e. transition strip, beside meta strip containing a transition		* (i.e. transition strip, beside meta strip containing a transition
* several levels deep inside it),		* several levels deep inside it),
* we tag the current strip as being evaluated, and clear this when we leave.		* we tag the current strip as being evaluated, and clear this when we leave.
*/		*/
/* TODO: be careful with this flag, since some edit tools may be running and have		/* TODO: be careful with this flag, since some edit tools may be running and have
* set this while animation playback was running. */		* set this while animation playback was running. */
if (strip->flag & NLASTRIP_FLAG_EDIT_TOUCHED) {		if (strip->flag & NLASTRIP_FLAG_EDIT_TOUCHED) {
return;		return;
}		}
strip->flag \|= NLASTRIP_FLAG_EDIT_TOUCHED;		strip->flag \|= NLASTRIP_FLAG_EDIT_TOUCHED;

/* actions to take depend on the type of strip */		/* actions to take depend on the type of strip */
switch (strip->type) {		switch (strip->type) {
case NLASTRIP_TYPE_CLIP: /* action-clip */		case NLASTRIP_TYPE_CLIP: /* action-clip */
nlastrip_evaluate_actionclip(ptr, channels, modifiers, nes, snapshot);		nlastrip_evaluate_actionclip(ptr, channels, modifiers, nes, snapshot);
break;		break;
case NLASTRIP_TYPE_TRANSITION: /* transition */		case NLASTRIP_TYPE_TRANSITION: /* transition */
nlastrip_evaluate_transition(depsgraph, ptr, channels, modifiers, nes, snapshot);		nlastrip_evaluate_transition(ptr, channels, modifiers, nes, snapshot, flush_to_original);
break;		break;
case NLASTRIP_TYPE_META: /* meta */		case NLASTRIP_TYPE_META: /* meta */
nlastrip_evaluate_meta(depsgraph, ptr, channels, modifiers, nes, snapshot);		nlastrip_evaluate_meta(ptr, channels, modifiers, nes, snapshot, flush_to_original);
break;		break;

default: /* do nothing */		default: /* do nothing */
break;		break;
}		}

/* clear temp recursion safe-check */		/* clear temp recursion safe-check */
strip->flag &= ~NLASTRIP_FLAG_EDIT_TOUCHED;		strip->flag &= ~NLASTRIP_FLAG_EDIT_TOUCHED;
}		}

/* write the accumulated settings to */		/* write the accumulated settings to */
void nladata_flush_channels(Depsgraph *depsgraph,		void nladata_flush_channels(PointerRNA *ptr,
PointerRNA *ptr,
NlaEvalData *channels,		NlaEvalData *channels,
NlaEvalSnapshot *snapshot)		NlaEvalSnapshot *snapshot,
		const bool flush_to_original)
{		{
/* sanity checks */		/* sanity checks */
if (channels == NULL) {		if (channels == NULL) {
return;		return;
}		}

const bool is_active_depsgraph = DEG_is_active(depsgraph);

/* for each channel with accumulated values, write its value on the property it affects */		/* for each channel with accumulated values, write its value on the property it affects */
for (NlaEvalChannel *nec = channels->channels.first; nec; nec = nec->next) {		for (NlaEvalChannel *nec = channels->channels.first; nec; nec = nec->next) {
NlaEvalChannelSnapshot *nec_snapshot = nlaeval_snapshot_find_channel(snapshot, nec);		NlaEvalChannelSnapshot *nec_snapshot = nlaeval_snapshot_find_channel(snapshot, nec);

PathResolvedRNA rna = {nec->key.ptr, nec->key.prop, -1};		PathResolvedRNA rna = {nec->key.ptr, nec->key.prop, -1};

for (int i = 0; i < nec_snapshot->length; i++) {		for (int i = 0; i < nec_snapshot->length; i++) {
if (BLI_BITMAP_TEST(nec->valid.ptr, i)) {		if (BLI_BITMAP_TEST(nec->valid.ptr, i)) {
float value = nec_snapshot->values[i];		float value = nec_snapshot->values[i];
if (nec->is_array) {		if (nec->is_array) {
rna.prop_index = i;		rna.prop_index = i;
}		}
animsys_write_rna_setting(&rna, value);		animsys_write_rna_setting(&rna, value);
if (is_active_depsgraph) {		if (flush_to_original) {
animsys_write_orig_anim_rna(ptr, nec->rna_path, rna.prop_index, value);		animsys_write_orig_anim_rna(ptr, nec->rna_path, rna.prop_index, value);
}		}
}		}
}		}
}		}
}		}

/* ---------------------- */		/* ---------------------- */
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
/**		/**
* NLA Evaluation function - values are calculated and stored in temporary "NlaEvalChannels"		* NLA Evaluation function - values are calculated and stored in temporary "NlaEvalChannels"
*		*
* \param[out] echannels: Evaluation channels with calculated values		* \param[out] echannels: Evaluation channels with calculated values
* \param[out] r_context: If not NULL,		* \param[out] r_context: If not NULL,
* data about the currently edited strip is stored here and excluded from value calculation.		* data about the currently edited strip is stored here and excluded from value calculation.
* \return false if NLA evaluation isn't actually applicable.		* \return false if NLA evaluation isn't actually applicable.
*/		*/
static bool animsys_evaluate_nla(Depsgraph *depsgraph,		static bool animsys_evaluate_nla(NlaEvalData *echannels,
NlaEvalData *echannels,
PointerRNA *ptr,		PointerRNA *ptr,
AnimData *adt,		AnimData *adt,
float ctime,		float ctime,
		const bool flush_to_original,
NlaKeyframingContext *r_context)		NlaKeyframingContext *r_context)
{		{
NlaTrack *nlt;		NlaTrack *nlt;
short track_index = 0;		short track_index = 0;
bool has_strips = false;		bool has_strips = false;

ListBase estrips = {NULL, NULL};		ListBase estrips = {NULL, NULL};
NlaEvalStrip *nes;		NlaEvalStrip *nes;
Show All 30 Lines	for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next, track_index++) {
/* if this track has strips (but maybe they won't be suitable), set has_strips		/* if this track has strips (but maybe they won't be suitable), set has_strips
* - used for mainly for still allowing normal action evaluation...		* - used for mainly for still allowing normal action evaluation...
*/		*/
if (nlt->strips.first) {		if (nlt->strips.first) {
has_strips = true;		has_strips = true;
}		}

/* otherwise, get strip to evaluate for this channel */		/* otherwise, get strip to evaluate for this channel */
nes = nlastrips_ctime_get_strip(depsgraph, &estrips, &nlt->strips, track_index, ctime);		nes = nlastrips_ctime_get_strip(&estrips, &nlt->strips, track_index, ctime, flush_to_original);
if (nes) {		if (nes) {
nes->track = nlt;		nes->track = nlt;
}		}
}		}

/* add 'active' Action (may be tweaking track) as last strip to evaluate in NLA stack		/* add 'active' Action (may be tweaking track) as last strip to evaluate in NLA stack
* - only do this if we're not exclusively evaluating the 'solo' NLA-track		* - only do this if we're not exclusively evaluating the 'solo' NLA-track
* - however, if the 'solo' track houses the current 'tweaking' strip,		* - however, if the 'solo' track houses the current 'tweaking' strip,
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines	if ((has_strips) \|\| (adt->actstrip)) {

/* NOTE: must set this, or else the default setting overrides,		/* NOTE: must set this, or else the default setting overrides,
* and this setting doesn't work. */		* and this setting doesn't work. */
dummy_strip->flag \|= NLASTRIP_FLAG_USR_INFLUENCE;		dummy_strip->flag \|= NLASTRIP_FLAG_USR_INFLUENCE;
}		}

/* add this to our list of evaluation strips */		/* add this to our list of evaluation strips */
if (r_context == NULL) {		if (r_context == NULL) {
nlastrips_ctime_get_strip(depsgraph, &estrips, &dummy_trackslist, -1, ctime);		nlastrips_ctime_get_strip(&estrips, &dummy_trackslist, -1, ctime, flush_to_original);
}		}
/* If computing the context for keyframing, store data there instead of the list. */		/* If computing the context for keyframing, store data there instead of the list. */
else {		else {
/* The extend mode here effectively controls		/* The extend mode here effectively controls
* whether it is possible to key-frame beyond the ends. */		* whether it is possible to key-frame beyond the ends. */
dummy_strip->extendmode = is_inplace_tweak ? NLASTRIP_EXTEND_NOTHING :		dummy_strip->extendmode = is_inplace_tweak ? NLASTRIP_EXTEND_NOTHING :
NLASTRIP_EXTEND_HOLD;		NLASTRIP_EXTEND_HOLD;

r_context->eval_strip = nes = nlastrips_ctime_get_strip(		r_context->eval_strip = nes = nlastrips_ctime_get_strip(
depsgraph, NULL, &dummy_trackslist, -1, ctime);		NULL, &dummy_trackslist, -1, ctime, flush_to_original);

/* These setting combinations require no data from strips below, so exit immediately. */		/* These setting combinations require no data from strips below, so exit immediately. */
if ((nes == NULL) \|\|		if ((nes == NULL) \|\|
(dummy_strip->blendmode == NLASTRIP_MODE_REPLACE && dummy_strip->influence == 1.0f)) {		(dummy_strip->blendmode == NLASTRIP_MODE_REPLACE && dummy_strip->influence == 1.0f)) {
BLI_freelistN(&estrips);		BLI_freelistN(&estrips);
return true;		return true;
}		}
}		}
}		}
else {		else {
/* special case - evaluate as if there isn't any NLA data */		/* special case - evaluate as if there isn't any NLA data */
BLI_freelistN(&estrips);		BLI_freelistN(&estrips);
return false;		return false;
}		}
}		}

/* only continue if there are strips to evaluate */		/* only continue if there are strips to evaluate */
if (BLI_listbase_is_empty(&estrips)) {		if (BLI_listbase_is_empty(&estrips)) {
return true;		return true;
}		}

/* 2. for each strip, evaluate then accumulate on top of existing channels,		/* 2. for each strip, evaluate then accumulate on top of existing channels,
* but don't set values yet. */		* but don't set values yet. */
for (nes = estrips.first; nes; nes = nes->next) {		for (nes = estrips.first; nes; nes = nes->next) {
nlastrip_evaluate(depsgraph, ptr, echannels, NULL, nes, &echannels->eval_snapshot);		nlastrip_evaluate(ptr, echannels, NULL, nes, &echannels->eval_snapshot, flush_to_original);
}		}

/* 3. free temporary evaluation data that's not used elsewhere */		/* 3. free temporary evaluation data that's not used elsewhere */
BLI_freelistN(&estrips);		BLI_freelistN(&estrips);
return true;		return true;
}		}

/* NLA Evaluation function (mostly for use through do_animdata)		/* NLA Evaluation function (mostly for use through do_animdata)
* - All channels that will be affected are not cleared anymore. Instead, we just evaluate into		* - All channels that will be affected are not cleared anymore. Instead, we just evaluate into
* some temp channels, where values can be accumulated in one go.		* some temp channels, where values can be accumulated in one go.
*/		*/
static void animsys_calculate_nla(Depsgraph *depsgraph,		static void animsys_calculate_nla(PointerRNA *ptr,
PointerRNA *ptr,
AnimData *adt,		AnimData *adt,
float ctime)		float ctime,
		const bool flush_to_original)
{		{
NlaEvalData echannels;		NlaEvalData echannels;

nlaeval_init(&echannels);		nlaeval_init(&echannels);

/* evaluate the NLA stack, obtaining a set of values to flush */		/* evaluate the NLA stack, obtaining a set of values to flush */
if (animsys_evaluate_nla(depsgraph, &echannels, ptr, adt, ctime, NULL)) {		if (animsys_evaluate_nla(&echannels, ptr, adt, ctime, flush_to_original, NULL)) {
/* reset any channels touched by currently inactive actions to default value */		/* reset any channels touched by currently inactive actions to default value */
animsys_evaluate_nla_domain(ptr, &echannels, adt);		animsys_evaluate_nla_domain(ptr, &echannels, adt);

/* flush effects of accumulating channels in NLA to the actual data they affect */		/* flush effects of accumulating channels in NLA to the actual data they affect */
nladata_flush_channels(depsgraph, ptr, &echannels, &echannels.eval_snapshot);		nladata_flush_channels(ptr, &echannels, &echannels.eval_snapshot, flush_to_original);
}		}
else {		else {
/* special case - evaluate as if there isn't any NLA data */		/* special case - evaluate as if there isn't any NLA data */
/* TODO: this is really just a stop-gap measure... */		/* TODO: this is really just a stop-gap measure... */
if (G.debug & G_DEBUG) {		if (G.debug & G_DEBUG) {
CLOG_WARN(&LOG, "NLA Eval: Stopgap for active action on NLA Stack - no strips case");		CLOG_WARN(&LOG, "NLA Eval: Stopgap for active action on NLA Stack - no strips case");
}		}

animsys_evaluate_action(depsgraph, ptr, adt->action, ctime);		animsys_evaluate_action(ptr, adt->action, ctime, flush_to_original);
}		}

/* free temp data */		/* free temp data */
nlaeval_free(&echannels);		nlaeval_free(&echannels);
}		}

/* ---------------------- */		/* ---------------------- */

/**		/**
* Prepare data necessary to compute correct keyframe values for NLA strips		* Prepare data necessary to compute correct keyframe values for NLA strips
* with non-Replace mode or influence different from 1.		* with non-Replace mode or influence different from 1.
*		*
* \param cache: List used to cache contexts for reuse when keying		* \param cache: List used to cache contexts for reuse when keying
* multiple channels in one operation.		* multiple channels in one operation.
* \param ptr: RNA pointer to the Object with the animation.		* \param ptr: RNA pointer to the Object with the animation.
* \return Keyframing context, or NULL if not necessary.		* \return Keyframing context, or NULL if not necessary.
*/		*/
NlaKeyframingContext BKE_animsys_get_nla_keyframing_context(struct ListBase cache,		NlaKeyframingContext BKE_animsys_get_nla_keyframing_context(struct ListBase cache,
struct Depsgraph *depsgraph,
struct PointerRNA *ptr,		struct PointerRNA *ptr,
struct AnimData *adt,		struct AnimData *adt,
float ctime)		float ctime,
		const bool flush_to_original)
{		{
/* No remapping needed if NLA is off or no action. */		/* No remapping needed if NLA is off or no action. */
if ((adt == NULL) \|\| (adt->action == NULL) \|\| (adt->nla_tracks.first == NULL) \|\|		if ((adt == NULL) \|\| (adt->action == NULL) \|\| (adt->nla_tracks.first == NULL) \|\|
(adt->flag & ADT_NLA_EVAL_OFF)) {		(adt->flag & ADT_NLA_EVAL_OFF)) {
return NULL;		return NULL;
}		}

/* No remapping if editing an ordinary Replace action with full influence. */		/* No remapping if editing an ordinary Replace action with full influence. */
if (!(adt->flag & ADT_NLA_EDIT_ON) &&		if (!(adt->flag & ADT_NLA_EDIT_ON) &&
(adt->act_blendmode == NLASTRIP_MODE_REPLACE && adt->act_influence == 1.0f)) {		(adt->act_blendmode == NLASTRIP_MODE_REPLACE && adt->act_influence == 1.0f)) {
return NULL;		return NULL;
}		}

/* Try to find a cached context. */		/* Try to find a cached context. */
NlaKeyframingContext *ctx = BLI_findptr(cache, adt, offsetof(NlaKeyframingContext, adt));		NlaKeyframingContext *ctx = BLI_findptr(cache, adt, offsetof(NlaKeyframingContext, adt));

if (ctx == NULL) {		if (ctx == NULL) {
/* Allocate and evaluate a new context. */		/* Allocate and evaluate a new context. */
ctx = MEM_callocN(sizeof(*ctx), "NlaKeyframingContext");		ctx = MEM_callocN(sizeof(*ctx), "NlaKeyframingContext");
ctx->adt = adt;		ctx->adt = adt;

nlaeval_init(&ctx->nla_channels);		nlaeval_init(&ctx->nla_channels);
animsys_evaluate_nla(depsgraph, &ctx->nla_channels, ptr, adt, ctime, ctx);		animsys_evaluate_nla(&ctx->nla_channels, ptr, adt, ctime, flush_to_original, ctx);

BLI_assert(ELEM(ctx->strip.act, NULL, adt->action));		BLI_assert(ELEM(ctx->strip.act, NULL, adt->action));
BLI_addtail(cache, ctx);		BLI_addtail(cache, ctx);
}		}

return ctx;		return ctx;
}		}

▲ Show 20 Lines • Show All 174 Lines • ▼ Show 20 Lines

/* Evaluation loop for evaluation animation data		/* Evaluation loop for evaluation animation data
*		*
* This assumes that the animation-data provided belongs to the ID block in question,		* This assumes that the animation-data provided belongs to the ID block in question,
* and that the flags for which parts of the anim-data settings need to be recalculated		* and that the flags for which parts of the anim-data settings need to be recalculated
* have been set already by the depsgraph. Now, we use the recalc		* have been set already by the depsgraph. Now, we use the recalc
*/		*/
void BKE_animsys_evaluate_animdata(		void BKE_animsys_evaluate_animdata(
Depsgraph depsgraph, Scene scene, ID id, AnimData adt, float ctime, short recalc)		Scene scene, ID id, AnimData *adt, float ctime, short recalc, const bool flush_to_original)
{		{
PointerRNA id_ptr;		PointerRNA id_ptr;

/* sanity checks */		/* sanity checks */
if (ELEM(NULL, id, adt)) {		if (ELEM(NULL, id, adt)) {
return;		return;
}		}

/* get pointer to ID-block for RNA to use */		/* get pointer to ID-block for RNA to use */
RNA_id_pointer_create(id, &id_ptr);		RNA_id_pointer_create(id, &id_ptr);

/* recalculate keyframe data:		/* recalculate keyframe data:
* - NLA before Active Action, as Active Action behaves as 'tweaking track'		* - NLA before Active Action, as Active Action behaves as 'tweaking track'
* that overrides 'rough' work in NLA		* that overrides 'rough' work in NLA
*/		*/
/* TODO: need to double check that this all works correctly */		/* TODO: need to double check that this all works correctly */
if (recalc & ADT_RECALC_ANIM) {		if (recalc & ADT_RECALC_ANIM) {
/* evaluate NLA data */		/* evaluate NLA data */
if ((adt->nla_tracks.first) && !(adt->flag & ADT_NLA_EVAL_OFF)) {		if ((adt->nla_tracks.first) && !(adt->flag & ADT_NLA_EVAL_OFF)) {
/* evaluate NLA-stack		/* evaluate NLA-stack
* - active action is evaluated as part of the NLA stack as the last item		* - active action is evaluated as part of the NLA stack as the last item
*/		*/
animsys_calculate_nla(depsgraph, &id_ptr, adt, ctime);		animsys_calculate_nla(&id_ptr, adt, ctime, flush_to_original);
}		}
/* evaluate Active Action only */		/* evaluate Active Action only */
else if (adt->action) {		else if (adt->action) {
animsys_evaluate_action_ex(depsgraph, &id_ptr, adt->action, ctime);		animsys_evaluate_action_ex(&id_ptr, adt->action, ctime, flush_to_original);
}		}
}		}

/* recalculate drivers		/* recalculate drivers
* - Drivers need to be evaluated afterwards, as they can either override		* - Drivers need to be evaluated afterwards, as they can either override
* or be layered on top of existing animation data.		* or be layered on top of existing animation data.
* - Drivers should be in the appropriate order to be evaluated without problems...		* - Drivers should be in the appropriate order to be evaluated without problems...
*/		*/
Show All 30 Lines	void BKE_animsys_evaluate_all_animation(Main *main,
float ctime)		float ctime)
{		{
ID *id;		ID *id;

if (G.debug & G_DEBUG) {		if (G.debug & G_DEBUG) {
printf("Evaluate all animation - %f\n", ctime);		printf("Evaluate all animation - %f\n", ctime);
}		}

		const bool flush_to_original = -DEG_is_active(depsgraph);

/* macros for less typing		/* macros for less typing
* - only evaluate animation data for id if it has users (and not just fake ones)		* - only evaluate animation data for id if it has users (and not just fake ones)
* - whether animdata exists is checked for by the evaluation function, though taking		* - whether animdata exists is checked for by the evaluation function, though taking
* this outside of the function may make things slightly faster?		* this outside of the function may make things slightly faster?
*/		*/
#define EVAL_ANIM_IDS(first, aflag) \		#define EVAL_ANIM_IDS(first, aflag) \
for (id = first; id; id = id->next) { \		for (id = first; id; id = id->next) { \
if (ID_REAL_USERS(id) > 0) { \		if (ID_REAL_USERS(id) > 0) { \
AnimData *adt = BKE_animdata_from_id(id); \		AnimData *adt = BKE_animdata_from_id(id); \
BKE_animsys_evaluate_animdata(depsgraph, scene, id, adt, ctime, aflag); \		BKE_animsys_evaluate_animdata(scene, id, adt, ctime, aflag, flush_to_original); \
} \		} \
} \		} \
(void)0		(void)0

/* another macro for the "embedded" nodetree cases		/* another macro for the "embedded" nodetree cases
* - this is like EVAL_ANIM_IDS, but this handles the case "embedded nodetrees"		* - this is like EVAL_ANIM_IDS, but this handles the case "embedded nodetrees"
* (i.e. scene/material/texture->nodetree) which we need a special exception		* (i.e. scene/material/texture->nodetree) which we need a special exception
* for, otherwise they'd get skipped		* for, otherwise they'd get skipped
* - ntp = "node tree parent" = data-block where node tree stuff resides		* - ntp = "node tree parent" = data-block where node tree stuff resides
*/		*/
#define EVAL_ANIM_NODETREE_IDS(first, NtId_Type, aflag) \		#define EVAL_ANIM_NODETREE_IDS(first, NtId_Type, aflag) \
for (id = first; id; id = id->next) { \		for (id = first; id; id = id->next) { \
if (ID_REAL_USERS(id) > 0) { \		if (ID_REAL_USERS(id) > 0) { \
AnimData *adt = BKE_animdata_from_id(id); \		AnimData *adt = BKE_animdata_from_id(id); \
NtId_Type ntp = (NtId_Type )id; \		NtId_Type ntp = (NtId_Type )id; \
if (ntp->nodetree) { \		if (ntp->nodetree) { \
AnimData adt2 = BKE_animdata_from_id((ID )ntp->nodetree); \		AnimData adt2 = BKE_animdata_from_id((ID )ntp->nodetree); \
BKE_animsys_evaluate_animdata( \		BKE_animsys_evaluate_animdata( \
depsgraph, scene, (ID *)ntp->nodetree, adt2, ctime, ADT_RECALC_ANIM); \		scene, (ID *)ntp->nodetree, adt2, ctime, ADT_RECALC_ANIM, flush_to_original); \
} \		} \
BKE_animsys_evaluate_animdata(depsgraph, scene, id, adt, ctime, aflag); \		BKE_animsys_evaluate_animdata(scene, id, adt, ctime, aflag, flush_to_original); \
} \		} \
} \		} \
(void)0		(void)0

/* optimization:		/* optimization:
* when there are no actions, don't go over database and loop over heaps of data-blocks,		* when there are no actions, don't go over database and loop over heaps of data-blocks,
* which should ultimately be empty, since it is not possible for now to have any animation		* which should ultimately be empty, since it is not possible for now to have any animation
* without some actions, and drivers wouldn't get affected by any state changes		* without some actions, and drivers wouldn't get affected by any state changes
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
void BKE_animsys_eval_animdata(Depsgraph depsgraph, ID id)		void BKE_animsys_eval_animdata(Depsgraph depsgraph, ID id)
{		{
float ctime = DEG_get_ctime(depsgraph);		float ctime = DEG_get_ctime(depsgraph);
AnimData *adt = BKE_animdata_from_id(id);		AnimData *adt = BKE_animdata_from_id(id);
/* XXX: this is only needed for flushing RNA updates,		/* XXX: this is only needed for flushing RNA updates,
* which should get handled as part of the dependency graph instead. */		* which should get handled as part of the dependency graph instead. */
Scene *scene = NULL;		Scene *scene = NULL;
DEG_debug_print_eval_time(depsgraph, __func__, id->name, id, ctime);		DEG_debug_print_eval_time(depsgraph, __func__, id->name, id, ctime);
BKE_animsys_evaluate_animdata(depsgraph, scene, id, adt, ctime, ADT_RECALC_ANIM);		const bool flush_to_original = DEG_is_active(depsgraph);
		BKE_animsys_evaluate_animdata(scene, id, adt, ctime, ADT_RECALC_ANIM, flush_to_original);
}		}

void BKE_animsys_update_driver_array(ID *id)		void BKE_animsys_update_driver_array(ID *id)
{		{
AnimData *adt = BKE_animdata_from_id(id);		AnimData *adt = BKE_animdata_from_id(id);

/* Runtime driver map to avoid O(n^2) lookups in BKE_animsys_eval_driver.		/* Runtime driver map to avoid O(n^2) lookups in BKE_animsys_eval_driver.
* Ideally the depsgraph could pass a pointer to the COW driver directly,		* Ideally the depsgraph could pass a pointer to the COW driver directly,
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines