42#include "RNA_prototypes.hh"
87 N_(
"Standard transitions between keyframes")),
92 "Straight-line interpolation between A and B (i.e. no ease in/out)"},
97 "Custom interpolation defined using a curve map"},
101 N_(
"Predefined inertial transitions, useful for motion graphics "
102 "(from least to most \"dramatic\")")),
107 "Sinusoidal easing (weakest, almost linear but with a slight curvature)"},
116 "Exponential easing (dramatic)"},
121 "Circular easing (strongest and most dynamic)"},
124 N_(
"Simple physics-inspired easing effects")),
129 "Cubic easing with overshoot and settle"},
134 "Exponentially decaying parabolic bounce, like when objects collide"},
139 "Exponentially decaying sine wave, like an elastic band"},
141 {0,
nullptr, 0,
nullptr,
nullptr},
145 {int(InterpolateFlipMode::None),
"NONE", 0,
"No Flip",
""},
146 {int(InterpolateFlipMode::Flip),
"FLIP", 0,
"Flip",
""},
147 {int(InterpolateFlipMode::FlipAuto),
"AUTO", 0,
"Automatic",
""},
148 {0,
nullptr, 0,
nullptr,
nullptr},
152 {int(InterpolateLayerMode::Active),
"ACTIVE", 0,
"Active",
""},
153 {int(InterpolateLayerMode::All),
"ALL", 0,
"All Layers",
""},
154 {0,
nullptr, 0,
nullptr,
nullptr},
208 SortedKeysIterator prev_key_it =
layer.sorted_keys_iterator_at(frame_number);
212 SortedKeysIterator next_key_it = std::next(prev_key_it);
217 if (!frame || frame->is_end()) {
226 for (; next_key_it != sorted_keys.
end(); ++next_key_it) {
227 if (is_valid_keyframe(*next_key_it)) {
231 for (; prev_key_it != sorted_keys.
begin(); --prev_key_it) {
232 if (is_valid_keyframe(*prev_key_it)) {
236 if (next_key_it == sorted_keys.
end() || !is_valid_keyframe(*prev_key_it)) {
240 return std::make_pair(*prev_key_it, *next_key_it);
246 const int current_frame,
247 const bool exclude_breakdowns,
248 const bool only_selected,
254 layer, current_frame, exclude_breakdowns);
292 if (from_selection.
size() > to_selection.
size()) {
293 from_selection = from_selection.
slice(0, to_selection.
size());
295 else if (to_selection.
size() > from_selection.
size()) {
296 to_selection = to_selection.
slice(0, from_selection.
size());
309 to_curves[from_segment[i]] = to_segment[i];
323 const int current_frame = scene.
r.
cfra;
346 switch (layer_mode) {
347 case InterpolateLayerMode::Active:
350 case InterpolateLayerMode::All:
353 data->layer_mask_memory,
354 [&](
const int layer_index) { return grease_pencil.layer(layer_index).is_editable(); });
358 bool found_mapping =
false;
360 data->layer_mask.foreach_index([&](
const int layer_index) {
368 data->exclude_breakdowns,
371 found_mapping = found_mapping || has_curve_mapping;
375 if (!found_mapping) {
381 active_layer, current_frame,
data->exclude_breakdowns);
382 data->init_factor = active_layer_interval ?
383 float(current_frame - active_layer_interval->first) /
384 (active_layer_interval->second - active_layer_interval->first + 1) :
396 int prev_from_frame = INT_MIN;
397 int prev_to_frame = INT_MIN;
398 int current_count = 0;
399 for (
const int pair_index : order) {
400 const int from_frame = curve_pairs.
from_frames[pair_index];
401 const int to_frame = curve_pairs.
to_frames[pair_index];
402 if (from_frame != prev_from_frame || to_frame != prev_to_frame) {
404 if (current_count > 0) {
405 pair_offsets.
append(current_count);
411 if (current_count > 0) {
412 pair_offsets.
append(current_count);
429 if (from_positions.
size() < 2 || to_positions.
size() < 2) {
433 constexpr float min_angle =
DEG2RADF(15);
436 const float3 &from_last = from_positions.
last();
444 .radian() < min_angle)
460 return math::dot(from_last - from_first, to_last - to_first) < 0.0f;
466 const float mix_factor,
482 std::ranges::sort(sorted_pairs, [&](
const int a,
const int b) {
483 const int from_frame_a = curve_pairs.
from_frames[a];
484 const int to_frame_a = curve_pairs.
to_frames[a];
486 const int to_frame_b = curve_pairs.
to_frames[
b];
487 return from_frame_a < from_frame_b ||
488 (from_frame_a == from_frame_b && to_frame_a < to_frame_b);
504 for (
const int pair_range_i : curves_by_pair.
index_range()) {
505 const IndexRange pair_range = curves_by_pair[pair_range_i];
508 const int first_pair_index = sorted_pairs[pair_range.
first()];
509 const int from_frame = curve_pairs.
from_frames[first_pair_index];
510 const int to_frame = curve_pairs.
to_frames[first_pair_index];
513 if (!from_drawing || !to_drawing) {
521 for (
const int sorted_index : pair_range) {
522 const int pair_index = sorted_pairs[sorted_index];
523 const int from_curve = curve_pairs.
from_curves[pair_index];
524 const int to_curve = curve_pairs.
to_curves[pair_index];
527 bool curve_flip =
false;
528 if (from_curve < 0 && to_curve < 0) {
531 else if (from_curve < 0) {
532 const IndexRange to_points = to_points_by_curve[to_curve];
533 curve_size = to_points.
size();
536 else if (to_curve < 0) {
537 const IndexRange from_points = from_points_by_curve[from_curve];
538 curve_size = from_points.
size();
542 const IndexRange from_points = from_points_by_curve[from_curve];
543 const IndexRange to_points = to_points_by_curve[to_curve];
545 curve_size = std::max(from_points.
size(), to_points.
size());
547 case InterpolateFlipMode::None:
550 case InterpolateFlipMode::Flip:
553 case InterpolateFlipMode::FlipAuto: {
555 to_positions.
slice(to_points));
561 dst_curve_offsets[pair_index] = curve_size;
562 dst_curve_flip[pair_index] = curve_flip;
567 const int dst_point_num = dst_points_by_curve.
total_size();
571 if (dst_curve_num > 0) {
584 Array<int> from_sample_indices(dst_point_num);
590 for (
const int pair_range_i : curves_by_pair.
index_range()) {
591 const IndexRange pair_range = curves_by_pair[pair_range_i];
595 sorted_pairs.
as_span().slice(pair_range), memory);
599 const int first_pair_index = sorted_pairs[pair_range.
first()];
600 const int from_frame = curve_pairs.
from_frames[first_pair_index];
601 const int to_frame = curve_pairs.
to_frames[first_pair_index];
604 if (!from_drawing || !to_drawing) {
613 const int pair_index = sorted_pairs[pair_range[i]];
614 const IndexRange dst_points = dst_points_by_curve[pair_index];
615 from_indices[i] = curve_pairs.
from_curves[pair_index];
616 to_indices[i] = curve_pairs.
to_curves[pair_index];
618 const int from_curve = curve_pairs.
from_curves[pair_index];
619 const int to_curve = curve_pairs.
to_curves[pair_index];
625 from_sample_factors.
fill(0.0f);
628 if (from_curve < 0) {
631 to_sample_factors.
fill(0.0f);
635 const IndexRange from_points = from_points_by_curve[from_curve];
636 const IndexRange to_points = to_points_by_curve[to_curve];
637 if (from_points.
size() >= to_points.
size()) {
644 to_curves_cyclic[to_curve],
645 dst_curve_flip[pair_index],
654 from_curves_cyclic[from_curve],
655 dst_curve_flip[pair_index],
659 to_sample_factors.
fill(0.0f);
698 status = msg + std::string(str_ofs);
701 status = msg + std::to_string(
int((opdata.
init_factor + opdata.
shift) * 100.0f)) +
" %";
706 &
C,
IFACE_(
"ESC/RMB to cancel, Enter/LMB to confirm, WHEEL/MOVE to adjust factor"));
712 const int frame_number)
716 const std::optional<int> start_frame =
layer.start_frame_at(frame_number);
717 if (start_frame && *start_frame == frame_number) {
727 const int frame_number)
747 const int current_frame = scene.
r.
cfra;
752 opdata.layer_mask.foreach_index([&](
const int layer_index) {
758 if (dst_drawing ==
nullptr) {
762 const float mix_factor = opdata.init_factor + opdata.shift;
766 if (opdata.smooth_factor > 0.0f && opdata.smooth_steps > 0) {
772 interpolated_curves.
cyclic(),
774 opdata.smooth_factor,
803 const int current_frame = scene.
r.
cfra;
807 opdata.layer_mask.foreach_index([&](
const int layer_index) {
841 const int current_frame = scene.
r.
cfra;
846 data.layer_mask.foreach_index([&](
const int layer_index) {
933 switch (event->
type) {
974 const float mouse_pos =
event->mval[0];
975 const float factor = std::clamp(
1008 ot->
name =
"Grease Pencil Interpolation";
1009 ot->
idname =
"GREASE_PENCIL_OT_interpolate";
1010 ot->
description =
"Interpolate Grease Pencil strokes between frames";
1026 "Bias factor for which frame has more influence on the interpolated strokes",
1035 "Layers included in the interpolation");
1038 "exclude_breakdowns",
1040 "Exclude Breakdowns",
1041 "Exclude existing Breakdowns keyframes as interpolation extremes");
1047 "Use only selected strokes for interpolating");
1052 int(InterpolateFlipMode::FlipAuto),
1054 "Invert destination stroke to match start and end with source stroke");
1062 "Number of times to smooth newly created strokes",
1072 "Amount of smoothing to apply to interpolated strokes, to reduce jitter/noise",
1086 const float back_easing,
1087 const float amplitude,
1092 constexpr float begin = 0.0f;
1093 constexpr float change = 1.0f;
1094 constexpr float duration = 1.0f;
1263 const int current_frame = scene.
r.
cfra;
1290 const int frame_range_size = interval->second - interval->first + 1;
1293 for (
int cframe = interval->first +
step; cframe < interval->second; cframe +=
step) {
1296 if (dst_drawing ==
nullptr) {
1300 const float base_factor =
float(cframe - interval->first) /
1301 std::max(frame_range_size - 1, 1);
1303 easing, type, back_easing, amplitude, period, *ipo_settings.
custom_ipo, base_factor);
1314 interpolated_curves.
cyclic(),
1349 row = &layout.
row(
true);
1353 row = &layout.
row(
true);
1357 row = &layout.
row(
true);
1360 row = &layout.
row(
true);
1363 row = &layout.
row(
true);
1370 row = &layout.
row(
true);
1379 template_curve_mapping(
1380 &layout, &gpsettings_ptr,
"interpolation_curve", 0,
false,
true,
true,
false,
false);
1383 row = &layout.
row(
false);
1386 row = &layout.
row(
false);
1390 row = &layout.
row(
false);
1392 row = &layout.
row(
false);
1402 ot->
name =
"Interpolate Sequence";
1403 ot->
idname =
"GREASE_PENCIL_OT_interpolate_sequence";
1405 ot->
description =
"Generate 'in-betweens' to smoothly interpolate between Grease Pencil frames";
1417 "Number of frames between generated interpolated frames",
1426 "Layers included in the interpolation");
1429 "exclude_breakdowns",
1431 "Exclude Breakdowns",
1432 "Exclude existing Breakdowns keyframes as interpolation extremes");
1438 "Use only selected strokes for interpolating");
1443 int(InterpolateFlipMode::FlipAuto),
1445 "Invert destination stroke to match start and end with source stroke");
1453 "Number of times to smooth newly created strokes",
1463 "Amount of smoothing to apply to interpolated strokes, to reduce jitter/noise",
1472 "Interpolation method to use the next time 'Interpolate Sequence' is run");
1481 "Which ends of the segment between the preceding and following Grease Pencil frames "
1482 "easing interpolation is applied to");
1491 "Amount of overshoot for 'back' easing",
1502 "Amount to boost elastic bounces for 'elastic' easing",
1512 "Time between bounces for elastic easing",
1542 {0,
nullptr, 0,
nullptr,
nullptr},
Low-level operations for curves.
Low-level operations for grease pencil.
#define ISECT_LINE_LINE_CROSS
#define CTX_N_(context, msgid)
#define BLT_I18NCONTEXT_ID_GPENCIL
Read Blender memory allocation and freeing.
#define RNA_ENUM_ITEM_HEADING(name, description)
#define BLI_assert_unreachable()
Span< T > as_span() const
MutableSpan< T > as_mutable_span()
void fill(const T &value) const
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
static IndexMask from_indices(Span< T > indices, LinearAllocator<> &memory)
static void foreach_segment_zipped(Span< IndexMask > masks, FunctionRef< bool(Span< IndexMaskSegment > segments)> fn)
constexpr int64_t first() const
constexpr int64_t size() const
constexpr bool is_empty() const
static constexpr IndexRange from_single(const int64_t index)
constexpr IndexRange index_range() const
const int * SortedKeysIterator
constexpr void fill(const T &value) const
IndexRange index_range() const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T & first() const
constexpr int64_t size() const
constexpr const T & last(const int64_t n=0) const
constexpr const T * end() const
constexpr const T * begin() const
static VArray from_single(T value, const int64_t size)
void append(const T &value)
void resize(const int64_t new_size)
MutableSpan< T > as_mutable_span()
void append_n_times(const T &value, const int64_t n)
MutableSpan< float3 > positions_for_write()
VArray< bool > cyclic() const
Span< float3 > positions() const
IndexRange curves_range() const
MutableSpan< int > offsets_for_write()
void tag_positions_changed()
OffsetIndices< int > points_by_curve() const
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
void tag_topology_changed()
IndexMask slice(IndexRange range) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexRange index_range() const
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
void fill_index_range(MutableSpan< T > span, const T start=0)
bool has_anything_selected(const VArray< bool > &varray, const IndexRange range_to_check)
IndexMask retrieve_selected_curves(const bke::CurvesGeometry &curves, LinearAllocator<> &memory)
bool active_grease_pencil_poll(bContext *C)
static float grease_pencil_interpolate_sequence_easing_calc(const eBezTriple_Easing easing, const InterpolationType type, const float back_easing, const float amplitude, const float period, const CurveMapping &custom_ipo, const float time)
static void grease_pencil_interpolate_exit(bContext &C, wmOperator &op)
static bool find_curve_mapping_from_index(const GreasePencil &grease_pencil, const bke::greasepencil::Layer &layer, const int current_frame, const bool exclude_breakdowns, const bool only_selected, InterpolationPairs &pairs)
static bke::CurvesGeometry interpolate_between_curves(const GreasePencil &grease_pencil, const bke::greasepencil::Layer &layer, const InterpolationPairs &curve_pairs, const float mix_factor, const InterpolateFlipMode flip_mode)
InterpolateToolModalEvent
static void grease_pencil_interpolate_cancel(bContext *C, wmOperator *op)
constexpr float interpolate_factor_min
static wmOperatorStatus grease_pencil_interpolate_invoke(bContext *C, wmOperator *op, const wmEvent *)
static void grease_pencil_interpolate_status_indicators(bContext &C, const InterpolateOpData &opdata)
static wmOperatorStatus grease_pencil_interpolate_sequence_exec(bContext *C, wmOperator *op)
static const EnumPropertyItem grease_pencil_interpolate_layer_items[]
static bool grease_pencil_interpolate_init(const bContext &C, wmOperator &op)
static const EnumPropertyItem grease_pencil_interpolate_flip_mode_items[]
static bool compute_auto_flip(const Span< float3 > from_positions, const Span< float3 > to_positions)
static const EnumPropertyItem grease_pencil_interpolation_type_items[]
static void grease_pencil_interpolate_sequence_ui(bContext *C, wmOperator *op)
static wmOperatorStatus grease_pencil_interpolate_modal(bContext *C, wmOperator *op, const wmEvent *event)
static bke::greasepencil::Drawing * get_drawing_at_exact_frame(GreasePencil &grease_pencil, bke::greasepencil::Layer &layer, const int frame_number)
constexpr float interpolate_factor_max
static bool grease_pencil_interpolate_poll(bContext *C)
static void grease_pencil_interpolate_update(bContext &C, const wmOperator &op)
static void GREASE_PENCIL_OT_interpolate_sequence(wmOperatorType *ot)
static std::optional< FramesMapKeyIntervalT > find_frames_interval(const bke::greasepencil::Layer &layer, const int frame_number, const bool exclude_breakdowns)
static void grease_pencil_interpolate_restore(bContext &C, wmOperator &op)
static void GREASE_PENCIL_OT_interpolate(wmOperatorType *ot)
std::pair< int, int > FramesMapKeyIntervalT
static Vector< int > find_curve_pair_offsets(const InterpolationPairs &curve_pairs, const Span< int > order)
static bke::greasepencil::Drawing * ensure_drawing_at_exact_frame(GreasePencil &grease_pencil, bke::greasepencil::Layer &layer, InterpolateOpData::LayerData &layer_data, const int frame_number)
void interpolate_curves_with_samples(const bke::CurvesGeometry &from_curves, const bke::CurvesGeometry &to_curves, Span< int > from_curve_indices, Span< int > to_curve_indices, Span< int > from_sample_indices, Span< int > to_sample_indices, Span< float > from_sample_factors, Span< float > to_sample_factors, const IndexMask &dst_curve_mask, float mix_factor, bke::CurvesGeometry &dst_curves, IndexMaskMemory &memory)
void sample_curve_padded(const Span< float3 > positions, bool cyclic, MutableSpan< int > r_indices, MutableSpan< float > r_factors)
void smooth_curve_attribute(const IndexMask &curves_to_smooth, const OffsetIndices< int > points_by_curve, const VArray< bool > &point_selection, const VArray< bool > &cyclic, int iterations, float influence, bool smooth_ends, bool keep_shape, GMutableSpan attribute_data)
AngleRadianBase< T > angle_between(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
T distance_squared(const VecBase< T, Size > &a, const VecBase< T, Size > &b)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
float BLI_easing_elastic_ease_in(float time, float begin, float change, float duration, float amplitude, float period)
void WM_operatortype_append(void(*opfunc)(wmOperatorType *))
float BLI_easing_quint_ease_out(float time, float begin, float change, float duration)
ScrArea * CTX_wm_area(const bContext *C)
int RNA_enum_get(PointerRNA *ptr, const char *name)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
wmKeyMap * WM_modalkeymap_find(wmKeyConfig *keyconf, const char *idname)
float BLI_easing_sine_ease_in(float time, float begin, float change, float duration)
float BLI_easing_back_ease_in_out(float time, float begin, float change, float duration, float overshoot)
float BLI_easing_expo_ease_in_out(float time, float begin, float change, float duration)
bool handleNumInput(bContext *C, NumInput *n, const wmEvent *event)
float BLI_easing_quad_ease_out(float time, float begin, float change, float duration)
void WM_cursor_modal_set(wmWindow *win, int val)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
float BLI_easing_cubic_ease_in_out(float time, float begin, float change, float duration)
int RNA_int_get(PointerRNA *ptr, const char *name)
bool hasNumInput(const NumInput *n)
wmWindow * CTX_wm_window(const bContext *C)
enum eContextObjectMode CTX_data_mode_enum(const bContext *C)
int isect_seg_seg_v2(const float v1[2], const float v2[2], const float v3[2], const float v4[2])
float BLI_easing_quart_ease_out(float time, float begin, float change, float duration)
float BLI_easing_cubic_ease_out(float time, float begin, float change, float duration)
float BLI_easing_sine_ease_out(float time, float begin, float change, float duration)
float BLI_easing_back_ease_out(float time, float begin, float change, float duration, float overshoot)
float BLI_easing_expo_ease_in(float time, float begin, float change, float duration)
@ CTX_MODE_EDIT_GPENCIL_LEGACY
float BLI_easing_bounce_ease_out(float time, float begin, float change, float duration)
void ED_operatortypes_grease_pencil_interpolate()
void ED_interpolatetool_modal_keymap(wmKeyConfig *keyconf)
float BLI_easing_circ_ease_out(float time, float begin, float change, float duration)
float BLI_easing_circ_ease_in_out(float time, float begin, float change, float duration)
PropertyRNA * RNA_def_float_factor(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
float BLI_easing_quint_ease_in(float time, float begin, float change, float duration)
void BKE_curvemapping_init(CurveMapping *cumap)
void DEG_id_tag_update(ID *id, unsigned int flags)
BMesh const char void * data
float BLI_easing_quad_ease_in_out(float time, float begin, float change, float duration)
const EnumPropertyItem rna_enum_beztriple_interpolation_easing_items[]
void WM_cursor_modal_restore(wmWindow *win)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
float BLI_easing_back_ease_in(float time, float begin, float change, float duration, float overshoot)
void ED_area_status_text(ScrArea *area, const char *str)
ToolSettings * CTX_data_tool_settings(const bContext *C)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
float BLI_easing_quart_ease_in_out(float time, float begin, float change, float duration)
bool applyNumInput(NumInput *n, float *vec)
float BLI_easing_bounce_ease_in(float time, float begin, float change, float duration)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
float BLI_easing_expo_ease_out(float time, float begin, float change, float duration)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
float BLI_easing_bounce_ease_in_out(float time, float begin, float change, float duration)
float BLI_easing_quint_ease_in_out(float time, float begin, float change, float duration)
void outputNumInput(NumInput *n, char *str, const UnitSettings &unit_settings)
float BLI_easing_circ_ease_in(float time, float begin, float change, float duration)
void BKE_defgroup_copy_list(ListBaseT< bDeformGroup > *outbase, const ListBaseT< bDeformGroup > *inbase)
void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
float BLI_easing_elastic_ease_in_out(float time, float begin, float change, float duration, float amplitude, float period)
Scene * CTX_data_scene(const bContext *C)
wmKeyMap * WM_modalkeymap_ensure(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items)
float BLI_easing_quad_ease_in(float time, float begin, float change, float duration)
VecBase< float, 3 > float3
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
float BLI_easing_quart_ease_in(float time, float begin, float change, float duration)
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
Object * CTX_data_active_object(const bContext *C)
ARegion * CTX_wm_region(const bContext *C)
void ED_workspace_status_text(bContext *C, const char *str)
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
float BLI_easing_sine_ease_in_out(float time, float begin, float change, float duration)
float RNA_float_get(PointerRNA *ptr, const char *name)
float BLI_easing_cubic_ease_in(float time, float begin, float change, float duration)
float BLI_easing_elastic_ease_out(float time, float begin, float change, float duration, float amplitude, float period)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ListBaseT< struct bDeformGroup > vertex_group_names
struct CurveMapping * custom_ipo
struct ToolSettings * toolsettings
InterpolationPairs curve_pairs
std::optional< bke::CurvesGeometry > orig_curves
IndexMaskMemory layer_mask_memory
InterpolateFlipMode flipmode
static InterpolateOpData * from_operator(const bContext &C, const wmOperator &op)
Array< LayerData > layer_data
Vector< int > from_frames
Vector< int > from_curves
void use_property_decorate_set(bool is_decorate)
void use_property_split_set(bool is_sep)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
Layout & column(bool align)
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
void(*) cancel(bContext *C, wmOperator *op)
const char * translation_context
void(*) ui(bContext *C, wmOperator *op)
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT