← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/blender/makesrna/intern/rna_fcurve.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/makesrna/intern/rna_fcurve.c
55
55
        {FMODIFIER_TYPE_ENVELOPE, "ENVELOPE", 0, "Envelope", ""},
56
56
        {FMODIFIER_TYPE_CYCLES, "CYCLES", 0, "Cycles", ""},
57
57
        {FMODIFIER_TYPE_NOISE, "NOISE", 0, "Noise", ""},
58
 
        {FMODIFIER_TYPE_FILTER, "FILTER", 0, "Filter", ""},
 
58
        /*{FMODIFIER_TYPE_FILTER, "FILTER", 0, "Filter", ""},*/ /* FIXME: not implemented yet! */
59
59
        /*{FMODIFIER_TYPE_PYTHON, "PYTHON", 0, "Python", ""},    *//* FIXME: not implemented yet! */
60
60
        {FMODIFIER_TYPE_LIMITS, "LIMITS", 0, "Limits", ""},
61
61
        {FMODIFIER_TYPE_STEPPED, "STEPPED", 0, "Stepped Interpolation", ""},
62
 
        {0, NULL, 0, NULL, NULL}};
 
62
        {0, NULL, 0, NULL, NULL}
 
63
};
63
64
 
64
65
EnumPropertyItem beztriple_keyframe_type_items[] = {
65
66
        {BEZT_KEYTYPE_KEYFRAME, "KEYFRAME", 0, "Keyframe", ""},
66
67
        {BEZT_KEYTYPE_BREAKDOWN, "BREAKDOWN", 0, "Breakdown", ""},
67
68
        {BEZT_KEYTYPE_EXTREME, "EXTREME", 0, "Extreme", ""},
68
69
        {BEZT_KEYTYPE_JITTER, "JITTER", 0, "Jitter", ""},
69
 
        {0, NULL, 0, NULL, NULL}};
 
70
        {0, NULL, 0, NULL, NULL}
 
71
};
70
72
 
71
73
#ifdef RNA_RUNTIME
72
74
 
115
117
        
116
118
        /* TODO: this really needs an update guard... */
117
119
        DAG_scene_sort(bmain, scene);
118
 
        DAG_id_tag_update(id, OB_RECALC_OB|OB_RECALC_DATA);
 
120
        DAG_id_tag_update(id, OB_RECALC_OB | OB_RECALC_DATA);
119
121
        
120
 
        WM_main_add_notifier(NC_SCENE|ND_FRAME, scene);
 
122
        WM_main_add_notifier(NC_SCENE | ND_FRAME, scene);
121
123
}
122
124
 
123
125
static void rna_ChannelDriver_update_expr(Main *bmain, Scene *scene, PointerRNA *ptr)
163
165
/* note: this function exists only to avoid id refcounting */
164
166
static void rna_DriverTarget_id_set(PointerRNA *ptr, PointerRNA value)
165
167
{
166
 
        DriverTarget *dtar = (DriverTarget*)ptr->data;
 
168
        DriverTarget *dtar = (DriverTarget *)ptr->data;
167
169
        dtar->id = value.data;
168
170
}
169
171
 
170
172
static StructRNA *rna_DriverTarget_id_typef(PointerRNA *ptr)
171
173
{
172
 
        DriverTarget *dtar = (DriverTarget*)ptr->data;
 
174
        DriverTarget *dtar = (DriverTarget *)ptr->data;
173
175
        return ID_code_to_RNA_type(dtar->idtype);
174
176
}
175
177
 
176
178
static int rna_DriverTarget_id_editable(PointerRNA *ptr)
177
179
{
178
 
        DriverTarget *dtar = (DriverTarget*)ptr->data;
179
 
        return (dtar->idtype)? PROP_EDITABLE : 0;
 
180
        DriverTarget *dtar = (DriverTarget *)ptr->data;
 
181
        return (dtar->idtype) ? PROP_EDITABLE : 0;
180
182
}
181
183
 
182
184
static int rna_DriverTarget_id_type_editable(PointerRNA *ptr)
183
185
{
184
 
        DriverTarget *dtar = (DriverTarget*)ptr->data;
 
186
        DriverTarget *dtar = (DriverTarget *)ptr->data;
185
187
        
186
188
        /* when the id-type can only be object, don't allow editing
187
189
         * otherwise, there may be strange crashes
191
193
 
192
194
static void rna_DriverTarget_id_type_set(PointerRNA *ptr, int value)
193
195
{
194
 
        DriverTarget *data = (DriverTarget*)(ptr->data);
 
196
        DriverTarget *data = (DriverTarget *)(ptr->data);
195
197
        
196
198
        /* check if ID-type is settable */
197
199
        if ((data->flag & DTAR_FLAG_ID_OB_ONLY) == 0) {
254
256
 
255
257
static void rna_FKeyframe_handle1_get(PointerRNA *ptr, float *values)
256
258
{
257
 
        BezTriple *bezt = (BezTriple*)ptr->data;
 
259
        BezTriple *bezt = (BezTriple *)ptr->data;
258
260
        
259
261
        values[0] = bezt->vec[0][0];
260
262
        values[1] = bezt->vec[0][1];
262
264
 
263
265
static void rna_FKeyframe_handle1_set(PointerRNA *ptr, const float *values)
264
266
{
265
 
        BezTriple *bezt = (BezTriple*)ptr->data;
 
267
        BezTriple *bezt = (BezTriple *)ptr->data;
266
268
        
267
269
        bezt->vec[0][0] = values[0];
268
270
        bezt->vec[0][1] = values[1];
270
272
 
271
273
static void rna_FKeyframe_handle2_get(PointerRNA *ptr, float *values)
272
274
{
273
 
        BezTriple *bezt = (BezTriple*)ptr->data;
 
275
        BezTriple *bezt = (BezTriple *)ptr->data;
274
276
        
275
277
        values[0] = bezt->vec[2][0];
276
278
        values[1] = bezt->vec[2][1];
278
280
 
279
281
static void rna_FKeyframe_handle2_set(PointerRNA *ptr, const float *values)
280
282
{
281
 
        BezTriple *bezt = (BezTriple*)ptr->data;
 
283
        BezTriple *bezt = (BezTriple *)ptr->data;
282
284
        
283
285
        bezt->vec[2][0] = values[0];
284
286
        bezt->vec[2][1] = values[1];
286
288
 
287
289
static void rna_FKeyframe_ctrlpoint_get(PointerRNA *ptr, float *values)
288
290
{
289
 
        BezTriple *bezt = (BezTriple*)ptr->data;
 
291
        BezTriple *bezt = (BezTriple *)ptr->data;
290
292
        
291
293
        values[0] = bezt->vec[1][0];
292
294
        values[1] = bezt->vec[1][1];
294
296
 
295
297
static void rna_FKeyframe_ctrlpoint_set(PointerRNA *ptr, const float *values)
296
298
{
297
 
        BezTriple *bezt = (BezTriple*)ptr->data;
 
299
        BezTriple *bezt = (BezTriple *)ptr->data;
298
300
        
299
301
        bezt->vec[1][0] = values[0];
300
302
        bezt->vec[1][1] = values[1];
362
364
        else {
363
365
                /* the ID given is the owner of the F-Curve (for drivers) */
364
366
                AnimData *adt = BKE_animdata_from_id(ptr->id.data);
365
 
                act = (adt)? adt->action : NULL;
 
367
                act = (adt) ? adt->action : NULL;
366
368
        }
367
369
        
368
370
        /* already belongs to group? */
401
403
        }
402
404
}
403
405
 
404
 
DriverVar *rna_Driver_new_variable(ChannelDriver *driver)
 
406
static DriverVar *rna_Driver_new_variable(ChannelDriver *driver)
405
407
{
406
408
        /* call the API function for this */
407
409
        return driver_add_new_variable(driver);
408
410
}
409
411
 
410
 
void rna_Driver_remove_variable(ChannelDriver *driver, ReportList *reports, DriverVar *dvar)
 
412
static void rna_Driver_remove_variable(ChannelDriver *driver, ReportList *reports, PointerRNA *dvar_ptr)
411
413
{
 
414
        DriverVar *dvar = dvar_ptr->data;
412
415
        if (BLI_findindex(&driver->variables, dvar) == -1) {
413
416
                BKE_report(reports, RPT_ERROR, "Variable does not exist in this driver");
414
417
                return;
415
418
        }
416
419
 
417
420
        driver_free_variable(driver, dvar);
 
421
        RNA_POINTER_INVALIDATE(dvar_ptr);
418
422
}
419
423
 
420
424
 
421
425
static PointerRNA rna_FCurve_active_modifier_get(PointerRNA *ptr)
422
426
{
423
 
        FCurve *fcu = (FCurve*)ptr->data;
 
427
        FCurve *fcu = (FCurve *)ptr->data;
424
428
        FModifier *fcm = find_active_fmodifier(&fcu->modifiers);
425
429
        return rna_pointer_inherit_refine(ptr, &RNA_FModifier, fcm);
426
430
}
427
431
 
428
432
static void rna_FCurve_active_modifier_set(PointerRNA *ptr, PointerRNA value)
429
433
{
430
 
        FCurve *fcu = (FCurve*)ptr->data;
 
434
        FCurve *fcu = (FCurve *)ptr->data;
431
435
        set_active_fmodifier(&fcu->modifiers, (FModifier *)value.data);
432
436
}
433
437
 
436
440
        return add_fmodifier(&fcu->modifiers, type);
437
441
}
438
442
 
439
 
static void rna_FCurve_modifiers_remove(FCurve *fcu, ReportList *reports, FModifier *fcm)
 
443
static void rna_FCurve_modifiers_remove(FCurve *fcu, ReportList *reports, PointerRNA *fcm_ptr)
440
444
{
 
445
        FModifier *fcm = fcm_ptr->data;
441
446
        if (BLI_findindex(&fcu->modifiers, fcm) == -1) {
442
447
                BKE_reportf(reports, RPT_ERROR, "F-Curve modifier '%s' not found in F-Curve", fcm->name);
443
448
                return;
444
449
        }
 
450
 
445
451
        remove_fmodifier(&fcu->modifiers, fcm);
 
452
        RNA_POINTER_INVALIDATE(fcm_ptr);
446
453
}
447
454
 
448
455
static void rna_FModifier_active_set(PointerRNA *ptr, int UNUSED(value))
449
456
{
450
 
        FModifier *fm = (FModifier*)ptr->data;
 
457
        FModifier *fm = (FModifier *)ptr->data;
451
458
 
452
459
        /* don't toggle, always switch on */
453
460
        fm->flag |= FMODIFIER_FLAG_ACTIVE;
455
462
 
456
463
static void rna_FModifier_start_frame_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
457
464
{
458
 
        FModifier *fcm = (FModifier*)ptr->data;
 
465
        FModifier *fcm = (FModifier *)ptr->data;
459
466
        
460
467
        *min = MINAFRAMEF;
461
 
        *max = (fcm->flag & FMODIFIER_FLAG_RANGERESTRICT)? fcm->efra : MAXFRAMEF;
 
468
        *max = (fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) ? fcm->efra : MAXFRAMEF;
462
469
}
463
470
 
464
471
static void rna_FModifier_end_frame_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
465
472
{
466
 
        FModifier *fcm = (FModifier*)ptr->data;
 
473
        FModifier *fcm = (FModifier *)ptr->data;
467
474
 
468
 
        *min = (fcm->flag & FMODIFIER_FLAG_RANGERESTRICT)? fcm->sfra : MINAFRAMEF;
 
475
        *min = (fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) ? fcm->sfra : MINAFRAMEF;
469
476
        *max = MAXFRAMEF;
470
477
}
471
478
 
472
479
static void rna_FModifier_blending_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
473
480
{
474
 
        FModifier *fcm = (FModifier*)ptr->data;
 
481
        FModifier *fcm = (FModifier *)ptr->data;
475
482
 
476
483
        *min = 0.0f;
477
484
        *max = fcm->efra - fcm->sfra;
479
486
 
480
487
static void rna_FModifier_active_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
481
488
{
482
 
        FModifier *fm, *fmo = (FModifier*)ptr->data;
 
489
        FModifier *fm, *fmo = (FModifier *)ptr->data;
483
490
 
484
491
        /* clear active state of other FModifiers in this list */
485
 
        for (fm = fmo->prev; fm; fm = fm->prev)
486
 
        {
 
492
        for (fm = fmo->prev; fm; fm = fm->prev) {
487
493
                fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
488
494
        }
489
 
        for (fm = fmo->next; fm; fm = fm->next)
490
 
        {
 
495
        for (fm = fmo->next; fm; fm = fm->next) {
491
496
                fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
492
497
        }
493
498
        
495
500
 
496
501
static int rna_FModifierGenerator_coefficients_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
497
502
{
498
 
        FModifier *fcm = (FModifier*)ptr->data;
 
503
        FModifier *fcm = (FModifier *)ptr->data;
499
504
        FMod_Generator *gen = fcm->data;
500
505
 
501
506
        if (gen)
502
507
                length[0] = gen->arraysize;
503
508
        else
504
 
                length[0] = 100; /* for raw_access, untested */
 
509
                length[0] = 100;  /* for raw_access, untested */
505
510
 
506
511
        return length[0];
507
512
}
508
513
 
509
514
static void rna_FModifierGenerator_coefficients_get(PointerRNA *ptr, float *values)
510
515
{
511
 
        FModifier *fcm = (FModifier*)ptr->data;
 
516
        FModifier *fcm = (FModifier *)ptr->data;
512
517
        FMod_Generator *gen = fcm->data;
513
518
        memcpy(values, gen->coefficients, gen->arraysize * sizeof(float));
514
519
}
515
520
 
516
521
static void rna_FModifierGenerator_coefficients_set(PointerRNA *ptr, const float *values)
517
522
{
518
 
        FModifier *fcm = (FModifier*)ptr->data;
 
523
        FModifier *fcm = (FModifier *)ptr->data;
519
524
        FMod_Generator *gen = fcm->data;
520
525
        memcpy(gen->coefficients, values, gen->arraysize * sizeof(float));
521
526
}
522
527
 
523
528
static void rna_FModifierLimits_minx_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
524
529
{
525
 
        FModifier *fcm = (FModifier*)ptr->data;
 
530
        FModifier *fcm = (FModifier *)ptr->data;
526
531
        FMod_Limits *data = fcm->data;
527
532
 
528
533
        *min = MINAFRAMEF;
529
 
        *max = (data->flag & FCM_LIMIT_XMAX)? data->rect.xmax : MAXFRAMEF;
 
534
        *max = (data->flag & FCM_LIMIT_XMAX) ? data->rect.xmax : MAXFRAMEF;
530
535
}
531
536
 
532
537
static void rna_FModifierLimits_maxx_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
533
538
{
534
 
        FModifier *fcm = (FModifier*)ptr->data;
 
539
        FModifier *fcm = (FModifier *)ptr->data;
535
540
        FMod_Limits *data = fcm->data;
536
541
 
537
 
        *min = (data->flag & FCM_LIMIT_XMIN)? data->rect.xmin : MINAFRAMEF;
 
542
        *min = (data->flag & FCM_LIMIT_XMIN) ? data->rect.xmin : MINAFRAMEF;
538
543
        *max = MAXFRAMEF;
539
544
}
540
545
 
541
546
static void rna_FModifierLimits_miny_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
542
547
{
543
 
        FModifier *fcm = (FModifier*)ptr->data;
 
548
        FModifier *fcm = (FModifier *)ptr->data;
544
549
        FMod_Limits *data = fcm->data;
545
550
 
546
551
        *min = -FLT_MAX;
547
 
        *max = (data->flag & FCM_LIMIT_YMAX)? data->rect.ymax : FLT_MAX;
 
552
        *max = (data->flag & FCM_LIMIT_YMAX) ? data->rect.ymax : FLT_MAX;
548
553
}
549
554
 
550
555
static void rna_FModifierLimits_maxy_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
551
556
{
552
 
        FModifier *fcm = (FModifier*)ptr->data;
 
557
        FModifier *fcm = (FModifier *)ptr->data;
553
558
        FMod_Limits *data = fcm->data;
554
559
 
555
 
        *min = (data->flag & FCM_LIMIT_YMIN)? data->rect.ymin : -FLT_MAX;
 
560
        *min = (data->flag & FCM_LIMIT_YMIN) ? data->rect.ymin : -FLT_MAX;
556
561
        *max = FLT_MAX;
557
562
}
558
563
 
560
565
static void rna_FModifierStepped_start_frame_range(PointerRNA *ptr, float *min, float *max,
561
566
                                                   float *softmin, float *softmax)
562
567
{
563
 
        FModifier *fcm = (FModifier*)ptr->data;
 
568
        FModifier *fcm = (FModifier *)ptr->data;
564
569
        FMod_Stepped *data = fcm->data;
565
570
        
566
571
        *min = MINAFRAMEF;
567
 
        *max = (data->flag & FCM_STEPPED_NO_AFTER)? data->end_frame : MAXFRAMEF;
 
572
        *max = (data->flag & FCM_STEPPED_NO_AFTER) ? data->end_frame : MAXFRAMEF;
568
573
}
569
574
 
570
575
static void rna_FModifierStepped_end_frame_range(PointerRNA *ptr, float *min, float *max,
571
576
                                                 float *softmin, float *softmax)
572
577
{
573
 
        FModifier *fcm = (FModifier*)ptr->data;
 
578
        FModifier *fcm = (FModifier *)ptr->data;
574
579
        FMod_Stepped *data = fcm->data;
575
580
 
576
 
        *min = (data->flag & FCM_STEPPED_NO_BEFORE)? data->start_frame : MINAFRAMEF;
 
581
        *min = (data->flag & FCM_STEPPED_NO_BEFORE) ? data->start_frame : MINAFRAMEF;
577
582
        *max = MAXFRAMEF;
578
583
}
579
584
 
580
585
static BezTriple *rna_FKeyframe_points_insert(FCurve *fcu, float frame, float value, int flag)
581
586
{
582
587
        int index = insert_vert_fcurve(fcu, frame, value, flag);
583
 
        return ((fcu->bezt) && (index >= 0))? (fcu->bezt + index) : NULL;
 
588
        return ((fcu->bezt) && (index >= 0)) ? (fcu->bezt + index) : NULL;
584
589
}
585
590
 
586
591
static void rna_FKeyframe_points_add(FCurve *fcu, int tot)
610
615
        }
611
616
}
612
617
 
613
 
static void rna_FKeyframe_points_remove(FCurve *fcu, ReportList *reports, BezTriple *bezt, int do_fast)
 
618
static void rna_FKeyframe_points_remove(FCurve *fcu, ReportList *reports, PointerRNA *bezt_ptr, int do_fast)
614
619
{
 
620
        BezTriple *bezt = bezt_ptr->data;
615
621
        int index = (int)(bezt - fcu->bezt);
616
622
        if (index < 0 || index >= fcu->totvert) {
617
623
                BKE_report(reports, RPT_ERROR, "Keyframe not in F-Curve");
619
625
        }
620
626
 
621
627
        delete_fcurve_key(fcu, index, !do_fast);
 
628
        RNA_POINTER_INVALIDATE(bezt_ptr);
622
629
}
623
630
 
624
631
static void rna_fcurve_range(FCurve *fcu, float range[2])
625
632
{
626
 
        calc_fcurve_range(fcu, range, range+1, FALSE, FALSE);
 
633
        calc_fcurve_range(fcu, range, range + 1, FALSE, FALSE);
 
634
}
 
635
 
 
636
 
 
637
static FCM_EnvelopeData *rna_FModifierEnvelope_points_add(FModifier *fmod, ReportList *reports, float frame)
 
638
{
 
639
        FCM_EnvelopeData fed;
 
640
        FMod_Envelope *env = (FMod_Envelope *)fmod->data;
 
641
        int i;
 
642
 
 
643
        /* init template data */
 
644
        fed.min = -1.0f;
 
645
        fed.max = 1.0f;
 
646
        fed.time = frame;
 
647
        fed.f1 = fed.f2 = 0;
 
648
 
 
649
        if (env->data) {
 
650
                short exists = -1;
 
651
                i = BKE_fcm_envelope_find_index(env->data, frame, env->totvert, &exists);
 
652
                if (exists) {
 
653
                        BKE_reportf(reports, RPT_ERROR, "Already a control point at frame %.6f", frame);
 
654
                        return NULL;
 
655
                }
 
656
 
 
657
                /* realloc memory for extra point */
 
658
                env->data = (FCM_EnvelopeData *) MEM_reallocN((void *)env->data, (env->totvert + 1) * sizeof(FCM_EnvelopeData));
 
659
 
 
660
                /* move the points after the added point */
 
661
                if (i < env->totvert) {
 
662
                        memmove(env->data + i + 1, env->data + i, (env->totvert - i) * sizeof(FCM_EnvelopeData));
 
663
                }
 
664
 
 
665
                env->totvert++;
 
666
        }
 
667
        else {
 
668
                env->data = MEM_mallocN(sizeof(FCM_EnvelopeData), "FCM_EnvelopeData");
 
669
                env->totvert = 1;
 
670
                i = 0;
 
671
        }
 
672
 
 
673
        /* add point to paste at index i */
 
674
        *(env->data + i) = fed;
 
675
        return (env->data + i);
 
676
}
 
677
 
 
678
void rna_FModifierEnvelope_points_remove(FModifier *fmod, ReportList *reports, PointerRNA *point)
 
679
{
 
680
        FCM_EnvelopeData *cp = point->data;
 
681
        FMod_Envelope *env = (FMod_Envelope *)fmod->data;
 
682
 
 
683
        int index = (int)(cp - env->data);
 
684
 
 
685
        /* test point is in range */
 
686
        if (index < 0 || index >= env->totvert) {
 
687
                BKE_report(reports, RPT_ERROR, "Control point not in Envelope F-Modifier");
 
688
                return;
 
689
        }
 
690
 
 
691
        if (env->totvert > 1) {
 
692
                /* move data after the removed point */
 
693
 
 
694
                memmove(env->data + index, env->data + (index + 1), sizeof(FCM_EnvelopeData) * ((env->totvert - index) - 1));
 
695
 
 
696
                /* realloc smaller array */
 
697
                env->totvert--;
 
698
                env->data = (FCM_EnvelopeData *) MEM_reallocN((void *)env->data, (env->totvert) * sizeof(FCM_EnvelopeData));
 
699
        }
 
700
        else {
 
701
                /* just free array, since the only vert was deleted */
 
702
                if (env->data) {
 
703
                        MEM_freeN(env->data);
 
704
                        env->data = NULL;
 
705
                }
 
706
                env->totvert = 0;
 
707
        }
 
708
        RNA_POINTER_INVALIDATE(point);
627
709
}
628
710
 
629
711
#else
636
718
        static EnumPropertyItem generator_mode_items[] = {
637
719
                {FCM_GENERATOR_POLYNOMIAL, "POLYNOMIAL", 0, "Expanded Polynomial", ""},
638
720
                {FCM_GENERATOR_POLYNOMIAL_FACTORISED, "POLYNOMIAL_FACTORISED", 0, "Factorized Polynomial", ""},
639
 
                {0, NULL, 0, NULL, NULL}};
 
721
                {0, NULL, 0, NULL, NULL}
 
722
        };
640
723
        
641
724
        srna = RNA_def_struct(brna, "FModifierGenerator", "FModifier");
642
725
        RNA_def_struct_ui_text(srna, "Generator F-Modifier", "Deterministically generate values for the modified F-Curve");
648
731
        RNA_def_property_ui_text(prop, "Additive",
649
732
                                 "Values generated by this modifier are applied on top of "
650
733
                                 "the existing values instead of overwriting them");
651
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
734
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
652
735
        
653
 
                /* XXX this has a special validation func */
 
736
        /* XXX this has a special validation func */
654
737
        prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
655
738
        RNA_def_property_enum_items(prop, generator_mode_items);
656
739
        RNA_def_property_ui_text(prop, "Mode", "Type of generator to use");
657
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
740
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
658
741
        
659
742
        
660
743
        /* order of the polynomial */
661
 
                /* XXX this has a special validation func */
 
744
        /* XXX this has a special validation func */
662
745
        prop = RNA_def_property(srna, "poly_order", PROP_INT, PROP_NONE);
663
746
        RNA_def_property_ui_text(prop, "Polynomial Order",
664
747
                                 "The highest power of 'x' for this polynomial (number of coefficients - 1)");
665
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
748
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
666
749
        
667
750
        /* coefficients array */
668
751
        prop = RNA_def_property(srna, "coefficients", PROP_FLOAT, PROP_NONE);
687
770
                {2, "TAN", 0, "Tangent", ""},
688
771
                {3, "SQRT", 0, "Square Root", ""},
689
772
                {4, "LN", 0, "Natural Logarithm", ""},
690
 
                {5, "SINC", 0, "Normalised Sine", "sin(x) / x"},
691
 
                {0, NULL, 0, NULL, NULL}};
 
773
                {5, "SINC", 0, "Normalized Sine", "sin(x) / x"},
 
774
                {0, NULL, 0, NULL, NULL}
 
775
        };
692
776
        
693
777
        srna = RNA_def_struct(brna, "FModifierFunctionGenerator", "FModifier");
694
778
        RNA_def_struct_ui_text(srna, "Built-In Function F-Modifier", "Generate values using a Built-In Function");
697
781
        /* coefficients */
698
782
        prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
699
783
        RNA_def_property_ui_text(prop, "Amplitude", "Scale factor determining the maximum/minimum values");
700
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
784
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
701
785
        
702
786
        prop = RNA_def_property(srna, "phase_multiplier", PROP_FLOAT, PROP_NONE);
703
787
        RNA_def_property_ui_text(prop, "Phase Multiplier", "Scale factor determining the 'speed' of the function");
704
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
788
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
705
789
        
706
790
        prop = RNA_def_property(srna, "phase_offset", PROP_FLOAT, PROP_NONE);
707
791
        RNA_def_property_ui_text(prop, "Phase Offset", "Constant factor to offset time by for function");
708
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
792
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
709
793
        
710
794
        prop = RNA_def_property(srna, "value_offset", PROP_FLOAT, PROP_NONE);
711
795
        RNA_def_property_ui_text(prop, "Value Offset", "Constant factor to offset values by");
712
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
796
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
713
797
        
714
798
        /* flags */
715
799
        prop = RNA_def_property(srna, "use_additive", PROP_BOOLEAN, PROP_NONE);
717
801
        RNA_def_property_ui_text(prop, "Additive",
718
802
                                 "Values generated by this modifier are applied on top of "
719
803
                                 "the existing values instead of overwriting them");
720
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
804
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
721
805
        
722
806
        prop = RNA_def_property(srna, "function_type", PROP_ENUM, PROP_NONE);
723
807
        RNA_def_property_enum_sdna(prop, NULL, "type");
724
808
        RNA_def_property_enum_items(prop, prop_type_items);
725
809
        RNA_def_property_ui_text(prop, "Type", "Type of built-in function to use");
726
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
810
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
727
811
}
728
812
 
729
813
/* --------- */
744
828
        prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
745
829
        RNA_def_property_float_sdna(prop, NULL, "min");
746
830
        RNA_def_property_ui_text(prop, "Minimum Value", "Lower bound of envelope at this control-point");
747
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
831
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
748
832
        
749
833
        prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
750
834
        RNA_def_property_float_sdna(prop, NULL, "max");
751
835
        RNA_def_property_ui_text(prop, "Maximum Value", "Upper bound of envelope at this control-point");
752
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
836
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
753
837
        
754
838
        /* Frame */
755
839
        prop = RNA_def_property(srna, "frame", PROP_FLOAT, PROP_TIME);
756
840
        RNA_def_property_float_sdna(prop, NULL, "time");
757
841
        RNA_def_property_ui_text(prop, "Frame", "Frame this control-point occurs on");
758
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
842
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
759
843
        
760
844
        /* TODO: */
761
845
        /*      - selection flags (not implemented in UI yet though) */
762
846
}
763
847
 
 
848
static void rna_def_fmodifier_envelope_control_points(BlenderRNA *brna, PropertyRNA *cprop)
 
849
{
 
850
        StructRNA *srna;
 
851
 
 
852
        FunctionRNA *func;
 
853
        PropertyRNA *parm;
 
854
 
 
855
        RNA_def_property_srna(cprop, "FModifierEnvelopeControlPoints");
 
856
        srna = RNA_def_struct(brna, "FModifierEnvelopeControlPoints", NULL);
 
857
        RNA_def_struct_sdna(srna, "FModifier");
 
858
 
 
859
        RNA_def_struct_ui_text(srna, "Control Points", "Control points defining the shape of the envelope");
 
860
 
 
861
        func = RNA_def_function(srna, "add", "rna_FModifierEnvelope_points_add");
 
862
        RNA_def_function_ui_description(func, "Add a control point to a FModifierEnvelope");
 
863
        RNA_def_function_flag(func, FUNC_USE_REPORTS);
 
864
        parm = RNA_def_float(func, "frame", 0.0f, -FLT_MAX, FLT_MAX, "",
 
865
                             "Frame to add this control-point", -FLT_MAX, FLT_MAX);
 
866
        RNA_def_property_flag(parm, PROP_REQUIRED);
 
867
        parm = RNA_def_pointer(func, "point", "FModifierEnvelopeControlPoint", "", "Newly created control-point");
 
868
        RNA_def_function_return(func, parm);
 
869
 
 
870
        func = RNA_def_function(srna, "remove", "rna_FModifierEnvelope_points_remove");
 
871
        RNA_def_function_ui_description(func, "Remove a control-point from an FModifierEnvelope");
 
872
        RNA_def_function_flag(func, FUNC_USE_REPORTS);
 
873
        parm = RNA_def_pointer(func, "point", "FModifierEnvelopeControlPoint", "", "Control-point to remove");
 
874
        RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
 
875
}
 
876
 
 
877
 
764
878
static void rna_def_fmodifier_envelope(BlenderRNA *brna)
765
879
{
766
880
        StructRNA *srna;
775
889
        RNA_def_property_collection_sdna(prop, NULL, "data", "totvert");
776
890
        RNA_def_property_struct_type(prop, "FModifierEnvelopeControlPoint");
777
891
        RNA_def_property_ui_text(prop, "Control Points", "Control points defining the shape of the envelope");
 
892
        rna_def_fmodifier_envelope_control_points(brna, prop);
778
893
        
779
894
        /* Range Settings */
780
895
        prop = RNA_def_property(srna, "reference_value", PROP_FLOAT, PROP_NONE);
781
896
        RNA_def_property_float_sdna(prop, NULL, "midval");
782
897
        RNA_def_property_ui_text(prop, "Reference Value", "Value that envelope's influence is centered around / based on");
783
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
898
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
784
899
        
785
900
        prop = RNA_def_property(srna, "default_min", PROP_FLOAT, PROP_NONE);
786
901
        RNA_def_property_float_sdna(prop, NULL, "min");
787
902
        RNA_def_property_ui_text(prop, "Default Minimum", "Lower distance from Reference Value for 1:1 default influence");
788
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
903
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
789
904
        
790
905
        prop = RNA_def_property(srna, "default_max", PROP_FLOAT, PROP_NONE);
791
906
        RNA_def_property_float_sdna(prop, NULL, "max");
792
907
        RNA_def_property_ui_text(prop, "Default Maximum", "Upper distance from Reference Value for 1:1 default influence");
793
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
908
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
794
909
}
795
910
 
796
911
/* --------- */
808
923
                                                "start and end values"},
809
924
                {FCM_EXTRAPOLATE_MIRROR, "MIRROR", 0, "Repeat Mirrored",
810
925
                                         "Alternate between forward and reverse playback of keyframe range"},
811
 
                {0, NULL, 0, NULL, NULL}};
 
926
                {0, NULL, 0, NULL, NULL}
 
927
        };
812
928
        
813
929
        srna = RNA_def_struct(brna, "FModifierCycles", "FModifier");
814
930
        RNA_def_struct_ui_text(srna, "Cycles F-Modifier", "Repeat the values of the modified F-Curve");
819
935
        RNA_def_property_enum_sdna(prop, NULL, "before_mode");
820
936
        RNA_def_property_enum_items(prop, prop_type_items);
821
937
        RNA_def_property_ui_text(prop, "Before Mode", "Cycling mode to use before first keyframe");
822
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
938
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
823
939
        
824
940
        prop = RNA_def_property(srna, "cycles_before", PROP_INT, PROP_NONE);
825
941
        RNA_def_property_int_sdna(prop, NULL, "before_cycles");
826
942
        RNA_def_property_ui_text(prop, "Before Cycles",
827
943
                                 "Maximum number of cycles to allow before first keyframe (0 = infinite)");
828
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
944
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
829
945
        
830
946
        /* after */
831
947
        prop = RNA_def_property(srna, "mode_after", PROP_ENUM, PROP_NONE);
832
948
        RNA_def_property_enum_sdna(prop, NULL, "after_mode");
833
949
        RNA_def_property_enum_items(prop, prop_type_items);
834
950
        RNA_def_property_ui_text(prop, "After Mode", "Cycling mode to use after last keyframe");
835
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
951
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
836
952
        
837
953
        prop = RNA_def_property(srna, "cycles_after", PROP_INT, PROP_NONE);
838
954
        RNA_def_property_int_sdna(prop, NULL, "after_cycles");
839
955
        RNA_def_property_ui_text(prop, "After Cycles",
840
956
                                 "Maximum number of cycles to allow after last keyframe (0 = infinite)");
841
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
957
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
842
958
}
843
959
 
844
960
/* --------- */
867
983
        prop = RNA_def_property(srna, "use_min_x", PROP_BOOLEAN, PROP_NONE);
868
984
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMIN);
869
985
        RNA_def_property_ui_text(prop, "Minimum X", "Use the minimum X value");
870
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
986
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
871
987
        
872
988
        prop = RNA_def_property(srna, "use_min_y", PROP_BOOLEAN, PROP_NONE);
873
989
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMIN);
874
990
        RNA_def_property_ui_text(prop, "Minimum Y", "Use the minimum Y value");
875
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
991
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
876
992
        
877
993
        prop = RNA_def_property(srna, "use_max_x", PROP_BOOLEAN, PROP_NONE);
878
994
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMAX);
879
995
        RNA_def_property_ui_text(prop, "Maximum X", "Use the maximum X value");
880
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
996
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
881
997
        
882
998
        prop = RNA_def_property(srna, "use_max_y", PROP_BOOLEAN, PROP_NONE);
883
999
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMAX);
884
1000
        RNA_def_property_ui_text(prop, "Maximum Y", "Use the maximum Y value");
885
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1001
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
886
1002
        
887
1003
        prop = RNA_def_property(srna, "min_x", PROP_FLOAT, PROP_NONE);
888
1004
        RNA_def_property_float_sdna(prop, NULL, "rect.xmin");
889
1005
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_minx_range");
890
1006
        RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow");
891
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1007
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
892
1008
        
893
1009
        prop = RNA_def_property(srna, "min_y", PROP_FLOAT, PROP_NONE);
894
1010
        RNA_def_property_float_sdna(prop, NULL, "rect.ymin");
895
1011
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_miny_range");
896
1012
        RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow");
897
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1013
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
898
1014
        
899
1015
        prop = RNA_def_property(srna, "max_x", PROP_FLOAT, PROP_NONE);
900
1016
        RNA_def_property_float_sdna(prop, NULL, "rect.xmax");
901
1017
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_maxx_range");
902
1018
        RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow");
903
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1019
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
904
1020
        
905
1021
        prop = RNA_def_property(srna, "max_y", PROP_FLOAT, PROP_NONE);
906
1022
        RNA_def_property_float_sdna(prop, NULL, "rect.ymax");
907
1023
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_maxy_range");
908
1024
        RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow");
909
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1025
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
910
1026
}
911
1027
 
912
1028
/* --------- */
921
1037
                {FCM_NOISE_MODIF_ADD, "ADD", 0, "Add", ""},
922
1038
                {FCM_NOISE_MODIF_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
923
1039
                {FCM_NOISE_MODIF_MULTIPLY, "MULTIPLY", 0, "Multiply", ""},
924
 
                {0, NULL, 0, NULL, NULL}};
 
1040
                {0, NULL, 0, NULL, NULL}
 
1041
        };
925
1042
        
926
1043
        srna = RNA_def_struct(brna, "FModifierNoise", "FModifier");
927
1044
        RNA_def_struct_ui_text(srna, "Noise F-Modifier", "Give randomness to the modified F-Curve");
931
1048
        RNA_def_property_enum_sdna(prop, NULL, "modification");
932
1049
        RNA_def_property_enum_items(prop, prop_modification_items);
933
1050
        RNA_def_property_ui_text(prop, "Blend Type", "Method of modifying the existing F-Curve");
934
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1051
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
935
1052
        
936
1053
        prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
937
1054
        RNA_def_property_float_sdna(prop, NULL, "size");
938
1055
        RNA_def_property_ui_text(prop, "Scale", "Scaling (in time) of the noise");
939
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1056
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
940
1057
        
941
1058
        prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
942
1059
        RNA_def_property_float_sdna(prop, NULL, "strength");
943
1060
        RNA_def_property_ui_text(prop, "Strength",
944
1061
                                 "Amplitude of the noise - the amount that it modifies the underlying curve");
945
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1062
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
946
1063
        
947
1064
        prop = RNA_def_property(srna, "phase", PROP_FLOAT, PROP_NONE);
948
1065
        RNA_def_property_float_sdna(prop, NULL, "phase");
949
1066
        RNA_def_property_ui_text(prop, "Phase", "A random seed for the noise effect");
950
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1067
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
951
1068
        
952
1069
        prop = RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
953
1070
        RNA_def_property_int_sdna(prop, NULL, "depth");
954
1071
        RNA_def_property_ui_text(prop, "Depth", "Amount of fine level detail present in the noise");
955
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1072
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
956
1073
 
957
1074
}
958
1075
 
973
1090
        prop = RNA_def_property(srna, "frame_step", PROP_FLOAT, PROP_NONE);
974
1091
        RNA_def_property_float_sdna(prop, NULL, "step_size");
975
1092
        RNA_def_property_ui_text(prop, "Step Size", "Number of frames to hold each value");
976
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1093
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
977
1094
        
978
1095
        prop = RNA_def_property(srna, "frame_offset", PROP_FLOAT, PROP_NONE);
979
1096
        RNA_def_property_float_sdna(prop, NULL, "offset");
980
1097
        RNA_def_property_ui_text(prop, "Offset",
981
1098
                                 "Reference number of frames before frames get held "
982
1099
                                 "(use to get hold for '1-3' vs '5-7' holding patterns)");
983
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1100
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
984
1101
        
985
1102
        prop = RNA_def_property(srna, "use_frame_start", PROP_BOOLEAN, PROP_NONE);
986
1103
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_STEPPED_NO_BEFORE);
987
1104
        RNA_def_property_ui_text(prop, "Use Start Frame", "Restrict modifier to only act after its 'start' frame");
988
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1105
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
989
1106
        
990
1107
        prop = RNA_def_property(srna, "use_frame_end", PROP_BOOLEAN, PROP_NONE);
991
1108
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_STEPPED_NO_AFTER);
992
1109
        RNA_def_property_ui_text(prop, "Use End Frame", "Restrict modifier to only act before its 'end' frame");
993
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1110
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
994
1111
        
995
1112
        prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_NONE);
996
1113
        RNA_def_property_float_sdna(prop, NULL, "start_frame");
997
1114
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierStepped_start_frame_range");
998
1115
        RNA_def_property_ui_text(prop, "Start Frame", "Frame that modifier's influence starts (if applicable)");
999
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1116
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1000
1117
        
1001
1118
        prop = RNA_def_property(srna, "frame_end", PROP_FLOAT, PROP_NONE);
1002
1119
        RNA_def_property_float_sdna(prop, NULL, "end_frame");
1003
1120
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierStepped_end_frame_range");
1004
1121
        RNA_def_property_ui_text(prop, "End Frame", "Frame that modifier's influence ends (if applicable)");
1005
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1122
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1006
1123
}
1007
1124
 
1008
1125
/* --------- */
1019
1136
        RNA_def_struct_ui_text(srna, "F-Modifier", "Modifier for values of F-Curve");
1020
1137
        
1021
1138
#if 0 /* XXX not used yet */
1022
 
        /* name */
 
1139
          /* name */
1023
1140
        prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1024
1141
        RNA_def_struct_name_property(srna, prop);
1025
1142
        RNA_def_property_ui_text(prop, "Name", "Short description of F-Curve Modifier");
1040
1157
        prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1041
1158
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_MUTED);
1042
1159
        RNA_def_property_ui_text(prop, "Muted", "F-Curve Modifier will not be evaluated");
1043
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1160
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1044
1161
        RNA_def_property_ui_icon(prop, ICON_MUTE_IPO_OFF, 1);
1045
1162
        
1046
1163
        prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
1047
1164
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1048
1165
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", FMODIFIER_FLAG_DISABLED);
1049
1166
        RNA_def_property_ui_text(prop, "Disabled", "F-Curve Modifier has invalid settings and will not be evaluated");
1050
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1167
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1051
1168
        
1052
 
                /* TODO: setting this to true must ensure that all others in stack are turned off too... */
 
1169
        /* TODO: setting this to true must ensure that all others in stack are turned off too... */
1053
1170
        prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1054
1171
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_ACTIVE);
1055
1172
        RNA_def_property_ui_text(prop, "Active", "F-Curve Modifier is the one being edited ");
1056
1173
        RNA_def_property_boolean_funcs(prop, NULL, "rna_FModifier_active_set");
1057
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, "rna_FModifier_active_update");
 
1174
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, "rna_FModifier_active_update");
1058
1175
        RNA_def_property_ui_icon(prop, ICON_RADIOBUT_OFF, 1);
1059
1176
        
1060
1177
        /* restricted range */
1063
1180
        RNA_def_property_ui_text(prop, "Restrict Frame Range",
1064
1181
                                 "F-Curve Modifier is only applied for the specified frame range to help "
1065
1182
                                 "mask off effects in order to chain them");
1066
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1183
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1067
1184
        RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1); /* XXX: depends on UI implementation */
1068
1185
        
1069
1186
        prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_NONE);
1071
1188
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifier_start_frame_range");
1072
1189
        RNA_def_property_ui_text(prop, "Start Frame",
1073
1190
                                 "Frame that modifier's influence starts (if Restrict Frame Range is in use)");
1074
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1191
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1075
1192
        
1076
1193
        prop = RNA_def_property(srna, "frame_end", PROP_FLOAT, PROP_NONE);
1077
1194
        RNA_def_property_float_sdna(prop, NULL, "efra");
1078
1195
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifier_end_frame_range");
1079
1196
        RNA_def_property_ui_text(prop, "End Frame",
1080
1197
                                 "Frame that modifier's influence ends (if Restrict Frame Range is in use)");
1081
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1198
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1082
1199
        
1083
1200
        prop = RNA_def_property(srna, "blend_in", PROP_FLOAT, PROP_NONE);
1084
1201
        RNA_def_property_float_sdna(prop, NULL, "blendin");
1085
1202
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifier_blending_range");
1086
1203
        RNA_def_property_ui_text(prop, "Blend In", "Number of frames from start frame for influence to take effect");
1087
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1204
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1088
1205
        
1089
1206
        prop = RNA_def_property(srna, "blend_out", PROP_FLOAT, PROP_NONE);
1090
1207
        RNA_def_property_float_sdna(prop, NULL, "blendout");
1091
1208
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifier_blending_range");
1092
1209
        RNA_def_property_ui_text(prop, "Blend Out", "Number of frames from end frame for influence to fade out");
1093
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1210
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1094
1211
        
1095
1212
        /* influence */
1096
1213
        prop = RNA_def_property(srna, "use_influence", PROP_BOOLEAN, PROP_NONE);
1097
1214
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_USEINFLUENCE);
1098
1215
        RNA_def_property_ui_text(prop, "Use Influence", "F-Curve Modifier's effects will be tempered by a default factor");
1099
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1216
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1100
1217
        RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1); /* XXX: depends on UI implementation */
1101
1218
        
1102
1219
        prop = RNA_def_property(srna, "influence", PROP_FLOAT, PROP_FACTOR);
1105
1222
        RNA_def_property_float_default(prop, 1.0f);
1106
1223
        RNA_def_property_ui_text(prop, "Influence",
1107
1224
                                 "Amount of influence F-Curve Modifier will have when not fading in/out");
1108
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1225
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1109
1226
}
1110
1227
 
1111
1228
/* *********************** */
1125
1242
                {DTAR_TRANSCHAN_SCALEX, "SCALE_X", 0, "X Scale", ""},
1126
1243
                {DTAR_TRANSCHAN_SCALEY, "SCALE_Y", 0, "Y Scale", ""},
1127
1244
                {DTAR_TRANSCHAN_SCALEZ, "SCALE_Z", 0, "Z Scale", ""},
1128
 
                {0, NULL, 0, NULL, NULL}};
 
1245
                {0, NULL, 0, NULL, NULL}
 
1246
        };
1129
1247
                
1130
1248
        static EnumPropertyItem prop_local_space_items[] = {
1131
1249
                {0, "WORLD_SPACE", 0, "World Space", "Transforms include effects of parenting/restpose and constraints"},
1132
1250
                {DTAR_FLAG_LOCALSPACE, "TRANSFORM_SPACE", 0, "Transform Space",
1133
1251
                                       "Transforms don't include parenting/restpose or constraints"},
1134
 
                {DTAR_FLAG_LOCALSPACE|DTAR_FLAG_LOCAL_CONSTS, "LOCAL_SPACE", 0, "Local Space",
1135
 
                                                              "Transforms include effects of constraints but not "
1136
 
                                                              "parenting/restpose"},
1137
 
                {0, NULL, 0, NULL, NULL}};
 
1252
                {DTAR_FLAG_LOCALSPACE | DTAR_FLAG_LOCAL_CONSTS, "LOCAL_SPACE", 0, "Local Space",
 
1253
                                                                "Transforms include effects of constraints but not "
 
1254
                                                                "parenting/restpose"},
 
1255
                {0, NULL, 0, NULL, NULL}
 
1256
        };
1138
1257
        
1139
1258
        srna = RNA_def_struct(brna, "DriverTarget", NULL);
1140
1259
        RNA_def_struct_ui_text(srna, "Driver Target", "Source of input values for driver variables");
1196
1315
                                           "Final transformation value of object or bone"},
1197
1316
                {DVAR_TYPE_ROT_DIFF, "ROTATION_DIFF", 0, "Rotational Difference", "Use the angle between two bones"},
1198
1317
                {DVAR_TYPE_LOC_DIFF, "LOC_DIFF", 0, "Distance", "Distance between two bones or objects"},
1199
 
                {0, NULL, 0, NULL, NULL}};
 
1318
                {0, NULL, 0, NULL, NULL}
 
1319
        };
1200
1320
                
1201
1321
        
1202
1322
        srna = RNA_def_struct(brna, "DriverVariable", NULL);
1246
1366
        /* add variable */
1247
1367
        func = RNA_def_function(srna, "new", "rna_Driver_new_variable");
1248
1368
        RNA_def_function_ui_description(func, "Add a new variable for the driver");
1249
 
                /* return type */
 
1369
        /* return type */
1250
1370
        parm = RNA_def_pointer(func, "var", "DriverVariable", "", "Newly created Driver Variable");
1251
 
                RNA_def_function_return(func, parm);
 
1371
        RNA_def_function_return(func, parm);
1252
1372
 
1253
1373
        /* remove variable */
1254
1374
        func = RNA_def_function(srna, "remove", "rna_Driver_remove_variable");
1256
1376
        RNA_def_function_flag(func, FUNC_USE_REPORTS);
1257
1377
        /* target to remove */
1258
1378
        parm = RNA_def_pointer(func, "variable", "DriverVariable", "", "Variable to remove from the driver");
1259
 
        RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
 
1379
        RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
 
1380
        RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1260
1381
}
1261
1382
 
1262
1383
static void rna_def_channeldriver(BlenderRNA *brna)
1270
1391
                {DRIVER_TYPE_PYTHON, "SCRIPTED", 0, "Scripted Expression", ""},
1271
1392
                {DRIVER_TYPE_MIN, "MIN", 0, "Minimum Value", ""},
1272
1393
                {DRIVER_TYPE_MAX, "MAX", 0, "Maximum Value", ""},
1273
 
                {0, NULL, 0, NULL, NULL}};
 
1394
                {0, NULL, 0, NULL, NULL}
 
1395
        };
1274
1396
 
1275
1397
        srna = RNA_def_struct(brna, "Driver", NULL);
1276
1398
        RNA_def_struct_sdna(srna, "ChannelDriver");
1326
1448
        prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1327
1449
        RNA_def_property_boolean_sdna(prop, NULL, "flag", 1);
1328
1450
        RNA_def_property_ui_text(prop, "Select", "Selection status");
1329
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_SELECTED, NULL);
 
1451
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1330
1452
        
1331
1453
        /* Vector value */
1332
1454
        prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
1333
1455
        RNA_def_property_float_sdna(prop, NULL, "vec");
1334
1456
        RNA_def_property_array(prop, 2);
1335
1457
        RNA_def_property_ui_text(prop, "Point", "Point coordinates");
1336
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1458
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1337
1459
}
1338
1460
 
1339
1461
 
1353
1475
        prop = RNA_def_property(srna, "select_left_handle", PROP_BOOLEAN, PROP_NONE);
1354
1476
        RNA_def_property_boolean_sdna(prop, NULL, "f1", 0);
1355
1477
        RNA_def_property_ui_text(prop, "Handle 1 selected", "Left handle selection status");
1356
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_SELECTED, NULL);
 
1478
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1357
1479
        
1358
1480
        prop = RNA_def_property(srna, "select_right_handle", PROP_BOOLEAN, PROP_NONE);
1359
1481
        RNA_def_property_boolean_sdna(prop, NULL, "f3", 0);
1360
1482
        RNA_def_property_ui_text(prop, "Handle 2 selected", "Right handle selection status");
1361
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_SELECTED, NULL);
 
1483
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1362
1484
        
1363
1485
        prop = RNA_def_property(srna, "select_control_point", PROP_BOOLEAN, PROP_NONE);
1364
1486
        RNA_def_property_boolean_sdna(prop, NULL, "f2", 0);
1365
1487
        RNA_def_property_ui_text(prop, "Select", "Control point selection status");
1366
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_SELECTED, NULL);
 
1488
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1367
1489
        
1368
1490
        /* Enums */
1369
1491
        prop = RNA_def_property(srna, "handle_left_type", PROP_ENUM, PROP_NONE);
1370
1492
        RNA_def_property_enum_sdna(prop, NULL, "h1");
1371
1493
        RNA_def_property_enum_items(prop, keyframe_handle_type_items);
1372
1494
        RNA_def_property_ui_text(prop, "Left Handle Type", "Handle types");
1373
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1495
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1374
1496
        
1375
1497
        prop = RNA_def_property(srna, "handle_right_type", PROP_ENUM, PROP_NONE);
1376
1498
        RNA_def_property_enum_sdna(prop, NULL, "h2");
1377
1499
        RNA_def_property_enum_items(prop, keyframe_handle_type_items);
1378
1500
        RNA_def_property_ui_text(prop, "Right Handle Type", "Handle types");
1379
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1501
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1380
1502
        
1381
1503
        prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
1382
1504
        RNA_def_property_enum_sdna(prop, NULL, "ipo");
1384
1506
        RNA_def_property_ui_text(prop, "Interpolation",
1385
1507
                                 "Interpolation method to use for segment of the F-Curve from "
1386
1508
                                 "this Keyframe until the next Keyframe");
1387
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1509
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1388
1510
        
1389
1511
        prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1390
1512
        RNA_def_property_enum_sdna(prop, NULL, "hide");
1391
1513
        RNA_def_property_enum_items(prop, beztriple_keyframe_type_items);
1392
1514
        RNA_def_property_ui_text(prop, "Type", "Type of keyframe (for visual purposes only)");
1393
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1515
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1394
1516
        
1395
1517
        /* Vector values */
1396
1518
        prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
1397
1519
        RNA_def_property_array(prop, 2);
1398
1520
        RNA_def_property_float_funcs(prop, "rna_FKeyframe_handle1_get", "rna_FKeyframe_handle1_set", NULL);
1399
1521
        RNA_def_property_ui_text(prop, "Left Handle", "Coordinates of the left handle (before the control point)");
1400
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1522
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1401
1523
        
1402
1524
        prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
1403
1525
        RNA_def_property_array(prop, 2);
1404
1526
        RNA_def_property_float_funcs(prop, "rna_FKeyframe_ctrlpoint_get", "rna_FKeyframe_ctrlpoint_set", NULL);
1405
1527
        RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
1406
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1528
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1407
1529
        
1408
1530
        prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_COORDS); /* keyframes are dimensionless */
1409
1531
        RNA_def_property_array(prop, 2);
1410
1532
        RNA_def_property_float_funcs(prop, "rna_FKeyframe_handle2_get", "rna_FKeyframe_handle2_set", NULL);
1411
1533
        RNA_def_property_ui_text(prop, "Right Handle", "Coordinates of the right handle (after the control point)");
1412
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 
1534
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1413
1535
}
1414
1536
 
1415
1537
static void rna_def_fcurve_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
1450
1572
        RNA_def_function_ui_description(func, "Remove a modifier from this F-Curve");
1451
1573
        /* modifier to remove */
1452
1574
        parm = RNA_def_pointer(func, "modifier", "FModifier", "", "Removed modifier");
1453
 
        RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
 
1575
        RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
 
1576
        RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1454
1577
}
1455
1578
 
1456
1579
/* fcurve.keyframe_points */
1465
1588
                {INSERTKEY_REPLACE, "REPLACE", 0, "Replace", "Don't add any new keyframes, but just replace existing ones"},
1466
1589
                {INSERTKEY_NEEDED, "NEEDED", 0, "Needed", "Only adds keyframes that are needed"},
1467
1590
                {INSERTKEY_FAST, "FAST", 0, "Fast", "Fast keyframe insertion to avoid recalculating the curve each time"},
1468
 
                {0, NULL, 0, NULL, NULL}};
 
1591
                {0, NULL, 0, NULL, NULL}
 
1592
        };
1469
1593
 
1470
1594
        RNA_def_property_srna(cprop, "FCurveKeyframePoints");
1471
1595
        srna = RNA_def_struct(brna, "FCurveKeyframePoints", NULL);
1488
1612
 
1489
1613
        func = RNA_def_function(srna, "add", "rna_FKeyframe_points_add");
1490
1614
        RNA_def_function_ui_description(func, "Add a keyframe point to a F-Curve");
1491
 
        RNA_def_int(func, "count", 1, 1, INT_MAX, "Number", "Number of points to add to the spline", 1, INT_MAX);
 
1615
        RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of points to add to the spline", 0, INT_MAX);
1492
1616
 
1493
1617
        func = RNA_def_function(srna, "remove", "rna_FKeyframe_points_remove");
1494
1618
        RNA_def_function_ui_description(func, "Remove keyframe from an F-Curve");
1495
1619
        RNA_def_function_flag(func, FUNC_USE_REPORTS);
1496
1620
        parm = RNA_def_pointer(func, "keyframe", "Keyframe", "", "Keyframe to remove");
1497
 
        RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
 
1621
        RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
 
1622
        RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1498
1623
        /* optional */
1499
1624
        RNA_def_boolean(func, "fast", 0, "Fast", "Fast keyframe removal to avoid recalculating the curve each time");
1500
1625
}
1509
1634
        static EnumPropertyItem prop_mode_extend_items[] = {
1510
1635
                {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant", ""},
1511
1636
                {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear", ""},
1512
 
                {0, NULL, 0, NULL, NULL}};
 
1637
                {0, NULL, 0, NULL, NULL}
 
1638
        };
1513
1639
        static EnumPropertyItem prop_mode_color_items[] = {
1514
1640
                {FCURVE_COLOR_AUTO_RAINBOW, "AUTO_RAINBOW", 0, "Auto Rainbow", ""},
1515
1641
                {FCURVE_COLOR_AUTO_RGB, "AUTO_RGB", 0, "Auto XYZ to RGB", ""},
1516
1642
                {FCURVE_COLOR_CUSTOM, "CUSTOM", 0, "User Defined", ""},
1517
 
                {0, NULL, 0, NULL, NULL}};
 
1643
                {0, NULL, 0, NULL, NULL}
 
1644
        };
1518
1645
 
1519
1646
        srna = RNA_def_struct(brna, "FCurve", NULL);
1520
1647
        RNA_def_struct_ui_text(srna, "F-Curve", "F-Curve defining values of a period of time");
1525
1652
        RNA_def_property_enum_sdna(prop, NULL, "extend");
1526
1653
        RNA_def_property_enum_items(prop, prop_mode_extend_items);
1527
1654
        RNA_def_property_ui_text(prop, "Extrapolation", "");
1528
 
                /* XXX need an update callback for this so that animation gets evaluated */
 
1655
        /* XXX need an update callback for this so that animation gets evaluated */
1529
1656
        RNA_def_property_update(prop, NC_ANIMATION, NULL);
1530
1657
 
1531
1658
        /* Pointers */
1545
1672
        RNA_def_property_string_funcs(prop, "rna_FCurve_RnaPath_get", "rna_FCurve_RnaPath_length",
1546
1673
                                      "rna_FCurve_RnaPath_set");
1547
1674
        RNA_def_property_ui_text(prop, "Data Path", "RNA Path to property affected by F-Curve");
1548
 
                /* XXX need an update callback for this to that animation gets evaluated */
 
1675
        /* XXX need an update callback for this to that animation gets evaluated */
1549
1676
        RNA_def_property_update(prop, NC_ANIMATION, NULL);
1550
1677
 
1551
1678
        /* called 'index' when given as function arg */
1552
1679
        prop = RNA_def_property(srna, "array_index", PROP_INT, PROP_NONE);
1553
1680
        RNA_def_property_ui_text(prop, "RNA Array Index",
1554
1681
                                 "Index to the specific property affected by F-Curve if applicable");
1555
 
                /* XXX need an update callback for this so that animation gets evaluated */
 
1682
        /* XXX need an update callback for this so that animation gets evaluated */
1556
1683
        RNA_def_property_update(prop, NC_ANIMATION, NULL);
1557
1684
        
1558
1685
        /* Color */
1571
1698
        prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1572
1699
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCURVE_SELECTED);
1573
1700
        RNA_def_property_ui_text(prop, "Select", "F-Curve is selected for editing");
1574
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_SELECTED, NULL);
 
1701
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
1575
1702
        
1576
1703
        prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1577
1704
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCURVE_PROTECTED);
1578
1705
        RNA_def_property_ui_text(prop, "Lock", "F-Curve's settings cannot be edited");
1579
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN|NA_EDITED, NULL);
 
1706
        RNA_def_property_update(prop, NC_ANIMATION | ND_ANIMCHAN | NA_EDITED, NULL);
1580
1707
        
1581
1708
        prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1582
1709
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCURVE_MUTED);
1583
1710
        RNA_def_property_ui_text(prop, "Muted", "F-Curve is not evaluated");
1584
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN|NA_EDITED, NULL);
 
1711
        RNA_def_property_update(prop, NC_ANIMATION | ND_ANIMCHAN | NA_EDITED, NULL);
1585
1712
        
1586
1713
        prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1587
1714
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", FCURVE_VISIBLE);
1588
1715
        RNA_def_property_ui_text(prop, "Hide", "F-Curve and its keyframes are hidden in the Graph Editor graphs");
1589
 
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_GRAPH, NULL);
 
1716
        RNA_def_property_update(prop, NC_SPACE | ND_SPACE_GRAPH, NULL);
1590
1717
 
1591
1718
        /* State Info (for Debugging) */
1592
1719
        prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
1594
1721
        RNA_def_property_ui_text(prop, "Valid",
1595
1722
                                 "False when F-Curve could not be evaluated in past, so should be skipped "
1596
1723
                                 "when evaluating");
1597
 
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
 
1724
        RNA_def_property_update(prop, NC_ANIMATION | ND_KEYFRAME_PROP, NULL);
1598
1725
        
1599
1726
        /* Collections */
1600
1727
        prop = RNA_def_property(srna, "sampled_points", PROP_COLLECTION, PROP_NONE);
1637
1764
void RNA_def_fcurve(BlenderRNA *brna)
1638
1765
{
1639
1766
        rna_def_fcurve(brna);
1640
 
                rna_def_fkeyframe(brna);
1641
 
                rna_def_fpoint(brna);
 
1767
        rna_def_fkeyframe(brna);
 
1768
        rna_def_fpoint(brna);
1642
1769
        
1643
1770
        rna_def_drivertarget(brna);
1644
1771
        rna_def_drivervar(brna);
1648
1775
        
1649
1776
        rna_def_fmodifier_generator(brna);
1650
1777
        rna_def_fmodifier_function_generator(brna);
 
1778
 
1651
1779
        rna_def_fmodifier_envelope(brna);
1652
 
                rna_def_fmodifier_envelope_ctrl(brna);
 
1780
        rna_def_fmodifier_envelope_ctrl(brna);
 
1781
 
1653
1782
        rna_def_fmodifier_cycles(brna);
1654
1783
        rna_def_fmodifier_python(brna);
1655
1784
        rna_def_fmodifier_limits(brna);