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