Animation: blend offset slider #106518

Closed
AresDeveaux wants to merge 12 commits from AresDeveaux/blender:blend_offset_slider into main

When changing the target branch, be careful to rebase the branch in your fork to match. See documentation.
6 changed files with 175 additions and 0 deletions
Showing only changes of commit 52a9e65548 - Show all commits

View File

@ -329,6 +329,7 @@ class GRAPH_MT_slider(Menu):
layout.operator("graph.breakdown", text="Breakdown")
layout.operator("graph.blend_to_neighbor", text="Blend to Neighbor")
layout.operator("graph.blend_to_default", text="Blend to Default Value")
layout.operator("graph.blend_to_offset", text="Blend to Offset")
layout.operator("graph.ease", text="Ease")
layout.operator("graph.gaussian_smooth", text="Smooth")

View File

@ -491,6 +491,53 @@ void ease_fcurve_segment(FCurve *fcu, FCurveSegment *segment, const float factor
/* ---------------- */
void blend_to_offset_fcurve_segment(FCurve *fcu, FCurveSegment *segment, const float factor)
{
const BezTriple *left_key = fcurve_segment_start_get(fcu, segment->start_index);
const float left_x = left_key->vec[1][0];
const float left_y = left_key->vec[1][1];

this can be simplified to fcu->bezt[segment->start_index]
same for getting the segment end

this can be simplified to `fcu->bezt[segment->start_index]` same for getting the segment end

Since ``y_delta * fabs(factor)` doesnt' change over the course of this loop, take it out of the loop:

const float weighted_delta = y_delta * fabs(factor);
Since ``y_delta * fabs(factor)` doesnt' change over the course of this loop, take it out of the loop: ```c const float weighted_delta = y_delta * fabs(factor); ```
const BezTriple *right_key = fcurve_segment_end_get(fcu, segment->start_index + segment->length);
const float right_x = right_key->vec[1][0];
const float right_y = right_key->vec[1][1];
const BezTriple *segment_first_key = fcurve_segment_start_get(fcu, segment->start_index + 1);
const float segment_first_key_y = segment_first_key->vec[1][1];
const BezTriple *segment_last_key = fcurve_segment_end_get(fcu, segment->start_index + segment->length - 1);

watch out for typos poritive -> positive

watch out for typos poritive -> positive
const float segment_last_key_y = segment_last_key->vec[1][1];
const float key_x_range = right_x - left_x;
/* Happens if there is only 1 key on the FCurve. Needs to be skipped because it

if you use ED_slider_is_bidirectional_set you can just say factor > 0 and remove the boolean
That way this function doesn't even need to have an implicit notion of where the value came from

if you use `ED_slider_is_bidirectional_set` you can just say `factor > 0` and remove the boolean That way this function doesn't even need to have an implicit notion of where the value came from

I just tried this. One problem with a bidirectional slider is that the factor is always going to be more than zero, so the else part of the if statement is never executed. I still need to know what side of the slider the value is coming from. If the factor is from 0 to 1 I can, and by using ping_pong_factor = fabs(factor * 2 - 1) I have been simulating what now I should call "bidirectional_factor" instead of "ping_pong_factor"

If there is a way to know what side of the slider the value is coming from I could use ED_slider_is_bidirectional_set

I just tried this. One problem with a bidirectional slider is that the factor is always going to be more than zero, so the `else` part of the if statement is never executed. I still need to know what side of the slider the value is coming from. If the factor is from 0 to 1 I can, and by using `ping_pong_factor = fabs(factor * 2 - 1)` I have been simulating what now I should call "bidirectional_factor" instead of "ping_pong_factor" If there is a way to know what side of the slider the value is coming from I could use `ED_slider_is_bidirectional_set`

hm sorry I think that was my bad. I thought this would set the slider to a -1/1 range but it does not. It just allows negative values.
In that case your implementation is correct until we add that feature to the slider :)

hm sorry I think that was my bad. I thought this would set the slider to a -1/1 range but it does not. It just allows negative values. In that case your implementation is correct until we add that feature to the slider :)
* would be a divide by 0. */
if (IS_EQF(key_x_range, 0.0f)) {
return;
}
/* The calculation needs diferent values for each side of the slider. */
const bool slider_right_side = factor > 0.5;
/* For this tool the calculations are made easier if each side of the slider goes from 0 to porisive 1. */
const float ping_pong_factor = fabs(factor * 2 - 1);
float y_delta = 0;
if (slider_right_side) {
y_delta = right_y - segment_last_key_y;
}
else {
y_delta = left_y - segment_first_key_y;
}
for (int i = segment->start_index; i < segment->start_index + segment->length; i++) {
const float key_y_value = fcu->bezt[i].vec[1][1] + y_delta * ping_pong_factor;
move_key(&fcu->bezt[i], key_y_value);
}
}
/* ---------------- */
void breakdown_fcurve_segment(FCurve *fcu, FCurveSegment *segment, const float factor)
{
const BezTriple *left_bezt = fcurve_segment_start_get(fcu, segment->start_index);

View File

@ -437,6 +437,7 @@ void smooth_fcurve_segment(struct FCurve *fcu,
int kernel_size,
double *kernel);
void ease_fcurve_segment(struct FCurve *fcu, struct FCurveSegment *segment, float factor);
void blend_to_offset_fcurve_segment(struct FCurve *fcu, struct FCurveSegment *segment, float factor);
bool decimate_fcurve(struct bAnimListElem *ale, float remove_ratio, float error_sq_max);
void blend_to_default_fcurve(struct PointerRNA *id_ptr, struct FCurve *fcu, float factor);

The more functions we add here, the more important it becomes that they are documented. Could you write a doxygen-style comment for it, that explains what it does? Something like this:

/**
 * Shift the FCurve segment up/down so that it aligns with the key before/after
 * the segment.
 *
 * \param factor blend factor from -1.0 to 1.0. The sign determines whether the
 * segment is aligned with the key before or after the segment.
 */
The more functions we add here, the more important it becomes that they are documented. Could you write a doxygen-style comment for it, that explains what it does? Something like this: ```c /** * Shift the FCurve segment up/down so that it aligns with the key before/after * the segment. * * \param factor blend factor from -1.0 to 1.0. The sign determines whether the * segment is aligned with the key before or after the segment. */ ```
/**

View File

@ -114,6 +114,7 @@ void GRAPH_OT_clean(struct wmOperatorType *ot);
void GRAPH_OT_blend_to_neighbor(struct wmOperatorType *ot);
void GRAPH_OT_breakdown(struct wmOperatorType *ot);
void GRAPH_OT_ease(struct wmOperatorType *ot);
void GRAPH_OT_blend_to_offset(struct wmOperatorType *ot);
void GRAPH_OT_decimate(struct wmOperatorType *ot);
void GRAPH_OT_blend_to_default(struct wmOperatorType *ot);
void GRAPH_OT_gaussian_smooth(struct wmOperatorType *ot);

View File

@ -463,6 +463,7 @@ void graphedit_operatortypes(void)
WM_operatortype_append(GRAPH_OT_blend_to_neighbor);
WM_operatortype_append(GRAPH_OT_breakdown);
WM_operatortype_append(GRAPH_OT_ease);
WM_operatortype_append(GRAPH_OT_blend_to_offset);
WM_operatortype_append(GRAPH_OT_blend_to_default);
WM_operatortype_append(GRAPH_OT_gaussian_smooth);
WM_operatortype_append(GRAPH_OT_euler_filter);

View File

@ -1060,6 +1060,130 @@ void GRAPH_OT_ease(wmOperatorType *ot)
1.0f);
}
/* -------------------------------------------------------------------- */
/** \name Blend to Offset Operator
* \{ */
static void blend_to_offset_graph_keys(bAnimContext *ac, const float factor)
{
ListBase anim_data = {NULL, NULL};
ANIM_animdata_filter(ac, &anim_data, OPERATOR_DATA_FILTER, ac->data, ac->datatype);
LISTBASE_FOREACH (bAnimListElem *, ale, &anim_data) {
FCurve *fcu = (FCurve *)ale->key_data;
ListBase segments = find_fcurve_segments(fcu);
LISTBASE_FOREACH (FCurveSegment *, segment, &segments) {
blend_to_offset_fcurve_segment(fcu, segment, factor);
}
ale->update |= ANIM_UPDATE_DEFAULT;
BLI_freelistN(&segments);
}
ANIM_animdata_update(ac, &anim_data);
ANIM_animdata_freelist(&anim_data);
}
static void blend_to_offset_draw_status_header(bContext *C, tGraphSliderOp *gso)
{
char status_str[UI_MAX_DRAW_STR];
char mode_str[32];
char slider_string[UI_MAX_DRAW_STR];
ED_slider_status_string_get(gso->slider, slider_string, UI_MAX_DRAW_STR);
strcpy(mode_str, TIP_("Blend to Offset Keys"));
if (hasNumInput(&gso->num)) {
char str_ofs[NUM_STR_REP_LEN];
outputNumInput(&gso->num, str_ofs, &gso->scene->unit);
BLI_snprintf(status_str, sizeof(status_str), "%s: %s", mode_str, str_ofs);
}
else {
BLI_snprintf(status_str, sizeof(status_str), "%s: %s", mode_str, slider_string);
}
ED_workspace_status_text(C, status_str);
}
static void blend_to_offset_modal_update(bContext *C, wmOperator *op)
{
tGraphSliderOp *gso = op->customdata;
blend_to_offset_draw_status_header(C, gso);
/* Reset keyframes to the state at invoke. */
reset_bezts(gso);
const float factor = slider_factor_get_and_remember(op);
blend_to_offset_graph_keys(&gso->ac, factor);
WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
}
static int blend_to_offset_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
const int invoke_result = graph_slider_invoke(C, op, event);
if (invoke_result == OPERATOR_CANCELLED) {
return invoke_result;
}
tGraphSliderOp *gso = op->customdata;
gso->modal_update = blend_to_offset_modal_update;
gso->factor_prop = RNA_struct_find_property(op->ptr, "factor");
blend_to_offset_draw_status_header(C, gso);
return invoke_result;
}
static int blend_to_offset_exec(bContext *C, wmOperator *op)
{
bAnimContext ac;
/* Get editor data. */
if (ANIM_animdata_get_context(C, &ac) == 0) {
return OPERATOR_CANCELLED;
}
const float factor = RNA_float_get(op->ptr, "factor");
blend_to_offset_graph_keys(&ac, factor);
/* Set notifier that keyframes have changed. */
WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
return OPERATOR_FINISHED;
}
void GRAPH_OT_blend_to_offset(wmOperatorType *ot)
{
/* Identifiers. */
ot->name = "Blend to Offset Keyframes";
ot->idname = "GRAPH_OT_blend_to_offset";
ot->description = "Shift selected keys to the value of the neighboring keys as a block";
/* API callbacks. */
ot->invoke = blend_to_offset_invoke;
ot->modal = graph_slider_modal;
ot->exec = blend_to_offset_exec;
ot->poll = graphop_editable_keyframes_poll;
/* Flags. */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
RNA_def_float_factor(ot->srna,
"factor",
0.5f,
-FLT_MAX,
FLT_MAX,
"Curve Bend",
"Control the bend of the curve",
0.0f,
1.0f);
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Gauss Smooth Operator