1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License
4 * as published by the Free Software Foundation; either version 2
5 * of the License, or (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software Foundation,
14 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15 */
16
17 /** \file
18 * \ingroup RNA
19 */
20
21 #include <stdlib.h>
22
23 #include "DNA_anim_types.h"
24 #include "DNA_curve_types.h"
25 #include "DNA_object_types.h"
26 #include "DNA_scene_types.h"
27
28 #include "MEM_guardedalloc.h"
29
30 #include "BLT_translation.h"
31
32 #include "BKE_action.h"
33
34 #include "RNA_access.h"
35 #include "RNA_define.h"
36 #include "RNA_enum_types.h"
37
38 #include "rna_internal.h"
39
40 #include "WM_types.h"
41
42 #include "ED_keyframes_edit.h"
43 #include "ED_keyframing.h"
44
45 const EnumPropertyItem rna_enum_fmodifier_type_items[] = {
46 {FMODIFIER_TYPE_NULL, "NULL", 0, "Invalid", ""},
47 {FMODIFIER_TYPE_GENERATOR,
48 "GENERATOR",
49 0,
50 "Generator",
51 "Generate a curve using a factorized or expanded polynomial"},
52 {FMODIFIER_TYPE_FN_GENERATOR,
53 "FNGENERATOR",
54 0,
55 "Built-In Function",
56 "Generate a curve using standard math functions such as sin and cos"},
57 {FMODIFIER_TYPE_ENVELOPE,
58 "ENVELOPE",
59 0,
60 "Envelope",
61 "Reshape F-Curve values - e.g. change amplitude of movements"},
62 {FMODIFIER_TYPE_CYCLES, "CYCLES", 0, "Cycles", "Cyclic extend/repeat keyframe sequence"},
63 {FMODIFIER_TYPE_NOISE, "NOISE", 0, "Noise", "Add pseudo-random noise on top of F-Curves"},
64 /*{FMODIFIER_TYPE_FILTER, "FILTER", 0, "Filter", ""},*/ /* FIXME: not implemented yet! */
65 /*{FMODIFIER_TYPE_PYTHON, "PYTHON", 0, "Python", ""},*/ /* FIXME: not implemented yet! */
66 {FMODIFIER_TYPE_LIMITS,
67 "LIMITS",
68 0,
69 "Limits",
70 "Restrict maximum and minimum values of F-Curve"},
71 {FMODIFIER_TYPE_STEPPED,
72 "STEPPED",
73 0,
74 "Stepped Interpolation",
75 "Snap values to nearest grid-step - e.g. for a stop-motion look"},
76 {0, NULL, 0, NULL, NULL},
77 };
78
79 const EnumPropertyItem rna_enum_fcurve_auto_smoothing_items[] = {
80 {FCURVE_SMOOTH_NONE,
81 "NONE",
82 0,
83 "None",
84 "Automatic handles only take immediately adjacent keys into account"},
85 {FCURVE_SMOOTH_CONT_ACCEL,
86 "CONT_ACCEL",
87 0,
88 "Continuous Acceleration",
89 "Automatic handles are adjusted to avoid jumps in acceleration, resulting "
90 "in smoother curves. However, key changes may affect interpolation over a "
91 "larger stretch of the curve"},
92 {0, NULL, 0, NULL, NULL},
93 };
94
95 const EnumPropertyItem rna_enum_beztriple_keyframe_type_items[] = {
96 {BEZT_KEYTYPE_KEYFRAME,
97 "KEYFRAME",
98 ICON_KEYTYPE_KEYFRAME_VEC,
99 "Keyframe",
100 "Normal keyframe - e.g. for key poses"},
101 {BEZT_KEYTYPE_BREAKDOWN,
102 "BREAKDOWN",
103 ICON_KEYTYPE_BREAKDOWN_VEC,
104 "Breakdown",
105 "A breakdown pose - e.g. for transitions between key poses"},
106 {BEZT_KEYTYPE_MOVEHOLD,
107 "MOVING_HOLD",
108 ICON_KEYTYPE_MOVING_HOLD_VEC,
109 "Moving Hold",
110 "A keyframe that is part of a moving hold"},
111 {BEZT_KEYTYPE_EXTREME,
112 "EXTREME",
113 ICON_KEYTYPE_EXTREME_VEC,
114 "Extreme",
115 "An 'extreme' pose, or some other purpose as needed"},
116 {BEZT_KEYTYPE_JITTER,
117 "JITTER",
118 ICON_KEYTYPE_JITTER_VEC,
119 "Jitter",
120 "A filler or baked keyframe for keying on ones, or some other purpose as needed"},
121 {0, NULL, 0, NULL, NULL},
122 };
123
124 const EnumPropertyItem rna_enum_beztriple_interpolation_easing_items[] = {
125 /* XXX: auto-easing is currently using a placeholder icon... */
126 {BEZT_IPO_EASE_AUTO,
127 "AUTO",
128 ICON_IPO_EASE_IN_OUT,
129 "Automatic Easing",
130 "Easing type is chosen automatically based on what the type of interpolation used "
131 "(e.g. 'Ease In' for transitional types, and 'Ease Out' for dynamic effects)"},
132
133 {BEZT_IPO_EASE_IN,
134 "EASE_IN",
135 ICON_IPO_EASE_IN,
136 "Ease In",
137 "Only on the end closest to the next keyframe"},
138 {BEZT_IPO_EASE_OUT,
139 "EASE_OUT",
140 ICON_IPO_EASE_OUT,
141 "Ease Out",
142 "Only on the end closest to the first keyframe"},
143 {BEZT_IPO_EASE_IN_OUT,
144 "EASE_IN_OUT",
145 ICON_IPO_EASE_IN_OUT,
146 "Ease In and Out",
147 "Segment between both keyframes"},
148 {0, NULL, 0, NULL, NULL},
149 };
150
151 const EnumPropertyItem rna_enum_driver_target_rotation_mode_items[] = {
152 {DTAR_ROTMODE_AUTO, "AUTO", 0, "Auto Euler", "Euler using the rotation order of the target"},
153 {DTAR_ROTMODE_EULER_XYZ, "XYZ", 0, "XYZ Euler", "Euler using the XYZ rotation order"},
154 {DTAR_ROTMODE_EULER_XZY, "XZY", 0, "XZY Euler", "Euler using the XZY rotation order"},
155 {DTAR_ROTMODE_EULER_YXZ, "YXZ", 0, "YXZ Euler", "Euler using the YXZ rotation order"},
156 {DTAR_ROTMODE_EULER_YZX, "YZX", 0, "YZX Euler", "Euler using the YZX rotation order"},
157 {DTAR_ROTMODE_EULER_ZXY, "ZXY", 0, "ZXY Euler", "Euler using the ZXY rotation order"},
158 {DTAR_ROTMODE_EULER_ZYX, "ZYX", 0, "ZYX Euler", "Euler using the ZYX rotation order"},
159 {DTAR_ROTMODE_QUATERNION, "QUATERNION", 0, "Quaternion", "Quaternion rotation"},
160 {DTAR_ROTMODE_SWING_TWIST_X,
161 "SWING_TWIST_X",
162 0,
163 "Swing and X Twist",
164 "Decompose into a swing rotation to aim the X axis, followed by twist around it"},
165 {DTAR_ROTMODE_SWING_TWIST_Y,
166 "SWING_TWIST_Y",
167 0,
168 "Swing and Y Twist",
169 "Decompose into a swing rotation to aim the Y axis, followed by twist around it"},
170 {DTAR_ROTMODE_SWING_TWIST_Z,
171 "SWING_TWIST_Z",
172 0,
173 "Swing and Z Twist",
174 "Decompose into a swing rotation to aim the Z axis, followed by twist around it"},
175 {0, NULL, 0, NULL, NULL},
176 };
177
178 #ifdef RNA_RUNTIME
179
180 # include "WM_api.h"
181
rna_FModifierType_refine(struct PointerRNA * ptr)182 static StructRNA *rna_FModifierType_refine(struct PointerRNA *ptr)
183 {
184 FModifier *fcm = (FModifier *)ptr->data;
185
186 switch (fcm->type) {
187 case FMODIFIER_TYPE_GENERATOR:
188 return &RNA_FModifierGenerator;
189 case FMODIFIER_TYPE_FN_GENERATOR:
190 return &RNA_FModifierFunctionGenerator;
191 case FMODIFIER_TYPE_ENVELOPE:
192 return &RNA_FModifierEnvelope;
193 case FMODIFIER_TYPE_CYCLES:
194 return &RNA_FModifierCycles;
195 case FMODIFIER_TYPE_NOISE:
196 return &RNA_FModifierNoise;
197 # if 0
198 case FMODIFIER_TYPE_FILTER:
199 return &RNA_FModifierFilter;
200 # endif
201 case FMODIFIER_TYPE_PYTHON:
202 return &RNA_FModifierPython;
203 case FMODIFIER_TYPE_LIMITS:
204 return &RNA_FModifierLimits;
205 case FMODIFIER_TYPE_STEPPED:
206 return &RNA_FModifierStepped;
207 default:
208 return &RNA_UnknownType;
209 }
210 }
211
212 /* ****************************** */
213
214 # include "BKE_anim_data.h"
215 # include "BKE_fcurve.h"
216 # include "BKE_fcurve_driver.h"
217
218 # include "DEG_depsgraph.h"
219 # include "DEG_depsgraph_build.h"
220
rna_ChannelDriver_is_simple_expression_get(PointerRNA * ptr)221 static bool rna_ChannelDriver_is_simple_expression_get(PointerRNA *ptr)
222 {
223 ChannelDriver *driver = ptr->data;
224
225 return BKE_driver_has_simple_expression(driver);
226 }
227
rna_ChannelDriver_update_data(Main * bmain,Scene * scene,PointerRNA * ptr)228 static void rna_ChannelDriver_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
229 {
230 ID *id = ptr->owner_id;
231 ChannelDriver *driver = ptr->data;
232
233 driver->flag &= ~DRIVER_FLAG_INVALID;
234
235 /* TODO: this really needs an update guard... */
236 DEG_relations_tag_update(bmain);
237 DEG_id_tag_update(id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
238
239 WM_main_add_notifier(NC_SCENE | ND_FRAME, scene);
240 }
241
rna_ChannelDriver_update_expr(Main * bmain,Scene * scene,PointerRNA * ptr)242 static void rna_ChannelDriver_update_expr(Main *bmain, Scene *scene, PointerRNA *ptr)
243 {
244 ChannelDriver *driver = ptr->data;
245
246 /* tag driver as needing to be recompiled */
247 BKE_driver_invalidate_expression(driver, true, false);
248
249 /* update_data() clears invalid flag and schedules for updates */
250 rna_ChannelDriver_update_data(bmain, scene, ptr);
251 }
252
rna_DriverTarget_update_data(Main * bmain,Scene * scene,PointerRNA * ptr)253 static void rna_DriverTarget_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
254 {
255 PointerRNA driverptr;
256 ChannelDriver *driver;
257 FCurve *fcu;
258 AnimData *adt = BKE_animdata_from_id(ptr->owner_id);
259
260 /* find the driver this belongs to and update it */
261 for (fcu = adt->drivers.first; fcu; fcu = fcu->next) {
262 driver = fcu->driver;
263 fcu->flag &= ~FCURVE_DISABLED;
264
265 if (driver) {
266 /* FIXME: need to be able to search targets for required one... */
267 /*BLI_findindex(&driver->targets, ptr->data) != -1) */
268 RNA_pointer_create(ptr->owner_id, &RNA_Driver, driver, &driverptr);
269 rna_ChannelDriver_update_data(bmain, scene, &driverptr);
270 }
271 }
272 }
273
rna_DriverTarget_update_name(Main * bmain,Scene * scene,PointerRNA * ptr)274 static void rna_DriverTarget_update_name(Main *bmain, Scene *scene, PointerRNA *ptr)
275 {
276 ChannelDriver *driver = ptr->data;
277 rna_DriverTarget_update_data(bmain, scene, ptr);
278
279 BKE_driver_invalidate_expression(driver, false, true);
280 }
281
282 /* ----------- */
283
284 /* note: this function exists only to avoid id refcounting */
rna_DriverTarget_id_set(PointerRNA * ptr,PointerRNA value,struct ReportList * UNUSED (reports))285 static void rna_DriverTarget_id_set(PointerRNA *ptr,
286 PointerRNA value,
287 struct ReportList *UNUSED(reports))
288 {
289 DriverTarget *dtar = (DriverTarget *)ptr->data;
290 dtar->id = value.data;
291 }
292
rna_DriverTarget_id_typef(PointerRNA * ptr)293 static StructRNA *rna_DriverTarget_id_typef(PointerRNA *ptr)
294 {
295 DriverTarget *dtar = (DriverTarget *)ptr->data;
296 return ID_code_to_RNA_type(dtar->idtype);
297 }
298
rna_DriverTarget_id_editable(PointerRNA * ptr,const char ** UNUSED (r_info))299 static int rna_DriverTarget_id_editable(PointerRNA *ptr, const char **UNUSED(r_info))
300 {
301 DriverTarget *dtar = (DriverTarget *)ptr->data;
302 return (dtar->idtype) ? PROP_EDITABLE : 0;
303 }
304
rna_DriverTarget_id_type_editable(PointerRNA * ptr,const char ** UNUSED (r_info))305 static int rna_DriverTarget_id_type_editable(PointerRNA *ptr, const char **UNUSED(r_info))
306 {
307 DriverTarget *dtar = (DriverTarget *)ptr->data;
308
309 /* when the id-type can only be object, don't allow editing
310 * otherwise, there may be strange crashes
311 */
312 return ((dtar->flag & DTAR_FLAG_ID_OB_ONLY) == 0);
313 }
314
rna_DriverTarget_id_type_set(PointerRNA * ptr,int value)315 static void rna_DriverTarget_id_type_set(PointerRNA *ptr, int value)
316 {
317 DriverTarget *data = (DriverTarget *)(ptr->data);
318
319 /* check if ID-type is settable */
320 if ((data->flag & DTAR_FLAG_ID_OB_ONLY) == 0) {
321 /* change ID-type to the new type */
322 data->idtype = value;
323 }
324 else {
325 /* make sure ID-type is Object */
326 data->idtype = ID_OB;
327 }
328
329 /* clear the id-block if the type is invalid */
330 if ((data->id) && (GS(data->id->name) != data->idtype)) {
331 data->id = NULL;
332 }
333 }
334
rna_DriverTarget_RnaPath_get(PointerRNA * ptr,char * value)335 static void rna_DriverTarget_RnaPath_get(PointerRNA *ptr, char *value)
336 {
337 DriverTarget *dtar = (DriverTarget *)ptr->data;
338
339 if (dtar->rna_path) {
340 strcpy(value, dtar->rna_path);
341 }
342 else {
343 value[0] = '\0';
344 }
345 }
346
rna_DriverTarget_RnaPath_length(PointerRNA * ptr)347 static int rna_DriverTarget_RnaPath_length(PointerRNA *ptr)
348 {
349 DriverTarget *dtar = (DriverTarget *)ptr->data;
350
351 if (dtar->rna_path) {
352 return strlen(dtar->rna_path);
353 }
354 else {
355 return 0;
356 }
357 }
358
rna_DriverTarget_RnaPath_set(PointerRNA * ptr,const char * value)359 static void rna_DriverTarget_RnaPath_set(PointerRNA *ptr, const char *value)
360 {
361 DriverTarget *dtar = (DriverTarget *)ptr->data;
362
363 /* XXX in this case we need to be very careful,
364 * as this will require some new dependencies to be added! */
365 if (dtar->rna_path) {
366 MEM_freeN(dtar->rna_path);
367 }
368
369 if (value[0]) {
370 dtar->rna_path = BLI_strdup(value);
371 }
372 else {
373 dtar->rna_path = NULL;
374 }
375 }
376
rna_DriverVariable_type_set(PointerRNA * ptr,int value)377 static void rna_DriverVariable_type_set(PointerRNA *ptr, int value)
378 {
379 DriverVar *dvar = (DriverVar *)ptr->data;
380
381 /* call the API function for this */
382 driver_change_variable_type(dvar, value);
383 }
384
rna_DriverVariable_name_set(PointerRNA * ptr,const char * value)385 void rna_DriverVariable_name_set(PointerRNA *ptr, const char *value)
386 {
387 DriverVar *data = (DriverVar *)(ptr->data);
388
389 BLI_strncpy_utf8(data->name, value, 64);
390 driver_variable_name_validate(data);
391 }
392
393 /* ----------- */
394
rna_Driver_new_variable(ChannelDriver * driver)395 static DriverVar *rna_Driver_new_variable(ChannelDriver *driver)
396 {
397 /* call the API function for this */
398 return driver_add_new_variable(driver);
399 }
400
rna_Driver_remove_variable(ChannelDriver * driver,ReportList * reports,PointerRNA * dvar_ptr)401 static void rna_Driver_remove_variable(ChannelDriver *driver,
402 ReportList *reports,
403 PointerRNA *dvar_ptr)
404 {
405 DriverVar *dvar = dvar_ptr->data;
406 if (BLI_findindex(&driver->variables, dvar) == -1) {
407 BKE_report(reports, RPT_ERROR, "Variable does not exist in this driver");
408 return;
409 }
410
411 driver_free_variable_ex(driver, dvar);
412 RNA_POINTER_INVALIDATE(dvar_ptr);
413 }
414
415 /* ****************************** */
416
rna_FKeyframe_handle1_get(PointerRNA * ptr,float * values)417 static void rna_FKeyframe_handle1_get(PointerRNA *ptr, float *values)
418 {
419 BezTriple *bezt = (BezTriple *)ptr->data;
420
421 values[0] = bezt->vec[0][0];
422 values[1] = bezt->vec[0][1];
423 }
424
rna_FKeyframe_handle1_set(PointerRNA * ptr,const float * values)425 static void rna_FKeyframe_handle1_set(PointerRNA *ptr, const float *values)
426 {
427 BezTriple *bezt = (BezTriple *)ptr->data;
428
429 bezt->vec[0][0] = values[0];
430 bezt->vec[0][1] = values[1];
431 }
432
rna_FKeyframe_handle2_get(PointerRNA * ptr,float * values)433 static void rna_FKeyframe_handle2_get(PointerRNA *ptr, float *values)
434 {
435 BezTriple *bezt = (BezTriple *)ptr->data;
436
437 values[0] = bezt->vec[2][0];
438 values[1] = bezt->vec[2][1];
439 }
440
rna_FKeyframe_handle2_set(PointerRNA * ptr,const float * values)441 static void rna_FKeyframe_handle2_set(PointerRNA *ptr, const float *values)
442 {
443 BezTriple *bezt = (BezTriple *)ptr->data;
444
445 bezt->vec[2][0] = values[0];
446 bezt->vec[2][1] = values[1];
447 }
448
rna_FKeyframe_ctrlpoint_get(PointerRNA * ptr,float * values)449 static void rna_FKeyframe_ctrlpoint_get(PointerRNA *ptr, float *values)
450 {
451 BezTriple *bezt = (BezTriple *)ptr->data;
452
453 values[0] = bezt->vec[1][0];
454 values[1] = bezt->vec[1][1];
455 }
456
rna_FKeyframe_ctrlpoint_set(PointerRNA * ptr,const float * values)457 static void rna_FKeyframe_ctrlpoint_set(PointerRNA *ptr, const float *values)
458 {
459 BezTriple *bezt = (BezTriple *)ptr->data;
460
461 bezt->vec[1][0] = values[0];
462 bezt->vec[1][1] = values[1];
463 }
464
rna_FKeyframe_ctrlpoint_ui_set(PointerRNA * ptr,const float * values)465 static void rna_FKeyframe_ctrlpoint_ui_set(PointerRNA *ptr, const float *values)
466 {
467 BezTriple *bezt = (BezTriple *)ptr->data;
468
469 const float frame_delta = values[0] - bezt->vec[1][0];
470 const float value_delta = values[1] - bezt->vec[1][1];
471
472 /** To match the behavior of transforming the keyframe Co using the Graph Editor
473 * (transform_convert_graph.c) flushTransGraphData(), we will also move the handles by
474 * the same amount as the Co delta. */
475
476 bezt->vec[0][0] += frame_delta;
477 bezt->vec[0][1] += value_delta;
478
479 bezt->vec[1][0] = values[0];
480 bezt->vec[1][1] = values[1];
481
482 bezt->vec[2][0] += frame_delta;
483 bezt->vec[2][1] += value_delta;
484 }
485
486 /* ****************************** */
487
rna_FCurve_RnaPath_get(PointerRNA * ptr,char * value)488 static void rna_FCurve_RnaPath_get(PointerRNA *ptr, char *value)
489 {
490 FCurve *fcu = (FCurve *)ptr->data;
491
492 if (fcu->rna_path) {
493 strcpy(value, fcu->rna_path);
494 }
495 else {
496 value[0] = '\0';
497 }
498 }
499
rna_FCurve_RnaPath_length(PointerRNA * ptr)500 static int rna_FCurve_RnaPath_length(PointerRNA *ptr)
501 {
502 FCurve *fcu = (FCurve *)ptr->data;
503
504 if (fcu->rna_path) {
505 return strlen(fcu->rna_path);
506 }
507 else {
508 return 0;
509 }
510 }
511
rna_FCurve_RnaPath_set(PointerRNA * ptr,const char * value)512 static void rna_FCurve_RnaPath_set(PointerRNA *ptr, const char *value)
513 {
514 FCurve *fcu = (FCurve *)ptr->data;
515
516 if (fcu->rna_path) {
517 MEM_freeN(fcu->rna_path);
518 }
519
520 if (value[0]) {
521 fcu->rna_path = BLI_strdup(value);
522 fcu->flag &= ~FCURVE_DISABLED;
523 }
524 else {
525 fcu->rna_path = NULL;
526 }
527 }
528
rna_FCurve_group_set(PointerRNA * ptr,PointerRNA value,struct ReportList * UNUSED (reports))529 static void rna_FCurve_group_set(PointerRNA *ptr,
530 PointerRNA value,
531 struct ReportList *UNUSED(reports))
532 {
533 ID *pid = ptr->owner_id;
534 ID *vid = value.owner_id;
535 FCurve *fcu = ptr->data;
536 bAction *act = NULL;
537
538 /* get action */
539 if (ELEM(NULL, pid, vid)) {
540 printf("ERROR: one of the ID's for the groups to assign to is invalid (ptr=%p, val=%p)\n",
541 pid,
542 vid);
543 return;
544 }
545 else if (value.data && (pid != vid)) {
546 /* id's differ, cant do this, should raise an error */
547 printf("ERROR: ID's differ - ptr=%p vs value=%p\n", pid, vid);
548 return;
549 }
550
551 if (GS(pid->name) == ID_AC && GS(vid->name) == ID_AC) {
552 /* The ID given is the action already -
553 * usually when F-Curve is obtained from an action's pointer. */
554 act = (bAction *)pid;
555 }
556 else {
557 /* the ID given is the owner of the F-Curve (for drivers) */
558 AnimData *adt = BKE_animdata_from_id(ptr->owner_id);
559 act = (adt) ? adt->action : NULL;
560 }
561
562 /* already belongs to group? */
563 if (fcu->grp == value.data) {
564 /* nothing to do */
565 printf("ERROR: F-Curve already belongs to this group\n");
566 return;
567 }
568
569 /* can only change group if we have info about the action the F-Curve is in
570 * (i.e. for drivers or random F-Curves, this cannot be done)
571 */
572 if (act == NULL) {
573 /* can't change the grouping of F-Curve when it doesn't belong to an action */
574 printf("ERROR: cannot assign F-Curve to group, since F-Curve is not attached to any ID\n");
575 return;
576 }
577 /* make sure F-Curve exists in this action first, otherwise we could still have been tricked */
578 else if (BLI_findindex(&act->curves, fcu) == -1) {
579 printf("ERROR: F-Curve (%p) doesn't exist in action '%s'\n", fcu, act->id.name);
580 return;
581 }
582
583 /* try to remove F-Curve from action (including from any existing groups) */
584 action_groups_remove_channel(act, fcu);
585
586 /* add the F-Curve back to the action now in the right place */
587 /* TODO: make the api function handle the case where there isn't any group to assign to */
588 if (value.data) {
589 /* add to its group using API function, which makes sure everything goes ok */
590 action_groups_add_channel(act, value.data, fcu);
591 }
592 else {
593 /* Need to add this back, but it can only go at the end of the list
594 * (or else will corrupt groups). */
595 BLI_addtail(&act->curves, fcu);
596 }
597 }
598
599 /* calculate time extents of F-Curve */
rna_FCurve_range(FCurve * fcu,float range[2])600 static void rna_FCurve_range(FCurve *fcu, float range[2])
601 {
602 BKE_fcurve_calc_range(fcu, range, range + 1, false, false);
603 }
604
rna_FCurve_is_empty_get(PointerRNA * ptr)605 static bool rna_FCurve_is_empty_get(PointerRNA *ptr)
606 {
607 FCurve *fcu = (FCurve *)ptr->data;
608 return BKE_fcurve_is_empty(fcu);
609 }
610
rna_tag_animation_update(Main * bmain,ID * id)611 static void rna_tag_animation_update(Main *bmain, ID *id)
612 {
613 const int tags = ID_RECALC_ANIMATION;
614 AnimData *adt = BKE_animdata_from_id(id);
615
616 if (adt && adt->action) {
617 /* Action is separate datablock, needs separate tag. */
618 DEG_id_tag_update_ex(bmain, &adt->action->id, tags);
619 }
620
621 DEG_id_tag_update_ex(bmain, id, tags);
622 }
623
624 /* allow scripts to update curve after editing manually */
rna_FCurve_update_data_ex(ID * id,FCurve * fcu,Main * bmain)625 static void rna_FCurve_update_data_ex(ID *id, FCurve *fcu, Main *bmain)
626 {
627 sort_time_fcurve(fcu);
628 calchandles_fcurve(fcu);
629
630 rna_tag_animation_update(bmain, id);
631 }
632
633 /* RNA update callback for F-Curves after curve shape changes */
rna_FCurve_update_data(Main * bmain,Scene * UNUSED (scene),PointerRNA * ptr)634 static void rna_FCurve_update_data(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
635 {
636 BLI_assert(ptr->type == &RNA_FCurve);
637 rna_FCurve_update_data_ex(ptr->owner_id, (FCurve *)ptr->data, bmain);
638 }
639
rna_FCurve_update_data_relations(Main * bmain,Scene * UNUSED (scene),PointerRNA * UNUSED (ptr))640 static void rna_FCurve_update_data_relations(Main *bmain,
641 Scene *UNUSED(scene),
642 PointerRNA *UNUSED(ptr))
643 {
644 DEG_relations_tag_update(bmain);
645 }
646
647 /* RNA update callback for F-Curves to indicate that there are copy-on-write tagging/flushing
648 * needed (e.g. for properties that affect how animation gets evaluated).
649 */
rna_FCurve_update_eval(Main * bmain,Scene * UNUSED (scene),PointerRNA * ptr)650 static void rna_FCurve_update_eval(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
651 {
652 rna_tag_animation_update(bmain, ptr->owner_id);
653 }
654
rna_FCurve_active_modifier_get(PointerRNA * ptr)655 static PointerRNA rna_FCurve_active_modifier_get(PointerRNA *ptr)
656 {
657 FCurve *fcu = (FCurve *)ptr->data;
658 FModifier *fcm = find_active_fmodifier(&fcu->modifiers);
659 return rna_pointer_inherit_refine(ptr, &RNA_FModifier, fcm);
660 }
661
rna_FCurve_active_modifier_set(PointerRNA * ptr,PointerRNA value,struct ReportList * UNUSED (reports))662 static void rna_FCurve_active_modifier_set(PointerRNA *ptr,
663 PointerRNA value,
664 struct ReportList *UNUSED(reports))
665 {
666 FCurve *fcu = (FCurve *)ptr->data;
667 set_active_fmodifier(&fcu->modifiers, (FModifier *)value.data);
668 }
669
rna_FCurve_modifiers_new(FCurve * fcu,int type)670 static FModifier *rna_FCurve_modifiers_new(FCurve *fcu, int type)
671 {
672 return add_fmodifier(&fcu->modifiers, type, fcu);
673 }
674
rna_FCurve_modifiers_remove(FCurve * fcu,ReportList * reports,PointerRNA * fcm_ptr)675 static void rna_FCurve_modifiers_remove(FCurve *fcu, ReportList *reports, PointerRNA *fcm_ptr)
676 {
677 FModifier *fcm = fcm_ptr->data;
678 if (BLI_findindex(&fcu->modifiers, fcm) == -1) {
679 BKE_reportf(reports, RPT_ERROR, "F-Curve modifier '%s' not found in F-Curve", fcm->name);
680 return;
681 }
682
683 remove_fmodifier(&fcu->modifiers, fcm);
684 RNA_POINTER_INVALIDATE(fcm_ptr);
685 }
686
rna_FModifier_active_set(PointerRNA * ptr,bool UNUSED (value))687 static void rna_FModifier_active_set(PointerRNA *ptr, bool UNUSED(value))
688 {
689 FModifier *fcm = (FModifier *)ptr->data;
690
691 /* don't toggle, always switch on */
692 fcm->flag |= FMODIFIER_FLAG_ACTIVE;
693 }
694
rna_FModifier_start_frame_set(PointerRNA * ptr,float value)695 static void rna_FModifier_start_frame_set(PointerRNA *ptr, float value)
696 {
697 FModifier *fcm = (FModifier *)ptr->data;
698
699 CLAMP(value, MINAFRAMEF, MAXFRAMEF);
700 fcm->sfra = value;
701
702 /* XXX: maintain old offset? */
703 if (fcm->sfra >= fcm->efra) {
704 fcm->efra = fcm->sfra;
705 }
706 }
707
rna_FModifier_end_frame_set(PointerRNA * ptr,float value)708 static void rna_FModifier_end_frame_set(PointerRNA *ptr, float value)
709 {
710 FModifier *fcm = (FModifier *)ptr->data;
711
712 CLAMP(value, MINAFRAMEF, MAXFRAMEF);
713 fcm->efra = value;
714
715 /* XXX: maintain old offset? */
716 if (fcm->efra <= fcm->sfra) {
717 fcm->sfra = fcm->efra;
718 }
719 }
720
rna_FModifier_start_frame_range(PointerRNA * UNUSED (ptr),float * min,float * max,float * UNUSED (softmin),float * UNUSED (softmax))721 static void rna_FModifier_start_frame_range(PointerRNA *UNUSED(ptr),
722 float *min,
723 float *max,
724 float *UNUSED(softmin),
725 float *UNUSED(softmax))
726 {
727 // FModifier *fcm = (FModifier *)ptr->data;
728
729 /* Technically, "sfra <= efra" must hold; however, we can't strictly enforce that,
730 * or else it becomes tricky to adjust the range, see: T36844.
731 *
732 * NOTE: we do not set soft-limits on lower bounds, as it's too confusing when you
733 * can't easily use the slider to set things here
734 */
735 *min = MINAFRAMEF;
736 *max = MAXFRAMEF;
737 }
738
rna_FModifier_end_frame_range(PointerRNA * ptr,float * min,float * max,float * softmin,float * softmax)739 static void rna_FModifier_end_frame_range(
740 PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
741 {
742 FModifier *fcm = (FModifier *)ptr->data;
743
744 /* Technically, "sfra <= efra" must hold; however, we can't strictly enforce that,
745 * or else it becomes tricky to adjust the range, see: T36844. */
746 *min = MINAFRAMEF;
747 *softmin = (fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) ? fcm->sfra : MINAFRAMEF;
748
749 *softmax = MAXFRAMEF;
750 *max = MAXFRAMEF;
751 }
752
rna_FModifier_blending_range(PointerRNA * ptr,float * min,float * max,float * UNUSED (softmin),float * UNUSED (softmax))753 static void rna_FModifier_blending_range(
754 PointerRNA *ptr, float *min, float *max, float *UNUSED(softmin), float *UNUSED(softmax))
755 {
756 FModifier *fcm = (FModifier *)ptr->data;
757
758 *min = 0.0f;
759 *max = fcm->efra - fcm->sfra;
760 }
761
rna_FModifier_update(Main * bmain,Scene * UNUSED (scene),PointerRNA * ptr)762 static void rna_FModifier_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
763 {
764 ID *id = ptr->owner_id;
765 FModifier *fcm = (FModifier *)ptr->data;
766
767 if (fcm->curve && fcm->type == FMODIFIER_TYPE_CYCLES) {
768 calchandles_fcurve(fcm->curve);
769 }
770
771 rna_tag_animation_update(bmain, id);
772 }
773
rna_FModifier_verify_data_update(Main * bmain,Scene * scene,PointerRNA * ptr)774 static void rna_FModifier_verify_data_update(Main *bmain, Scene *scene, PointerRNA *ptr)
775 {
776 FModifier *fcm = (FModifier *)ptr->data;
777 const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
778
779 /* call the verify callback on the modifier if applicable */
780 if (fmi && fmi->verify_data) {
781 fmi->verify_data(fcm);
782 }
783
784 rna_FModifier_update(bmain, scene, ptr);
785 }
786
rna_FModifier_active_update(Main * bmain,Scene * scene,PointerRNA * ptr)787 static void rna_FModifier_active_update(Main *bmain, Scene *scene, PointerRNA *ptr)
788 {
789 FModifier *fm, *fmo = (FModifier *)ptr->data;
790
791 /* clear active state of other FModifiers in this list */
792 for (fm = fmo->prev; fm; fm = fm->prev) {
793 fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
794 }
795 for (fm = fmo->next; fm; fm = fm->next) {
796 fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
797 }
798
799 rna_FModifier_update(bmain, scene, ptr);
800 }
801
rna_FModifierGenerator_coefficients_get_length(PointerRNA * ptr,int length[RNA_MAX_ARRAY_DIMENSION])802 static int rna_FModifierGenerator_coefficients_get_length(PointerRNA *ptr,
803 int length[RNA_MAX_ARRAY_DIMENSION])
804 {
805 FModifier *fcm = (FModifier *)ptr->data;
806 FMod_Generator *gen = fcm->data;
807
808 if (gen) {
809 length[0] = gen->arraysize;
810 }
811 else {
812 length[0] = 100; /* for raw_access, untested */
813 }
814
815 return length[0];
816 }
817
rna_FModifierGenerator_coefficients_get(PointerRNA * ptr,float * values)818 static void rna_FModifierGenerator_coefficients_get(PointerRNA *ptr, float *values)
819 {
820 FModifier *fcm = (FModifier *)ptr->data;
821 FMod_Generator *gen = fcm->data;
822 memcpy(values, gen->coefficients, gen->arraysize * sizeof(float));
823 }
824
rna_FModifierGenerator_coefficients_set(PointerRNA * ptr,const float * values)825 static void rna_FModifierGenerator_coefficients_set(PointerRNA *ptr, const float *values)
826 {
827 FModifier *fcm = (FModifier *)ptr->data;
828 FMod_Generator *gen = fcm->data;
829 memcpy(gen->coefficients, values, gen->arraysize * sizeof(float));
830 }
831
rna_FModifierLimits_minx_set(PointerRNA * ptr,float value)832 static void rna_FModifierLimits_minx_set(PointerRNA *ptr, float value)
833 {
834 FModifier *fcm = (FModifier *)ptr->data;
835 FMod_Limits *data = fcm->data;
836
837 data->rect.xmin = value;
838
839 if (data->rect.xmin >= data->rect.xmax) {
840 data->rect.xmax = data->rect.xmin;
841 }
842 }
843
rna_FModifierLimits_maxx_set(PointerRNA * ptr,float value)844 static void rna_FModifierLimits_maxx_set(PointerRNA *ptr, float value)
845 {
846 FModifier *fcm = (FModifier *)ptr->data;
847 FMod_Limits *data = fcm->data;
848
849 data->rect.xmax = value;
850
851 if (data->rect.xmax <= data->rect.xmin) {
852 data->rect.xmin = data->rect.xmax;
853 }
854 }
855
rna_FModifierLimits_miny_set(PointerRNA * ptr,float value)856 static void rna_FModifierLimits_miny_set(PointerRNA *ptr, float value)
857 {
858 FModifier *fcm = (FModifier *)ptr->data;
859 FMod_Limits *data = fcm->data;
860
861 data->rect.ymin = value;
862
863 if (data->rect.ymin >= data->rect.ymax) {
864 data->rect.ymax = data->rect.ymin;
865 }
866 }
867
rna_FModifierLimits_maxy_set(PointerRNA * ptr,float value)868 static void rna_FModifierLimits_maxy_set(PointerRNA *ptr, float value)
869 {
870 FModifier *fcm = (FModifier *)ptr->data;
871 FMod_Limits *data = fcm->data;
872
873 data->rect.ymax = value;
874
875 if (data->rect.ymax <= data->rect.ymin) {
876 data->rect.ymin = data->rect.ymax;
877 }
878 }
879
rna_FModifierLimits_minx_range(PointerRNA * UNUSED (ptr),float * min,float * max,float * UNUSED (softmin),float * UNUSED (softmax))880 static void rna_FModifierLimits_minx_range(PointerRNA *UNUSED(ptr),
881 float *min,
882 float *max,
883 float *UNUSED(softmin),
884 float *UNUSED(softmax))
885 {
886 // FModifier *fcm = (FModifier *)ptr->data;
887 // FMod_Limits *data = fcm->data;
888
889 /* No soft-limits on lower bound -
890 * it's too confusing when you can't easily use the slider to set things here. */
891 *min = MINAFRAMEF;
892 *max = MAXFRAMEF;
893 }
894
rna_FModifierLimits_maxx_range(PointerRNA * ptr,float * min,float * max,float * softmin,float * softmax)895 static void rna_FModifierLimits_maxx_range(
896 PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
897 {
898 FModifier *fcm = (FModifier *)ptr->data;
899 FMod_Limits *data = fcm->data;
900
901 *min = MINAFRAMEF;
902 *softmin = (data->flag & FCM_LIMIT_XMIN) ? data->rect.xmin : MINAFRAMEF;
903
904 *softmax = MAXFRAMEF;
905 *max = MAXFRAMEF;
906 }
907
rna_FModifierLimits_miny_range(PointerRNA * UNUSED (ptr),float * min,float * max,float * UNUSED (softmin),float * UNUSED (softmax))908 static void rna_FModifierLimits_miny_range(PointerRNA *UNUSED(ptr),
909 float *min,
910 float *max,
911 float *UNUSED(softmin),
912 float *UNUSED(softmax))
913 {
914 // FModifier *fcm = (FModifier *)ptr->data;
915 // FMod_Limits *data = fcm->data;
916
917 /* No soft-limits on lower bound -
918 * it's too confusing when you can't easily use the slider to set things here. */
919 *min = -FLT_MAX;
920 *max = FLT_MAX;
921 }
922
rna_FModifierLimits_maxy_range(PointerRNA * ptr,float * min,float * max,float * softmin,float * softmax)923 static void rna_FModifierLimits_maxy_range(
924 PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
925 {
926 FModifier *fcm = (FModifier *)ptr->data;
927 FMod_Limits *data = fcm->data;
928
929 *min = -FLT_MAX;
930 *softmin = (data->flag & FCM_LIMIT_YMIN) ? data->rect.ymin : -FLT_MAX;
931
932 *softmax = FLT_MAX;
933 *max = FLT_MAX;
934 }
935
rna_FModifierStepped_start_frame_range(PointerRNA * ptr,float * min,float * max,float * UNUSED (softmin),float * UNUSED (softmax))936 static void rna_FModifierStepped_start_frame_range(
937 PointerRNA *ptr, float *min, float *max, float *UNUSED(softmin), float *UNUSED(softmax))
938 {
939 FModifier *fcm = (FModifier *)ptr->data;
940 FMod_Stepped *data = fcm->data;
941
942 *min = MINAFRAMEF;
943 *max = (data->flag & FCM_STEPPED_NO_AFTER) ? data->end_frame : MAXFRAMEF;
944 }
945
rna_FModifierStepped_end_frame_range(PointerRNA * ptr,float * min,float * max,float * UNUSED (softmin),float * UNUSED (softmax))946 static void rna_FModifierStepped_end_frame_range(
947 PointerRNA *ptr, float *min, float *max, float *UNUSED(softmin), float *UNUSED(softmax))
948 {
949 FModifier *fcm = (FModifier *)ptr->data;
950 FMod_Stepped *data = fcm->data;
951
952 *min = (data->flag & FCM_STEPPED_NO_BEFORE) ? data->start_frame : MINAFRAMEF;
953 *max = MAXFRAMEF;
954 }
955
rna_FModifierStepped_frame_start_set(PointerRNA * ptr,float value)956 static void rna_FModifierStepped_frame_start_set(PointerRNA *ptr, float value)
957 {
958 FModifier *fcm = (FModifier *)ptr->data;
959 FMod_Stepped *data = fcm->data;
960
961 float prop_clamp_min = -FLT_MAX, prop_clamp_max = FLT_MAX, prop_soft_min, prop_soft_max;
962 rna_FModifierStepped_start_frame_range(
963 ptr, &prop_clamp_min, &prop_clamp_max, &prop_soft_min, &prop_soft_max);
964 value = CLAMPIS(value, prop_clamp_min, prop_clamp_max);
965
966 /* Need to set both step-data's start/end and the start/end on the base-data,
967 * or else Restrict-Range doesn't work due to RNA-property shadowing (T52009)
968 */
969 data->start_frame = value;
970 fcm->sfra = value;
971 }
972
rna_FModifierStepped_frame_end_set(PointerRNA * ptr,float value)973 static void rna_FModifierStepped_frame_end_set(PointerRNA *ptr, float value)
974 {
975 FModifier *fcm = (FModifier *)ptr->data;
976 FMod_Stepped *data = fcm->data;
977
978 float prop_clamp_min = -FLT_MAX, prop_clamp_max = FLT_MAX, prop_soft_min, prop_soft_max;
979 rna_FModifierStepped_end_frame_range(
980 ptr, &prop_clamp_min, &prop_clamp_max, &prop_soft_min, &prop_soft_max);
981 value = CLAMPIS(value, prop_clamp_min, prop_clamp_max);
982
983 /* Need to set both step-data's start/end and the start/end on the base-data,
984 * or else Restrict-Range doesn't work due to RNA-property shadowing (T52009)
985 */
986 data->end_frame = value;
987 fcm->efra = value;
988 }
989
rna_FKeyframe_points_insert(ID * id,FCurve * fcu,Main * bmain,float frame,float value,int keyframe_type,int flag)990 static BezTriple *rna_FKeyframe_points_insert(
991 ID *id, FCurve *fcu, Main *bmain, float frame, float value, int keyframe_type, int flag)
992 {
993 int index = insert_vert_fcurve(
994 fcu, frame, value, (char)keyframe_type, flag | INSERTKEY_NO_USERPREF);
995
996 if ((fcu->bezt) && (index >= 0)) {
997 rna_tag_animation_update(bmain, id);
998
999 return fcu->bezt + index;
1000 }
1001
1002 return NULL;
1003 }
1004
rna_FKeyframe_points_add(ID * id,FCurve * fcu,Main * bmain,int tot)1005 static void rna_FKeyframe_points_add(ID *id, FCurve *fcu, Main *bmain, int tot)
1006 {
1007 if (tot > 0) {
1008 BezTriple *bezt;
1009
1010 fcu->bezt = MEM_recallocN(fcu->bezt, sizeof(BezTriple) * (fcu->totvert + tot));
1011
1012 bezt = fcu->bezt + fcu->totvert;
1013 fcu->totvert += tot;
1014
1015 while (tot--) {
1016 /* defaults, no userprefs gives predictable results for API */
1017 bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
1018 bezt->ipo = BEZT_IPO_BEZ;
1019 bezt->h1 = bezt->h2 = HD_AUTO_ANIM;
1020 bezt++;
1021 }
1022
1023 rna_tag_animation_update(bmain, id);
1024 }
1025 }
1026
rna_FKeyframe_points_remove(ID * id,FCurve * fcu,Main * bmain,ReportList * reports,PointerRNA * bezt_ptr,bool do_fast)1027 static void rna_FKeyframe_points_remove(
1028 ID *id, FCurve *fcu, Main *bmain, ReportList *reports, PointerRNA *bezt_ptr, bool do_fast)
1029 {
1030 BezTriple *bezt = bezt_ptr->data;
1031 int index = (int)(bezt - fcu->bezt);
1032 if (index < 0 || index >= fcu->totvert) {
1033 BKE_report(reports, RPT_ERROR, "Keyframe not in F-Curve");
1034 return;
1035 }
1036
1037 delete_fcurve_key(fcu, index, !do_fast);
1038 RNA_POINTER_INVALIDATE(bezt_ptr);
1039
1040 rna_tag_animation_update(bmain, id);
1041 }
1042
rna_FModifierEnvelope_points_add(ID * id,FModifier * fmod,Main * bmain,ReportList * reports,float frame)1043 static FCM_EnvelopeData *rna_FModifierEnvelope_points_add(
1044 ID *id, FModifier *fmod, Main *bmain, ReportList *reports, float frame)
1045 {
1046 FCM_EnvelopeData fed;
1047 FMod_Envelope *env = (FMod_Envelope *)fmod->data;
1048 int i;
1049
1050 rna_tag_animation_update(bmain, id);
1051
1052 /* init template data */
1053 fed.min = -1.0f;
1054 fed.max = 1.0f;
1055 fed.time = frame;
1056 fed.f1 = fed.f2 = 0;
1057
1058 if (env->data) {
1059 bool exists;
1060 i = BKE_fcm_envelope_find_index(env->data, frame, env->totvert, &exists);
1061 if (exists) {
1062 BKE_reportf(reports, RPT_ERROR, "Already a control point at frame %.6f", frame);
1063 return NULL;
1064 }
1065
1066 /* realloc memory for extra point */
1067 env->data = (FCM_EnvelopeData *)MEM_reallocN((void *)env->data,
1068 (env->totvert + 1) * sizeof(FCM_EnvelopeData));
1069
1070 /* move the points after the added point */
1071 if (i < env->totvert) {
1072 memmove(env->data + i + 1, env->data + i, (env->totvert - i) * sizeof(FCM_EnvelopeData));
1073 }
1074
1075 env->totvert++;
1076 }
1077 else {
1078 env->data = MEM_mallocN(sizeof(FCM_EnvelopeData), "FCM_EnvelopeData");
1079 env->totvert = 1;
1080 i = 0;
1081 }
1082
1083 /* add point to paste at index i */
1084 *(env->data + i) = fed;
1085 return (env->data + i);
1086 }
1087
rna_FModifierEnvelope_points_remove(ID * id,FModifier * fmod,Main * bmain,ReportList * reports,PointerRNA * point)1088 static void rna_FModifierEnvelope_points_remove(
1089 ID *id, FModifier *fmod, Main *bmain, ReportList *reports, PointerRNA *point)
1090 {
1091 FCM_EnvelopeData *cp = point->data;
1092 FMod_Envelope *env = (FMod_Envelope *)fmod->data;
1093
1094 int index = (int)(cp - env->data);
1095
1096 /* test point is in range */
1097 if (index < 0 || index >= env->totvert) {
1098 BKE_report(reports, RPT_ERROR, "Control point not in Envelope F-Modifier");
1099 return;
1100 }
1101
1102 rna_tag_animation_update(bmain, id);
1103
1104 if (env->totvert > 1) {
1105 /* move data after the removed point */
1106
1107 memmove(env->data + index,
1108 env->data + (index + 1),
1109 sizeof(FCM_EnvelopeData) * ((env->totvert - index) - 1));
1110
1111 /* realloc smaller array */
1112 env->totvert--;
1113 env->data = (FCM_EnvelopeData *)MEM_reallocN((void *)env->data,
1114 (env->totvert) * sizeof(FCM_EnvelopeData));
1115 }
1116 else {
1117 /* just free array, since the only vert was deleted */
1118 if (env->data) {
1119 MEM_freeN(env->data);
1120 env->data = NULL;
1121 }
1122 env->totvert = 0;
1123 }
1124 RNA_POINTER_INVALIDATE(point);
1125 }
1126
rna_Keyframe_update(Main * bmain,Scene * UNUSED (scene),PointerRNA * ptr)1127 static void rna_Keyframe_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1128 {
1129 rna_tag_animation_update(bmain, ptr->owner_id);
1130 }
1131
1132 #else
1133
rna_def_fmodifier_generator(BlenderRNA * brna)1134 static void rna_def_fmodifier_generator(BlenderRNA *brna)
1135 {
1136 StructRNA *srna;
1137 PropertyRNA *prop;
1138
1139 static const EnumPropertyItem generator_mode_items[] = {
1140 {FCM_GENERATOR_POLYNOMIAL, "POLYNOMIAL", 0, "Expanded Polynomial", ""},
1141 {FCM_GENERATOR_POLYNOMIAL_FACTORISED,
1142 "POLYNOMIAL_FACTORISED",
1143 0,
1144 "Factorized Polynomial",
1145 ""},
1146 {0, NULL, 0, NULL, NULL},
1147 };
1148
1149 srna = RNA_def_struct(brna, "FModifierGenerator", "FModifier");
1150 RNA_def_struct_ui_text(
1151 srna, "Generator F-Modifier", "Deterministically generate values for the modified F-Curve");
1152 RNA_def_struct_sdna_from(srna, "FMod_Generator", "data");
1153
1154 /* define common props */
1155 prop = RNA_def_property(srna, "use_additive", PROP_BOOLEAN, PROP_NONE);
1156 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
1157 RNA_def_property_ui_text(prop,
1158 "Additive",
1159 "Values generated by this modifier are applied on top of "
1160 "the existing values instead of overwriting them");
1161 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1162
1163 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
1164 RNA_def_property_enum_items(prop, generator_mode_items);
1165 RNA_def_property_ui_text(prop, "Mode", "Type of generator to use");
1166 RNA_def_property_update(
1167 prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_verify_data_update");
1168
1169 /* order of the polynomial */
1170 prop = RNA_def_property(srna, "poly_order", PROP_INT, PROP_NONE);
1171 RNA_def_property_ui_text(
1172 prop,
1173 "Polynomial Order",
1174 "The highest power of 'x' for this polynomial (number of coefficients - 1)");
1175 RNA_def_property_range(prop, 1, 100);
1176 RNA_def_property_update(
1177 prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_verify_data_update");
1178
1179 /* coefficients array */
1180 prop = RNA_def_property(srna, "coefficients", PROP_FLOAT, PROP_NONE);
1181 RNA_def_property_array(prop, 32);
1182 RNA_def_property_flag(prop, PROP_DYNAMIC);
1183 RNA_def_property_dynamic_array_funcs(prop, "rna_FModifierGenerator_coefficients_get_length");
1184 RNA_def_property_float_funcs(prop,
1185 "rna_FModifierGenerator_coefficients_get",
1186 "rna_FModifierGenerator_coefficients_set",
1187 NULL);
1188 RNA_def_property_ui_text(
1189 prop, "Coefficients", "Coefficients for 'x' (starting from lowest power of x^0)");
1190 }
1191
1192 /* --------- */
1193
rna_def_fmodifier_function_generator(BlenderRNA * brna)1194 static void rna_def_fmodifier_function_generator(BlenderRNA *brna)
1195 {
1196 StructRNA *srna;
1197 PropertyRNA *prop;
1198
1199 static const EnumPropertyItem prop_type_items[] = {
1200 {0, "SIN", 0, "Sine", ""},
1201 {1, "COS", 0, "Cosine", ""},
1202 {2, "TAN", 0, "Tangent", ""},
1203 {3, "SQRT", 0, "Square Root", ""},
1204 {4, "LN", 0, "Natural Logarithm", ""},
1205 {5, "SINC", 0, "Normalized Sine", "sin(x) / x"},
1206 {0, NULL, 0, NULL, NULL},
1207 };
1208
1209 srna = RNA_def_struct(brna, "FModifierFunctionGenerator", "FModifier");
1210 RNA_def_struct_ui_text(
1211 srna, "Built-In Function F-Modifier", "Generate values using a Built-In Function");
1212 RNA_def_struct_sdna_from(srna, "FMod_FunctionGenerator", "data");
1213
1214 /* coefficients */
1215 prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
1216 RNA_def_property_ui_text(
1217 prop, "Amplitude", "Scale factor determining the maximum/minimum values");
1218 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1219
1220 prop = RNA_def_property(srna, "phase_multiplier", PROP_FLOAT, PROP_NONE);
1221 RNA_def_property_ui_text(
1222 prop, "Phase Multiplier", "Scale factor determining the 'speed' of the function");
1223 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1224
1225 prop = RNA_def_property(srna, "phase_offset", PROP_FLOAT, PROP_NONE);
1226 RNA_def_property_ui_text(prop, "Phase Offset", "Constant factor to offset time by for function");
1227 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1228
1229 prop = RNA_def_property(srna, "value_offset", PROP_FLOAT, PROP_NONE);
1230 RNA_def_property_ui_text(prop, "Value Offset", "Constant factor to offset values by");
1231 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1232
1233 /* flags */
1234 prop = RNA_def_property(srna, "use_additive", PROP_BOOLEAN, PROP_NONE);
1235 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
1236 RNA_def_property_ui_text(prop,
1237 "Additive",
1238 "Values generated by this modifier are applied on top of "
1239 "the existing values instead of overwriting them");
1240 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1241
1242 prop = RNA_def_property(srna, "function_type", PROP_ENUM, PROP_NONE);
1243 RNA_def_property_enum_sdna(prop, NULL, "type");
1244 RNA_def_property_enum_items(prop, prop_type_items);
1245 RNA_def_property_ui_text(prop, "Type", "Type of built-in function to use");
1246 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1247 }
1248
1249 /* --------- */
1250
rna_def_fmodifier_envelope_ctrl(BlenderRNA * brna)1251 static void rna_def_fmodifier_envelope_ctrl(BlenderRNA *brna)
1252 {
1253 StructRNA *srna;
1254 PropertyRNA *prop;
1255
1256 srna = RNA_def_struct(brna, "FModifierEnvelopeControlPoint", NULL);
1257 RNA_def_struct_ui_text(srna, "Envelope Control Point", "Control point for envelope F-Modifier");
1258 RNA_def_struct_sdna(srna, "FCM_EnvelopeData");
1259
1260 /* min/max extents
1261 * - for now, these are allowed to go past each other, so that we can have inverted action
1262 * - technically, the range is limited by the settings in the envelope-modifier data, not here...
1263 */
1264 prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
1265 RNA_def_property_float_sdna(prop, NULL, "min");
1266 RNA_def_property_ui_text(prop, "Minimum Value", "Lower bound of envelope at this control-point");
1267 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1268
1269 prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
1270 RNA_def_property_float_sdna(prop, NULL, "max");
1271 RNA_def_property_ui_text(prop, "Maximum Value", "Upper bound of envelope at this control-point");
1272 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1273
1274 /* Frame */
1275 prop = RNA_def_property(srna, "frame", PROP_FLOAT, PROP_TIME);
1276 RNA_def_property_float_sdna(prop, NULL, "time");
1277 RNA_def_property_ui_text(prop, "Frame", "Frame this control-point occurs on");
1278 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1279
1280 /* TODO: */
1281 /* - selection flags (not implemented in UI yet though) */
1282 }
1283
rna_def_fmodifier_envelope_control_points(BlenderRNA * brna,PropertyRNA * cprop)1284 static void rna_def_fmodifier_envelope_control_points(BlenderRNA *brna, PropertyRNA *cprop)
1285 {
1286 StructRNA *srna;
1287
1288 FunctionRNA *func;
1289 PropertyRNA *parm;
1290
1291 RNA_def_property_srna(cprop, "FModifierEnvelopeControlPoints");
1292 srna = RNA_def_struct(brna, "FModifierEnvelopeControlPoints", NULL);
1293 RNA_def_struct_sdna(srna, "FModifier");
1294
1295 RNA_def_struct_ui_text(
1296 srna, "Control Points", "Control points defining the shape of the envelope");
1297
1298 func = RNA_def_function(srna, "add", "rna_FModifierEnvelope_points_add");
1299 RNA_def_function_ui_description(func, "Add a control point to a FModifierEnvelope");
1300 RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
1301 parm = RNA_def_float(func,
1302 "frame",
1303 0.0f,
1304 -FLT_MAX,
1305 FLT_MAX,
1306 "",
1307 "Frame to add this control-point",
1308 -FLT_MAX,
1309 FLT_MAX);
1310 RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1311 parm = RNA_def_pointer(
1312 func, "point", "FModifierEnvelopeControlPoint", "", "Newly created control-point");
1313 RNA_def_function_return(func, parm);
1314
1315 func = RNA_def_function(srna, "remove", "rna_FModifierEnvelope_points_remove");
1316 RNA_def_function_ui_description(func, "Remove a control-point from an FModifierEnvelope");
1317 RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
1318 parm = RNA_def_pointer(
1319 func, "point", "FModifierEnvelopeControlPoint", "", "Control-point to remove");
1320 RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1321 }
1322
rna_def_fmodifier_envelope(BlenderRNA * brna)1323 static void rna_def_fmodifier_envelope(BlenderRNA *brna)
1324 {
1325 StructRNA *srna;
1326 PropertyRNA *prop;
1327
1328 srna = RNA_def_struct(brna, "FModifierEnvelope", "FModifier");
1329 RNA_def_struct_ui_text(srna, "Envelope F-Modifier", "Scale the values of the modified F-Curve");
1330 RNA_def_struct_sdna_from(srna, "FMod_Envelope", "data");
1331
1332 /* Collections */
1333 prop = RNA_def_property(srna, "control_points", PROP_COLLECTION, PROP_NONE);
1334 RNA_def_property_collection_sdna(prop, NULL, "data", "totvert");
1335 RNA_def_property_struct_type(prop, "FModifierEnvelopeControlPoint");
1336 RNA_def_property_ui_text(
1337 prop, "Control Points", "Control points defining the shape of the envelope");
1338 rna_def_fmodifier_envelope_control_points(brna, prop);
1339
1340 /* Range Settings */
1341 prop = RNA_def_property(srna, "reference_value", PROP_FLOAT, PROP_NONE);
1342 RNA_def_property_float_sdna(prop, NULL, "midval");
1343 RNA_def_property_ui_text(
1344 prop, "Reference Value", "Value that envelope's influence is centered around / based on");
1345 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1346
1347 prop = RNA_def_property(srna, "default_min", PROP_FLOAT, PROP_NONE);
1348 RNA_def_property_float_sdna(prop, NULL, "min");
1349 RNA_def_property_ui_text(
1350 prop, "Default Minimum", "Lower distance from Reference Value for 1:1 default influence");
1351 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1352
1353 prop = RNA_def_property(srna, "default_max", PROP_FLOAT, PROP_NONE);
1354 RNA_def_property_float_sdna(prop, NULL, "max");
1355 RNA_def_property_ui_text(
1356 prop, "Default Maximum", "Upper distance from Reference Value for 1:1 default influence");
1357 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1358 }
1359
1360 /* --------- */
1361
rna_def_fmodifier_cycles(BlenderRNA * brna)1362 static void rna_def_fmodifier_cycles(BlenderRNA *brna)
1363 {
1364 StructRNA *srna;
1365 PropertyRNA *prop;
1366
1367 static const EnumPropertyItem prop_type_items[] = {
1368 {FCM_EXTRAPOLATE_NONE, "NONE", 0, "No Cycles", "Don't do anything"},
1369 {FCM_EXTRAPOLATE_CYCLIC, "REPEAT", 0, "Repeat Motion", "Repeat keyframe range as-is"},
1370 {FCM_EXTRAPOLATE_CYCLIC_OFFSET,
1371 "REPEAT_OFFSET",
1372 0,
1373 "Repeat with Offset",
1374 "Repeat keyframe range, but with offset based on gradient between "
1375 "start and end values"},
1376 {FCM_EXTRAPOLATE_MIRROR,
1377 "MIRROR",
1378 0,
1379 "Repeat Mirrored",
1380 "Alternate between forward and reverse playback of keyframe range"},
1381 {0, NULL, 0, NULL, NULL},
1382 };
1383
1384 srna = RNA_def_struct(brna, "FModifierCycles", "FModifier");
1385 RNA_def_struct_ui_text(srna, "Cycles F-Modifier", "Repeat the values of the modified F-Curve");
1386 RNA_def_struct_sdna_from(srna, "FMod_Cycles", "data");
1387
1388 /* before */
1389 prop = RNA_def_property(srna, "mode_before", PROP_ENUM, PROP_NONE);
1390 RNA_def_property_enum_sdna(prop, NULL, "before_mode");
1391 RNA_def_property_enum_items(prop, prop_type_items);
1392 RNA_def_property_ui_text(prop, "Before Mode", "Cycling mode to use before first keyframe");
1393 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1394
1395 prop = RNA_def_property(srna, "cycles_before", PROP_INT, PROP_NONE);
1396 RNA_def_property_int_sdna(prop, NULL, "before_cycles");
1397 RNA_def_property_ui_text(
1398 prop,
1399 "Before Cycles",
1400 "Maximum number of cycles to allow before first keyframe (0 = infinite)");
1401 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1402
1403 /* after */
1404 prop = RNA_def_property(srna, "mode_after", PROP_ENUM, PROP_NONE);
1405 RNA_def_property_enum_sdna(prop, NULL, "after_mode");
1406 RNA_def_property_enum_items(prop, prop_type_items);
1407 RNA_def_property_ui_text(prop, "After Mode", "Cycling mode to use after last keyframe");
1408 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1409
1410 prop = RNA_def_property(srna, "cycles_after", PROP_INT, PROP_NONE);
1411 RNA_def_property_int_sdna(prop, NULL, "after_cycles");
1412 RNA_def_property_ui_text(prop,
1413 "After Cycles",
1414 "Maximum number of cycles to allow after last keyframe (0 = infinite)");
1415 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1416 }
1417
1418 /* --------- */
1419
rna_def_fmodifier_python(BlenderRNA * brna)1420 static void rna_def_fmodifier_python(BlenderRNA *brna)
1421 {
1422 StructRNA *srna;
1423 /*PropertyRNA *prop; */
1424
1425 srna = RNA_def_struct(brna, "FModifierPython", "FModifier");
1426 RNA_def_struct_ui_text(
1427 srna, "Python F-Modifier", "Perform user-defined operation on the modified F-Curve");
1428 RNA_def_struct_sdna_from(srna, "FMod_Python", "data");
1429 }
1430
1431 /* --------- */
1432
rna_def_fmodifier_limits(BlenderRNA * brna)1433 static void rna_def_fmodifier_limits(BlenderRNA *brna)
1434 {
1435 StructRNA *srna;
1436 PropertyRNA *prop;
1437
1438 srna = RNA_def_struct(brna, "FModifierLimits", "FModifier");
1439 RNA_def_struct_ui_text(
1440 srna, "Limit F-Modifier", "Limit the time/value ranges of the modified F-Curve");
1441 RNA_def_struct_sdna_from(srna, "FMod_Limits", "data");
1442
1443 prop = RNA_def_property(srna, "use_min_x", PROP_BOOLEAN, PROP_NONE);
1444 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMIN);
1445 RNA_def_property_ui_text(prop, "Minimum X", "Use the minimum X value");
1446 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1447
1448 prop = RNA_def_property(srna, "use_min_y", PROP_BOOLEAN, PROP_NONE);
1449 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMIN);
1450 RNA_def_property_ui_text(prop, "Minimum Y", "Use the minimum Y value");
1451 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1452
1453 prop = RNA_def_property(srna, "use_max_x", PROP_BOOLEAN, PROP_NONE);
1454 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMAX);
1455 RNA_def_property_ui_text(prop, "Maximum X", "Use the maximum X value");
1456 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1457
1458 prop = RNA_def_property(srna, "use_max_y", PROP_BOOLEAN, PROP_NONE);
1459 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMAX);
1460 RNA_def_property_ui_text(prop, "Maximum Y", "Use the maximum Y value");
1461 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1462
1463 prop = RNA_def_property(srna, "min_x", PROP_FLOAT, PROP_NONE);
1464 RNA_def_property_float_sdna(prop, NULL, "rect.xmin");
1465 RNA_def_property_float_funcs(
1466 prop, NULL, "rna_FModifierLimits_minx_set", "rna_FModifierLimits_minx_range");
1467 RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow");
1468 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1469
1470 prop = RNA_def_property(srna, "min_y", PROP_FLOAT, PROP_NONE);
1471 RNA_def_property_float_sdna(prop, NULL, "rect.ymin");
1472 RNA_def_property_float_funcs(
1473 prop, NULL, "rna_FModifierLimits_miny_set", "rna_FModifierLimits_miny_range");
1474 RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow");
1475 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1476
1477 prop = RNA_def_property(srna, "max_x", PROP_FLOAT, PROP_NONE);
1478 RNA_def_property_float_sdna(prop, NULL, "rect.xmax");
1479 RNA_def_property_float_funcs(
1480 prop, NULL, "rna_FModifierLimits_maxx_set", "rna_FModifierLimits_maxx_range");
1481 RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow");
1482 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1483
1484 prop = RNA_def_property(srna, "max_y", PROP_FLOAT, PROP_NONE);
1485 RNA_def_property_float_sdna(prop, NULL, "rect.ymax");
1486 RNA_def_property_float_funcs(
1487 prop, NULL, "rna_FModifierLimits_maxy_set", "rna_FModifierLimits_maxy_range");
1488 RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow");
1489 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1490 }
1491
1492 /* --------- */
1493
rna_def_fmodifier_noise(BlenderRNA * brna)1494 static void rna_def_fmodifier_noise(BlenderRNA *brna)
1495 {
1496 StructRNA *srna;
1497 PropertyRNA *prop;
1498
1499 static const EnumPropertyItem prop_modification_items[] = {
1500 {FCM_NOISE_MODIF_REPLACE, "REPLACE", 0, "Replace", ""},
1501 {FCM_NOISE_MODIF_ADD, "ADD", 0, "Add", ""},
1502 {FCM_NOISE_MODIF_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
1503 {FCM_NOISE_MODIF_MULTIPLY, "MULTIPLY", 0, "Multiply", ""},
1504 {0, NULL, 0, NULL, NULL},
1505 };
1506
1507 srna = RNA_def_struct(brna, "FModifierNoise", "FModifier");
1508 RNA_def_struct_ui_text(srna, "Noise F-Modifier", "Give randomness to the modified F-Curve");
1509 RNA_def_struct_sdna_from(srna, "FMod_Noise", "data");
1510
1511 prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
1512 RNA_def_property_enum_sdna(prop, NULL, "modification");
1513 RNA_def_property_enum_items(prop, prop_modification_items);
1514 RNA_def_property_ui_text(prop, "Blend Type", "Method of modifying the existing F-Curve");
1515 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1516
1517 prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
1518 RNA_def_property_float_sdna(prop, NULL, "size");
1519 RNA_def_property_ui_text(prop, "Scale", "Scaling (in time) of the noise");
1520 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1521
1522 prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
1523 RNA_def_property_float_sdna(prop, NULL, "strength");
1524 RNA_def_property_ui_text(
1525 prop,
1526 "Strength",
1527 "Amplitude of the noise - the amount that it modifies the underlying curve");
1528 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1529
1530 prop = RNA_def_property(srna, "phase", PROP_FLOAT, PROP_NONE);
1531 RNA_def_property_float_sdna(prop, NULL, "phase");
1532 RNA_def_property_ui_text(prop, "Phase", "A random seed for the noise effect");
1533 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1534
1535 prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
1536 RNA_def_property_float_sdna(prop, NULL, "offset");
1537 RNA_def_property_ui_text(prop, "Offset", "Time offset for the noise effect");
1538 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1539
1540 prop = RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
1541 RNA_def_property_int_sdna(prop, NULL, "depth");
1542 RNA_def_property_ui_text(prop, "Depth", "Amount of fine level detail present in the noise");
1543 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1544 }
1545
1546 /* --------- */
1547
rna_def_fmodifier_stepped(BlenderRNA * brna)1548 static void rna_def_fmodifier_stepped(BlenderRNA *brna)
1549 {
1550 StructRNA *srna;
1551 PropertyRNA *prop;
1552
1553 srna = RNA_def_struct(brna, "FModifierStepped", "FModifier");
1554 RNA_def_struct_ui_text(
1555 srna,
1556 "Stepped Interpolation F-Modifier",
1557 "Hold each interpolated value from the F-Curve for several frames without "
1558 "changing the timing");
1559 RNA_def_struct_sdna_from(srna, "FMod_Stepped", "data");
1560
1561 /* properties */
1562 prop = RNA_def_property(srna, "frame_step", PROP_FLOAT, PROP_NONE);
1563 RNA_def_property_float_sdna(prop, NULL, "step_size");
1564 RNA_def_property_ui_text(prop, "Step Size", "Number of frames to hold each value");
1565 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1566
1567 prop = RNA_def_property(srna, "frame_offset", PROP_FLOAT, PROP_NONE);
1568 RNA_def_property_float_sdna(prop, NULL, "offset");
1569 RNA_def_property_ui_text(prop,
1570 "Offset",
1571 "Reference number of frames before frames get held "
1572 "(use to get hold for '1-3' vs '5-7' holding patterns)");
1573 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1574
1575 prop = RNA_def_property(srna, "use_frame_start", PROP_BOOLEAN, PROP_NONE);
1576 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_STEPPED_NO_BEFORE);
1577 RNA_def_property_ui_text(
1578 prop, "Use Start Frame", "Restrict modifier to only act after its 'start' frame");
1579 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1580
1581 prop = RNA_def_property(srna, "use_frame_end", PROP_BOOLEAN, PROP_NONE);
1582 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_STEPPED_NO_AFTER);
1583 RNA_def_property_ui_text(
1584 prop, "Use End Frame", "Restrict modifier to only act before its 'end' frame");
1585 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1586
1587 prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_NONE);
1588 RNA_def_property_float_sdna(prop, NULL, "start_frame");
1589 RNA_def_property_float_funcs(prop,
1590 NULL,
1591 "rna_FModifierStepped_frame_start_set",
1592 "rna_FModifierStepped_start_frame_range");
1593 RNA_def_property_ui_text(
1594 prop, "Start Frame", "Frame that modifier's influence starts (if applicable)");
1595 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1596
1597 prop = RNA_def_property(srna, "frame_end", PROP_FLOAT, PROP_NONE);
1598 RNA_def_property_float_sdna(prop, NULL, "end_frame");
1599 RNA_def_property_float_funcs(
1600 prop, NULL, "rna_FModifierStepped_frame_end_set", "rna_FModifierStepped_end_frame_range");
1601 RNA_def_property_ui_text(
1602 prop, "End Frame", "Frame that modifier's influence ends (if applicable)");
1603 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FModifier_update");
1604 }
1605
1606 /* --------- */
1607
rna_def_fmodifier(BlenderRNA * brna)1608 static void rna_def_fmodifier(BlenderRNA *brna)
1609 {
1610 StructRNA *srna;
1611 PropertyRNA *prop;
1612
1613 /* base struct definition */
1614 srna = RNA_def_struct(brna, "FModifier", NULL);
1615 RNA_def_struct_refine_func(srna, "rna_FModifierType_refine");
1616 RNA_def_struct_ui_text(srna, "F-Modifier", "Modifier for values of F-Curve");
1617
1618 # if 0 /* XXX not used yet */
1619 /* name */
1620 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1621 RNA_def_struct_name_property(srna, prop);
1622 RNA_def_property_ui_text(prop, "Name", "Short description of F-Curve Modifier");
1623 # endif /* XXX not used yet */
1624
1625 /* type */
1626 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1627 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1628 RNA_def_property_enum_items(prop, rna_enum_fmodifier_type_items);
1629 RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_ACTION);
1630 RNA_def_property_ui_text(prop, "Type", "F-Curve Modifier Type");
1631
1632 /* settings */
1633 prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
1634 RNA_def_property_flag(prop, PROP_NO_DEG_UPDATE);
1635 RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_EXPANDED);
1636 RNA_def_property_ui_text(prop, "Expanded", "F-Curve Modifier's panel is expanded in UI");
1637 RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
1638
1639 prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1640 RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_MUTED);
1641 RNA_def_property_ui_text(prop, "Muted", "Disable F-Curve Modifier evaluation");
1642 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1643 RNA_def_property_ui_icon(prop, ICON_CHECKBOX_HLT, -1);
1644
1645 prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
1646 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1647 RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", FMODIFIER_FLAG_DISABLED);
1648 RNA_def_property_ui_text(
1649 prop, "Disabled", "F-Curve Modifier has invalid settings and will not be evaluated");
1650 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1651
1652 /* TODO: setting this to true must ensure that all others in stack are turned off too... */
1653 prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1654 RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_ACTIVE);
1655 RNA_def_property_ui_text(prop, "Active", "F-Curve Modifier is the one being edited");
1656 RNA_def_property_boolean_funcs(prop, NULL, "rna_FModifier_active_set");
1657 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_active_update");
1658 RNA_def_property_ui_icon(prop, ICON_RADIOBUT_OFF, 1);
1659
1660 /* restricted range */
1661 prop = RNA_def_property(srna, "use_restricted_range", PROP_BOOLEAN, PROP_NONE);
1662 RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_RANGERESTRICT);
1663 RNA_def_property_ui_text(
1664 prop,
1665 "Restrict Frame Range",
1666 "F-Curve Modifier is only applied for the specified frame range to help "
1667 "mask off effects in order to chain them");
1668 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1669 RNA_def_property_ui_icon(
1670 prop, ICON_DISCLOSURE_TRI_RIGHT, 1); /* XXX: depends on UI implementation */
1671
1672 prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_NONE);
1673 RNA_def_property_float_sdna(prop, NULL, "sfra");
1674 RNA_def_property_float_funcs(
1675 prop, NULL, "rna_FModifier_start_frame_set", "rna_FModifier_start_frame_range");
1676 RNA_def_property_ui_text(
1677 prop,
1678 "Start Frame",
1679 "Frame that modifier's influence starts (if Restrict Frame Range is in use)");
1680 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1681
1682 prop = RNA_def_property(srna, "frame_end", PROP_FLOAT, PROP_NONE);
1683 RNA_def_property_float_sdna(prop, NULL, "efra");
1684 RNA_def_property_float_funcs(
1685 prop, NULL, "rna_FModifier_end_frame_set", "rna_FModifier_end_frame_range");
1686 RNA_def_property_ui_text(
1687 prop,
1688 "End Frame",
1689 "Frame that modifier's influence ends (if Restrict Frame Range is in use)");
1690 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1691
1692 prop = RNA_def_property(srna, "blend_in", PROP_FLOAT, PROP_NONE);
1693 RNA_def_property_float_sdna(prop, NULL, "blendin");
1694 RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifier_blending_range");
1695 RNA_def_property_ui_text(
1696 prop, "Blend In", "Number of frames from start frame for influence to take effect");
1697 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1698
1699 prop = RNA_def_property(srna, "blend_out", PROP_FLOAT, PROP_NONE);
1700 RNA_def_property_float_sdna(prop, NULL, "blendout");
1701 RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifier_blending_range");
1702 RNA_def_property_ui_text(
1703 prop, "Blend Out", "Number of frames from end frame for influence to fade out");
1704 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1705
1706 /* influence */
1707 prop = RNA_def_property(srna, "use_influence", PROP_BOOLEAN, PROP_NONE);
1708 RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_USEINFLUENCE);
1709 RNA_def_property_ui_text(
1710 prop, "Use Influence", "F-Curve Modifier's effects will be tempered by a default factor");
1711 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1712 RNA_def_property_ui_icon(
1713 prop, ICON_DISCLOSURE_TRI_RIGHT, 1); /* XXX: depends on UI implementation */
1714
1715 prop = RNA_def_property(srna, "influence", PROP_FLOAT, PROP_FACTOR);
1716 RNA_def_property_float_sdna(prop, NULL, "influence");
1717 RNA_def_property_range(prop, 0.0f, 1.0f);
1718 RNA_def_property_float_default(prop, 1.0f);
1719 RNA_def_property_ui_text(
1720 prop, "Influence", "Amount of influence F-Curve Modifier will have when not fading in/out");
1721 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_update");
1722 }
1723
1724 /* *********************** */
1725
rna_def_drivertarget(BlenderRNA * brna)1726 static void rna_def_drivertarget(BlenderRNA *brna)
1727 {
1728 StructRNA *srna;
1729 PropertyRNA *prop;
1730
1731 static const EnumPropertyItem prop_trans_chan_items[] = {
1732 {DTAR_TRANSCHAN_LOCX, "LOC_X", 0, "X Location", ""},
1733 {DTAR_TRANSCHAN_LOCY, "LOC_Y", 0, "Y Location", ""},
1734 {DTAR_TRANSCHAN_LOCZ, "LOC_Z", 0, "Z Location", ""},
1735 {0, "", 0, NULL, NULL},
1736 {DTAR_TRANSCHAN_ROTX, "ROT_X", 0, "X Rotation", ""},
1737 {DTAR_TRANSCHAN_ROTY, "ROT_Y", 0, "Y Rotation", ""},
1738 {DTAR_TRANSCHAN_ROTZ, "ROT_Z", 0, "Z Rotation", ""},
1739 {DTAR_TRANSCHAN_ROTW, "ROT_W", 0, "W Rotation", ""},
1740 {0, "", 0, NULL, NULL},
1741 {DTAR_TRANSCHAN_SCALEX, "SCALE_X", 0, "X Scale", ""},
1742 {DTAR_TRANSCHAN_SCALEY, "SCALE_Y", 0, "Y Scale", ""},
1743 {DTAR_TRANSCHAN_SCALEZ, "SCALE_Z", 0, "Z Scale", ""},
1744 {DTAR_TRANSCHAN_SCALE_AVG, "SCALE_AVG", 0, "Average Scale", ""},
1745 {0, NULL, 0, NULL, NULL},
1746 };
1747
1748 static const EnumPropertyItem prop_local_space_items[] = {
1749 {0,
1750 "WORLD_SPACE",
1751 0,
1752 "World Space",
1753 "Transforms include effects of parenting/restpose and constraints"},
1754 {DTAR_FLAG_LOCALSPACE,
1755 "TRANSFORM_SPACE",
1756 0,
1757 "Transform Space",
1758 "Transforms don't include parenting/restpose or constraints"},
1759 {DTAR_FLAG_LOCALSPACE | DTAR_FLAG_LOCAL_CONSTS,
1760 "LOCAL_SPACE",
1761 0,
1762 "Local Space",
1763 "Transforms include effects of constraints but not "
1764 "parenting/restpose"},
1765 {0, NULL, 0, NULL, NULL},
1766 };
1767
1768 srna = RNA_def_struct(brna, "DriverTarget", NULL);
1769 RNA_def_struct_ui_text(srna, "Driver Target", "Source of input values for driver variables");
1770
1771 /* Target Properties - ID-block to Drive */
1772 prop = RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
1773 RNA_def_property_struct_type(prop, "ID");
1774 RNA_def_property_flag(prop, PROP_EDITABLE);
1775 RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1776 RNA_def_property_editable_func(prop, "rna_DriverTarget_id_editable");
1777 /* note: custom set function is ONLY to avoid rna setting a user for this. */
1778 RNA_def_property_pointer_funcs(
1779 prop, NULL, "rna_DriverTarget_id_set", "rna_DriverTarget_id_typef", NULL);
1780 RNA_def_property_ui_text(prop,
1781 "ID",
1782 "ID-block that the specific property used can be found from "
1783 "(id_type property must be set first)");
1784 RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
1785
1786 prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
1787 RNA_def_property_enum_sdna(prop, NULL, "idtype");
1788 RNA_def_property_enum_items(prop, rna_enum_id_type_items);
1789 RNA_def_property_enum_default(prop, ID_OB);
1790 RNA_def_property_enum_funcs(prop, NULL, "rna_DriverTarget_id_type_set", NULL);
1791 RNA_def_property_editable_func(prop, "rna_DriverTarget_id_type_editable");
1792 RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used");
1793 RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_ID);
1794 RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
1795
1796 /* Target Properties - Property to Drive */
1797 prop = RNA_def_property(srna, "data_path", PROP_STRING, PROP_NONE);
1798 RNA_def_property_string_funcs(prop,
1799 "rna_DriverTarget_RnaPath_get",
1800 "rna_DriverTarget_RnaPath_length",
1801 "rna_DriverTarget_RnaPath_set");
1802 RNA_def_property_ui_text(prop, "Data Path", "RNA Path (from ID-block) to property used");
1803 RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
1804
1805 prop = RNA_def_property(srna, "bone_target", PROP_STRING, PROP_NONE);
1806 RNA_def_property_string_sdna(prop, NULL, "pchan_name");
1807 RNA_def_property_ui_text(prop, "Bone Name", "Name of PoseBone to use as target");
1808 RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
1809
1810 prop = RNA_def_property(srna, "transform_type", PROP_ENUM, PROP_NONE);
1811 RNA_def_property_enum_sdna(prop, NULL, "transChan");
1812 RNA_def_property_enum_items(prop, prop_trans_chan_items);
1813 RNA_def_property_ui_text(prop, "Type", "Driver variable type");
1814 RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
1815
1816 prop = RNA_def_property(srna, "rotation_mode", PROP_ENUM, PROP_NONE);
1817 RNA_def_property_enum_sdna(prop, NULL, "rotation_mode");
1818 RNA_def_property_enum_items(prop, rna_enum_driver_target_rotation_mode_items);
1819 RNA_def_property_ui_text(prop, "Rotation Mode", "Mode for calculating rotation channel values");
1820 RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
1821
1822 prop = RNA_def_property(srna, "transform_space", PROP_ENUM, PROP_NONE);
1823 RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1824 RNA_def_property_enum_items(prop, prop_local_space_items);
1825 RNA_def_property_ui_text(prop, "Transform Space", "Space in which transforms are used");
1826 RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
1827 }
1828
rna_def_drivervar(BlenderRNA * brna)1829 static void rna_def_drivervar(BlenderRNA *brna)
1830 {
1831 StructRNA *srna;
1832 PropertyRNA *prop;
1833
1834 static const EnumPropertyItem prop_type_items[] = {
1835 {DVAR_TYPE_SINGLE_PROP,
1836 "SINGLE_PROP",
1837 ICON_RNA,
1838 "Single Property",
1839 "Use the value from some RNA property (Default)"},
1840 {DVAR_TYPE_TRANSFORM_CHAN,
1841 "TRANSFORMS",
1842 ICON_DRIVER_TRANSFORM,
1843 "Transform Channel",
1844 "Final transformation value of object or bone"},
1845 {DVAR_TYPE_ROT_DIFF,
1846 "ROTATION_DIFF",
1847 ICON_DRIVER_ROTATIONAL_DIFFERENCE,
1848 "Rotational Difference",
1849 "Use the angle between two bones"},
1850 {DVAR_TYPE_LOC_DIFF,
1851 "LOC_DIFF",
1852 ICON_DRIVER_DISTANCE,
1853 "Distance",
1854 "Distance between two bones or objects"},
1855 {0, NULL, 0, NULL, NULL},
1856 };
1857
1858 srna = RNA_def_struct(brna, "DriverVariable", NULL);
1859 RNA_def_struct_sdna(srna, "DriverVar");
1860 RNA_def_struct_ui_text(
1861 srna, "Driver Variable", "Variable from some source/target for driver relationship");
1862
1863 /* Variable Name */
1864 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1865 RNA_def_struct_name_property(srna, prop);
1866 RNA_def_property_string_funcs(prop, NULL, NULL, "rna_DriverVariable_name_set");
1867 RNA_def_property_ui_text(
1868 prop,
1869 "Name",
1870 "Name to use in scripted expressions/functions (no spaces or dots are allowed, "
1871 "and must start with a letter)");
1872 RNA_def_property_update(prop, 0, "rna_DriverTarget_update_name"); /* XXX */
1873
1874 /* Enums */
1875 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1876 RNA_def_property_enum_items(prop, prop_type_items);
1877 RNA_def_property_enum_funcs(prop, NULL, "rna_DriverVariable_type_set", NULL);
1878 RNA_def_property_ui_text(prop, "Type", "Driver variable type");
1879 RNA_def_property_update(prop, 0, "rna_ChannelDriver_update_data"); /* XXX */
1880
1881 /* Targets */
1882 /* TODO: for nicer api, only expose the relevant props via subclassing,
1883 * instead of exposing the collection of targets */
1884 prop = RNA_def_property(srna, "targets", PROP_COLLECTION, PROP_NONE);
1885 RNA_def_property_collection_sdna(prop, NULL, "targets", "num_targets");
1886 RNA_def_property_struct_type(prop, "DriverTarget");
1887 RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1888 RNA_def_property_ui_text(prop, "Targets", "Sources of input data for evaluating this variable");
1889
1890 /* Name Validity Flags */
1891 prop = RNA_def_property(srna, "is_name_valid", PROP_BOOLEAN, PROP_NONE);
1892 RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", DVAR_FLAG_INVALID_NAME);
1893 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1894 RNA_def_property_ui_text(prop, "Is Name Valid", "Is this a valid name for a driver variable");
1895 }
1896
1897 /* channeldriver.variables.* */
rna_def_channeldriver_variables(BlenderRNA * brna,PropertyRNA * cprop)1898 static void rna_def_channeldriver_variables(BlenderRNA *brna, PropertyRNA *cprop)
1899 {
1900 StructRNA *srna;
1901 /* PropertyRNA *prop; */
1902
1903 FunctionRNA *func;
1904 PropertyRNA *parm;
1905
1906 RNA_def_property_srna(cprop, "ChannelDriverVariables");
1907 srna = RNA_def_struct(brna, "ChannelDriverVariables", NULL);
1908 RNA_def_struct_sdna(srna, "ChannelDriver");
1909 RNA_def_struct_ui_text(
1910 srna, "ChannelDriver Variables", "Collection of channel driver Variables");
1911
1912 /* add variable */
1913 func = RNA_def_function(srna, "new", "rna_Driver_new_variable");
1914 RNA_def_function_ui_description(func, "Add a new variable for the driver");
1915 /* return type */
1916 parm = RNA_def_pointer(func, "var", "DriverVariable", "", "Newly created Driver Variable");
1917 RNA_def_function_return(func, parm);
1918
1919 /* remove variable */
1920 func = RNA_def_function(srna, "remove", "rna_Driver_remove_variable");
1921 RNA_def_function_ui_description(func, "Remove an existing variable from the driver");
1922 RNA_def_function_flag(func, FUNC_USE_REPORTS);
1923 /* target to remove */
1924 parm = RNA_def_pointer(
1925 func, "variable", "DriverVariable", "", "Variable to remove from the driver");
1926 RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1927 RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1928 }
1929
rna_def_channeldriver(BlenderRNA * brna)1930 static void rna_def_channeldriver(BlenderRNA *brna)
1931 {
1932 StructRNA *srna;
1933 PropertyRNA *prop;
1934
1935 static const EnumPropertyItem prop_type_items[] = {
1936 {DRIVER_TYPE_AVERAGE, "AVERAGE", 0, "Averaged Value", ""},
1937 {DRIVER_TYPE_SUM, "SUM", 0, "Sum Values", ""},
1938 {DRIVER_TYPE_PYTHON, "SCRIPTED", 0, "Scripted Expression", ""},
1939 {DRIVER_TYPE_MIN, "MIN", 0, "Minimum Value", ""},
1940 {DRIVER_TYPE_MAX, "MAX", 0, "Maximum Value", ""},
1941 {0, NULL, 0, NULL, NULL},
1942 };
1943
1944 srna = RNA_def_struct(brna, "Driver", NULL);
1945 RNA_def_struct_sdna(srna, "ChannelDriver");
1946 RNA_def_struct_ui_text(
1947 srna, "Driver", "Driver for the value of a setting based on an external value");
1948 RNA_def_struct_ui_icon(srna, ICON_DRIVER);
1949
1950 /* Enums */
1951 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1952 RNA_def_property_enum_items(prop, prop_type_items);
1953 RNA_def_property_ui_text(prop, "Type", "Driver type");
1954 RNA_def_property_update(prop, 0, "rna_ChannelDriver_update_data");
1955
1956 /* String values */
1957 prop = RNA_def_property(srna, "expression", PROP_STRING, PROP_NONE);
1958 RNA_def_property_ui_text(prop, "Expression", "Expression to use for Scripted Expression");
1959 RNA_def_property_update(prop, 0, "rna_ChannelDriver_update_expr");
1960
1961 /* Collections */
1962 prop = RNA_def_property(srna, "variables", PROP_COLLECTION, PROP_NONE);
1963 RNA_def_property_collection_sdna(prop, NULL, "variables", NULL);
1964 RNA_def_property_struct_type(prop, "DriverVariable");
1965 RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1966 RNA_def_property_ui_text(prop, "Variables", "Properties acting as inputs for this driver");
1967 rna_def_channeldriver_variables(brna, prop);
1968
1969 /* Settings */
1970 prop = RNA_def_property(srna, "use_self", PROP_BOOLEAN, PROP_NONE);
1971 RNA_def_property_boolean_sdna(prop, NULL, "flag", DRIVER_FLAG_USE_SELF);
1972 RNA_def_property_ui_text(
1973 prop,
1974 "Use Self",
1975 "Include a 'self' variable in the name-space, "
1976 "so drivers can easily reference the data being modified (object, bone, etc...)");
1977
1978 /* State Info (for Debugging) */
1979 prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
1980 RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", DRIVER_FLAG_INVALID);
1981 RNA_def_property_ui_text(
1982 prop, "Invalid", "Driver could not be evaluated in past, so should be skipped");
1983
1984 prop = RNA_def_property(srna, "is_simple_expression", PROP_BOOLEAN, PROP_NONE);
1985 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1986 RNA_def_property_boolean_funcs(prop, "rna_ChannelDriver_is_simple_expression_get", NULL);
1987 RNA_def_property_ui_text(
1988 prop,
1989 "Simple Expression",
1990 "The scripted expression can be evaluated without using the full python interpreter");
1991
1992 /* Functions */
1993 RNA_api_drivers(srna);
1994 }
1995
1996 /* *********************** */
1997
rna_def_fpoint(BlenderRNA * brna)1998 static void rna_def_fpoint(BlenderRNA *brna)
1999 {
2000 StructRNA *srna;
2001 PropertyRNA *prop;
2002
2003 srna = RNA_def_struct(brna, "FCurveSample", NULL);
2004 RNA_def_struct_sdna(srna, "FPoint");
2005 RNA_def_struct_ui_text(srna, "F-Curve Sample", "Sample point for F-Curve");
2006
2007 /* Boolean values */
2008 prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
2009 RNA_def_property_boolean_sdna(prop, NULL, "flag", 1);
2010 RNA_def_property_ui_text(prop, "Select", "Selection status");
2011 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
2012
2013 /* Vector value */
2014 prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
2015 RNA_def_property_float_sdna(prop, NULL, "vec");
2016 RNA_def_property_array(prop, 2);
2017 RNA_def_property_ui_text(prop, "Point", "Point coordinates");
2018 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
2019 }
2020
2021 /* duplicate of BezTriple in rna_curve.c
2022 * but with F-Curve specific options updates/functionality
2023 */
rna_def_fkeyframe(BlenderRNA * brna)2024 static void rna_def_fkeyframe(BlenderRNA *brna)
2025 {
2026 StructRNA *srna;
2027 PropertyRNA *prop;
2028
2029 srna = RNA_def_struct(brna, "Keyframe", NULL);
2030 RNA_def_struct_sdna(srna, "BezTriple");
2031 RNA_def_struct_ui_text(
2032 srna, "Keyframe", "Bezier curve point with two handles defining a Keyframe on an F-Curve");
2033
2034 /* Boolean values */
2035 prop = RNA_def_property(srna, "select_left_handle", PROP_BOOLEAN, PROP_NONE);
2036 RNA_def_property_boolean_sdna(prop, NULL, "f1", SELECT);
2037 RNA_def_property_ui_text(prop, "Handle 1 selected", "Left handle selection status");
2038 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
2039
2040 prop = RNA_def_property(srna, "select_right_handle", PROP_BOOLEAN, PROP_NONE);
2041 RNA_def_property_boolean_sdna(prop, NULL, "f3", SELECT);
2042 RNA_def_property_ui_text(prop, "Handle 2 selected", "Right handle selection status");
2043 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
2044
2045 prop = RNA_def_property(srna, "select_control_point", PROP_BOOLEAN, PROP_NONE);
2046 RNA_def_property_boolean_sdna(prop, NULL, "f2", SELECT);
2047 RNA_def_property_ui_text(prop, "Select", "Control point selection status");
2048 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
2049
2050 /* Enums */
2051 prop = RNA_def_property(srna, "handle_left_type", PROP_ENUM, PROP_NONE);
2052 RNA_def_property_enum_sdna(prop, NULL, "h1");
2053 RNA_def_property_enum_items(prop, rna_enum_keyframe_handle_type_items);
2054 RNA_def_property_ui_text(prop, "Left Handle Type", "Handle types");
2055 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_Keyframe_update");
2056
2057 prop = RNA_def_property(srna, "handle_right_type", PROP_ENUM, PROP_NONE);
2058 RNA_def_property_enum_sdna(prop, NULL, "h2");
2059 RNA_def_property_enum_items(prop, rna_enum_keyframe_handle_type_items);
2060 RNA_def_property_ui_text(prop, "Right Handle Type", "Handle types");
2061 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_Keyframe_update");
2062
2063 prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
2064 RNA_def_property_enum_sdna(prop, NULL, "ipo");
2065 RNA_def_property_enum_items(prop, rna_enum_beztriple_interpolation_mode_items);
2066 RNA_def_property_ui_text(prop,
2067 "Interpolation",
2068 "Interpolation method to use for segment of the F-Curve from "
2069 "this Keyframe until the next Keyframe");
2070 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_Keyframe_update");
2071
2072 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2073 RNA_def_property_enum_sdna(prop, NULL, "hide");
2074 RNA_def_property_enum_items(prop, rna_enum_beztriple_keyframe_type_items);
2075 RNA_def_property_ui_text(prop, "Type", "Type of keyframe (for visual purposes only)");
2076 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_Keyframe_update");
2077
2078 prop = RNA_def_property(srna, "easing", PROP_ENUM, PROP_NONE);
2079 RNA_def_property_enum_sdna(prop, NULL, "easing");
2080 RNA_def_property_enum_items(prop, rna_enum_beztriple_interpolation_easing_items);
2081 RNA_def_property_ui_text(prop,
2082 "Easing",
2083 "Which ends of the segment between this and the next keyframe easing "
2084 "interpolation is applied to");
2085 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_Keyframe_update");
2086
2087 prop = RNA_def_property(srna, "back", PROP_FLOAT, PROP_NONE);
2088 RNA_def_property_float_sdna(prop, NULL, "back");
2089 RNA_def_property_ui_text(prop, "Back", "Amount of overshoot for 'back' easing");
2090 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_Keyframe_update");
2091
2092 prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
2093 RNA_def_property_float_sdna(prop, NULL, "amplitude");
2094 RNA_def_property_range(prop, 0.0f, FLT_MAX); /* only positive values... */
2095 RNA_def_property_ui_text(
2096 prop, "Amplitude", "Amount to boost elastic bounces for 'elastic' easing");
2097 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_Keyframe_update");
2098
2099 prop = RNA_def_property(srna, "period", PROP_FLOAT, PROP_NONE);
2100 RNA_def_property_float_sdna(prop, NULL, "period");
2101 RNA_def_property_ui_text(prop, "Period", "Time between bounces for elastic easing");
2102 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_Keyframe_update");
2103
2104 /* Vector values */
2105 prop = RNA_def_property(
2106 srna, "handle_left", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
2107 RNA_def_property_array(prop, 2);
2108 RNA_def_property_float_funcs(
2109 prop, "rna_FKeyframe_handle1_get", "rna_FKeyframe_handle1_set", NULL);
2110 RNA_def_property_ui_text(
2111 prop, "Left Handle", "Coordinates of the left handle (before the control point)");
2112 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_Keyframe_update");
2113
2114 prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
2115 RNA_def_property_array(prop, 2);
2116 RNA_def_property_float_funcs(
2117 prop, "rna_FKeyframe_ctrlpoint_get", "rna_FKeyframe_ctrlpoint_set", NULL);
2118 RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
2119 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_Keyframe_update");
2120
2121 prop = RNA_def_property(
2122 srna, "co_ui", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
2123 RNA_def_property_array(prop, 2);
2124 RNA_def_property_float_funcs(
2125 prop, "rna_FKeyframe_ctrlpoint_get", "rna_FKeyframe_ctrlpoint_ui_set", NULL);
2126 RNA_def_property_ui_text(
2127 prop,
2128 "Control Point",
2129 "Coordinates of the control point. Note: Changing this value also updates the handles "
2130 "similar to using the graph editor transform operator");
2131 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_Keyframe_update");
2132
2133 prop = RNA_def_property(
2134 srna, "handle_right", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
2135 RNA_def_property_array(prop, 2);
2136 RNA_def_property_float_funcs(
2137 prop, "rna_FKeyframe_handle2_get", "rna_FKeyframe_handle2_set", NULL);
2138 RNA_def_property_ui_text(
2139 prop, "Right Handle", "Coordinates of the right handle (after the control point)");
2140 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_Keyframe_update");
2141 }
2142
rna_def_fcurve_modifiers(BlenderRNA * brna,PropertyRNA * cprop)2143 static void rna_def_fcurve_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
2144 {
2145 /* add modifiers */
2146 StructRNA *srna;
2147 PropertyRNA *prop;
2148
2149 FunctionRNA *func;
2150 PropertyRNA *parm;
2151
2152 RNA_def_property_srna(cprop, "FCurveModifiers");
2153 srna = RNA_def_struct(brna, "FCurveModifiers", NULL);
2154 RNA_def_struct_sdna(srna, "FCurve");
2155 RNA_def_struct_ui_text(srna, "F-Curve Modifiers", "Collection of F-Curve Modifiers");
2156
2157 /* Collection active property */
2158 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2159 RNA_def_property_struct_type(prop, "FModifier");
2160 RNA_def_property_pointer_funcs(
2161 prop, "rna_FCurve_active_modifier_get", "rna_FCurve_active_modifier_set", NULL, NULL);
2162 RNA_def_property_flag(prop, PROP_EDITABLE);
2163 RNA_def_property_ui_text(prop, "Active F-Curve Modifier", "Active F-Curve Modifier");
2164
2165 /* Constraint collection */
2166 func = RNA_def_function(srna, "new", "rna_FCurve_modifiers_new");
2167 RNA_def_function_ui_description(func, "Add a constraint to this object");
2168 /* return type */
2169 parm = RNA_def_pointer(func, "fmodifier", "FModifier", "", "New fmodifier");
2170 RNA_def_function_return(func, parm);
2171 /* object to add */
2172 parm = RNA_def_enum(
2173 func, "type", rna_enum_fmodifier_type_items, 1, "", "Constraint type to add");
2174 RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2175
2176 func = RNA_def_function(srna, "remove", "rna_FCurve_modifiers_remove");
2177 RNA_def_function_flag(func, FUNC_USE_REPORTS);
2178 RNA_def_function_ui_description(func, "Remove a modifier from this F-Curve");
2179 /* modifier to remove */
2180 parm = RNA_def_pointer(func, "modifier", "FModifier", "", "Removed modifier");
2181 RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2182 RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2183 }
2184
2185 /* fcurve.keyframe_points */
rna_def_fcurve_keyframe_points(BlenderRNA * brna,PropertyRNA * cprop)2186 static void rna_def_fcurve_keyframe_points(BlenderRNA *brna, PropertyRNA *cprop)
2187 {
2188 StructRNA *srna;
2189
2190 FunctionRNA *func;
2191 PropertyRNA *parm;
2192
2193 static const EnumPropertyItem keyframe_flag_items[] = {
2194 {INSERTKEY_REPLACE,
2195 "REPLACE",
2196 0,
2197 "Replace",
2198 "Don't add any new keyframes, but just replace existing ones"},
2199 {INSERTKEY_NEEDED, "NEEDED", 0, "Needed", "Only adds keyframes that are needed"},
2200 {INSERTKEY_FAST,
2201 "FAST",
2202 0,
2203 "Fast",
2204 "Fast keyframe insertion to avoid recalculating the curve each time"},
2205 {0, NULL, 0, NULL, NULL},
2206 };
2207
2208 RNA_def_property_srna(cprop, "FCurveKeyframePoints");
2209 srna = RNA_def_struct(brna, "FCurveKeyframePoints", NULL);
2210 RNA_def_struct_sdna(srna, "FCurve");
2211 RNA_def_struct_ui_text(srna, "Keyframe Points", "Collection of keyframe points");
2212
2213 func = RNA_def_function(srna, "insert", "rna_FKeyframe_points_insert");
2214 RNA_def_function_ui_description(func, "Add a keyframe point to a F-Curve");
2215 RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN);
2216 parm = RNA_def_float(func,
2217 "frame",
2218 0.0f,
2219 -FLT_MAX,
2220 FLT_MAX,
2221 "",
2222 "X Value of this keyframe point",
2223 -FLT_MAX,
2224 FLT_MAX);
2225 RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2226 parm = RNA_def_float(func,
2227 "value",
2228 0.0f,
2229 -FLT_MAX,
2230 FLT_MAX,
2231 "",
2232 "Y Value of this keyframe point",
2233 -FLT_MAX,
2234 FLT_MAX);
2235 RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2236 RNA_def_enum_flag(func, "options", keyframe_flag_items, 0, "", "Keyframe options");
2237 RNA_def_enum(func,
2238 "keyframe_type",
2239 rna_enum_beztriple_keyframe_type_items,
2240 BEZT_KEYTYPE_KEYFRAME,
2241 "",
2242 "Type of keyframe to insert");
2243 parm = RNA_def_pointer(func, "keyframe", "Keyframe", "", "Newly created keyframe");
2244 RNA_def_function_return(func, parm);
2245
2246 func = RNA_def_function(srna, "add", "rna_FKeyframe_points_add");
2247 RNA_def_function_ui_description(func, "Add a keyframe point to a F-Curve");
2248 RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN);
2249 parm = RNA_def_int(
2250 func, "count", 1, 0, INT_MAX, "Number", "Number of points to add to the spline", 0, INT_MAX);
2251 RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2252
2253 func = RNA_def_function(srna, "remove", "rna_FKeyframe_points_remove");
2254 RNA_def_function_ui_description(func, "Remove keyframe from an F-Curve");
2255 RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
2256 parm = RNA_def_pointer(func, "keyframe", "Keyframe", "", "Keyframe to remove");
2257 RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2258 RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2259 /* optional */
2260 RNA_def_boolean(
2261 func, "fast", 0, "Fast", "Fast keyframe removal to avoid recalculating the curve each time");
2262 }
2263
rna_def_fcurve(BlenderRNA * brna)2264 static void rna_def_fcurve(BlenderRNA *brna)
2265 {
2266 StructRNA *srna;
2267 PropertyRNA *prop;
2268 FunctionRNA *func;
2269 PropertyRNA *parm;
2270
2271 static const EnumPropertyItem prop_mode_extend_items[] = {
2272 {FCURVE_EXTRAPOLATE_CONSTANT,
2273 "CONSTANT",
2274 0,
2275 "Constant",
2276 "Hold values of endpoint keyframes"},
2277 {FCURVE_EXTRAPOLATE_LINEAR,
2278 "LINEAR",
2279 0,
2280 "Linear",
2281 "Use slope of curve leading in/out of endpoint keyframes"},
2282 {0, NULL, 0, NULL, NULL},
2283 };
2284 static const EnumPropertyItem prop_mode_color_items[] = {
2285 {FCURVE_COLOR_AUTO_RAINBOW,
2286 "AUTO_RAINBOW",
2287 0,
2288 "Auto Rainbow",
2289 "Cycle through the rainbow, trying to give each curve a unique color"},
2290 {FCURVE_COLOR_AUTO_RGB,
2291 "AUTO_RGB",
2292 0,
2293 "Auto XYZ to RGB",
2294 "Use axis colors for transform and color properties, and auto-rainbow for the rest"},
2295 {FCURVE_COLOR_AUTO_YRGB,
2296 "AUTO_YRGB",
2297 0,
2298 "Auto WXYZ to YRGB",
2299 "Use axis colors for XYZ parts of transform, and yellow for the 'W' channel"},
2300 {FCURVE_COLOR_CUSTOM,
2301 "CUSTOM",
2302 0,
2303 "User Defined",
2304 "Use custom hand-picked color for F-Curve"},
2305 {0, NULL, 0, NULL, NULL},
2306 };
2307
2308 srna = RNA_def_struct(brna, "FCurve", NULL);
2309 RNA_def_struct_ui_text(srna, "F-Curve", "F-Curve defining values of a period of time");
2310 RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
2311
2312 /* Enums */
2313 prop = RNA_def_property(srna, "extrapolation", PROP_ENUM, PROP_NONE);
2314 RNA_def_property_enum_sdna(prop, NULL, "extend");
2315 RNA_def_property_enum_items(prop, prop_mode_extend_items);
2316 RNA_def_property_ui_text(
2317 prop,
2318 "Extrapolation",
2319 "Method used for evaluating value of F-Curve outside first and last keyframes");
2320 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FCurve_update_data");
2321
2322 /* Pointers */
2323 prop = RNA_def_property(srna, "driver", PROP_POINTER, PROP_NONE);
2324 RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2325 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2326 RNA_def_property_ui_text(prop, "Driver", "Channel Driver (only set for Driver F-Curves)");
2327
2328 prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
2329 RNA_def_property_pointer_sdna(prop, NULL, "grp");
2330 RNA_def_property_flag(prop, PROP_EDITABLE | PROP_PTR_NO_OWNERSHIP);
2331 RNA_def_property_ui_text(prop, "Group", "Action Group that this F-Curve belongs to");
2332 RNA_def_property_pointer_funcs(prop, NULL, "rna_FCurve_group_set", NULL, NULL);
2333 RNA_def_property_update(prop, NC_ANIMATION, NULL);
2334
2335 /* Path + Array Index */
2336 prop = RNA_def_property(srna, "data_path", PROP_STRING, PROP_NONE);
2337 RNA_def_property_string_funcs(
2338 prop, "rna_FCurve_RnaPath_get", "rna_FCurve_RnaPath_length", "rna_FCurve_RnaPath_set");
2339 RNA_def_property_ui_text(prop, "Data Path", "RNA Path to property affected by F-Curve");
2340 /* XXX need an update callback for this to that animation gets evaluated */
2341 RNA_def_property_update(prop, NC_ANIMATION, "rna_FCurve_update_data_relations");
2342
2343 /* called 'index' when given as function arg */
2344 prop = RNA_def_property(srna, "array_index", PROP_INT, PROP_NONE);
2345 RNA_def_property_ui_text(
2346 prop, "RNA Array Index", "Index to the specific property affected by F-Curve if applicable");
2347 /* XXX need an update callback for this so that animation gets evaluated */
2348 RNA_def_property_update(prop, NC_ANIMATION, "rna_FCurve_update_data_relations");
2349
2350 /* Color */
2351 prop = RNA_def_property(srna, "color_mode", PROP_ENUM, PROP_NONE);
2352 RNA_def_property_enum_items(prop, prop_mode_color_items);
2353 RNA_def_property_ui_text(
2354 prop, "Color Mode", "Method used to determine color of F-Curve in Graph Editor");
2355 RNA_def_property_update(prop, NC_ANIMATION, NULL);
2356
2357 prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
2358 RNA_def_property_array(prop, 3);
2359 RNA_def_property_range(prop, 0.0f, 1.0f);
2360 RNA_def_property_ui_text(prop, "Color", "Color of the F-Curve in the Graph Editor");
2361 RNA_def_property_update(prop, NC_ANIMATION, NULL);
2362
2363 /* Flags */
2364 prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
2365 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCURVE_SELECTED);
2366 RNA_def_property_ui_text(prop, "Select", "F-Curve is selected for editing");
2367 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
2368
2369 prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
2370 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCURVE_PROTECTED);
2371 RNA_def_property_ui_text(prop, "Lock", "F-Curve's settings cannot be edited");
2372 RNA_def_property_update(prop, NC_ANIMATION | ND_ANIMCHAN | NA_EDITED, NULL);
2373
2374 prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
2375 RNA_def_property_boolean_sdna(prop, NULL, "flag", FCURVE_MUTED);
2376 RNA_def_property_ui_text(prop, "Muted", "Disable F-Curve Modifier evaluation");
2377 RNA_def_property_update(prop, NC_ANIMATION | ND_ANIMCHAN | NA_EDITED, "rna_FCurve_update_eval");
2378
2379 prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
2380 RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", FCURVE_VISIBLE);
2381 RNA_def_property_ui_text(
2382 prop, "Hide", "F-Curve and its keyframes are hidden in the Graph Editor graphs");
2383 RNA_def_property_update(prop, NC_SPACE | ND_SPACE_GRAPH, NULL);
2384
2385 prop = RNA_def_property(srna, "auto_smoothing", PROP_ENUM, PROP_NONE);
2386 RNA_def_property_enum_items(prop, rna_enum_fcurve_auto_smoothing_items);
2387 RNA_def_property_ui_text(
2388 prop, "Auto Handle Smoothing", "Algorithm used to compute automatic handles");
2389 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, "rna_FCurve_update_data");
2390
2391 /* State Info (for Debugging) */
2392 prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
2393 RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", FCURVE_DISABLED);
2394 RNA_def_property_ui_text(
2395 prop,
2396 "Valid",
2397 "False when F-Curve could not be evaluated in past, so should be skipped "
2398 "when evaluating");
2399 RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
2400
2401 prop = RNA_def_property(srna, "is_empty", PROP_BOOLEAN, PROP_NONE);
2402 RNA_def_property_boolean_funcs(prop, "rna_FCurve_is_empty_get", NULL);
2403 RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2404 RNA_def_property_ui_text(prop,
2405 "Empty",
2406 "True if the curve contributes no animation due to lack of "
2407 "keyframes or useful modifiers, and should be deleted");
2408
2409 /* Collections */
2410 prop = RNA_def_property(srna, "sampled_points", PROP_COLLECTION, PROP_NONE);
2411 RNA_def_property_collection_sdna(prop, NULL, "fpt", "totvert");
2412 RNA_def_property_struct_type(prop, "FCurveSample");
2413 RNA_def_property_ui_text(prop, "Sampled Points", "Sampled animation data");
2414
2415 prop = RNA_def_property(srna, "keyframe_points", PROP_COLLECTION, PROP_NONE);
2416 RNA_def_property_collection_sdna(prop, NULL, "bezt", "totvert");
2417 RNA_def_property_struct_type(prop, "Keyframe");
2418 RNA_def_property_ui_text(prop, "Keyframes", "User-editable keyframes");
2419 rna_def_fcurve_keyframe_points(brna, prop);
2420
2421 prop = RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
2422 RNA_def_property_struct_type(prop, "FModifier");
2423 RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting the shape of the F-Curve");
2424 rna_def_fcurve_modifiers(brna, prop);
2425
2426 /* Functions */
2427 /* -- evaluate -- */
2428 func = RNA_def_function(srna, "evaluate", "evaluate_fcurve"); /* calls the C/API direct */
2429 RNA_def_function_ui_description(func, "Evaluate F-Curve");
2430 parm = RNA_def_float(func,
2431 "frame",
2432 1.0f,
2433 -FLT_MAX,
2434 FLT_MAX,
2435 "Frame",
2436 "Evaluate F-Curve at given frame",
2437 -FLT_MAX,
2438 FLT_MAX);
2439 RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2440 /* return value */
2441 parm = RNA_def_float(func,
2442 "value",
2443 0,
2444 -FLT_MAX,
2445 FLT_MAX,
2446 "Value",
2447 "Value of F-Curve specific frame",
2448 -FLT_MAX,
2449 FLT_MAX);
2450 RNA_def_function_return(func, parm);
2451
2452 /* -- update / recalculate -- */
2453 func = RNA_def_function(srna, "update", "rna_FCurve_update_data_ex");
2454 RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN);
2455 RNA_def_function_ui_description(
2456 func, "Ensure keyframes are sorted in chronological order and handles are set correctly");
2457
2458 /* -- time extents/range -- */
2459 func = RNA_def_function(srna, "range", "rna_FCurve_range");
2460 RNA_def_function_ui_description(func, "Get the time extents for F-Curve");
2461 /* return value */
2462 parm = RNA_def_float_vector(
2463 func, "range", 2, NULL, -FLT_MAX, FLT_MAX, "Range", "Min/Max values", -FLT_MAX, FLT_MAX);
2464 RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
2465 RNA_def_function_output(func, parm);
2466
2467 /* -- auto-flag validity (ensures valid handling for data type) -- */
2468 func = RNA_def_function(
2469 srna, "update_autoflags", "update_autoflags_fcurve"); /* calls the C/API direct */
2470 RNA_def_function_ui_description(
2471 func,
2472 "Update FCurve flags set automatically from affected property "
2473 "(currently, integer/discrete flags set when the property is not a float)");
2474 RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2475 parm = RNA_def_pointer(
2476 func, "data", "AnyType", "Data", "Data containing the property controlled by given FCurve");
2477 RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2478
2479 /* Functions */
2480 RNA_api_fcurves(srna);
2481 }
2482
2483 /* *********************** */
2484
RNA_def_fcurve(BlenderRNA * brna)2485 void RNA_def_fcurve(BlenderRNA *brna)
2486 {
2487 rna_def_fcurve(brna);
2488 rna_def_fkeyframe(brna);
2489 rna_def_fpoint(brna);
2490
2491 rna_def_drivertarget(brna);
2492 rna_def_drivervar(brna);
2493 rna_def_channeldriver(brna);
2494
2495 rna_def_fmodifier(brna);
2496
2497 rna_def_fmodifier_generator(brna);
2498 rna_def_fmodifier_function_generator(brna);
2499
2500 rna_def_fmodifier_envelope(brna);
2501 rna_def_fmodifier_envelope_ctrl(brna);
2502
2503 rna_def_fmodifier_cycles(brna);
2504 rna_def_fmodifier_python(brna);
2505 rna_def_fmodifier_limits(brna);
2506 rna_def_fmodifier_noise(brna);
2507 rna_def_fmodifier_stepped(brna);
2508 }
2509
2510 #endif
2511