← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/blenkernel/intern/modifier.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2014-02-19 11:24:23 UTC
  • mfrom: (14.2.23 sid)
  • Revision ID: package-import@ubuntu.com-20140219112423-rkmaz2m7ha06d4tk
Tags: 2.69-3ubuntu1
* Merge with Debian; remaining changes:
  - Configure without OpenImageIO on armhf, as it is not available on
    Ubuntu.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/blenkernel/intern/modifier.c
69
69
 
70
70
#include "MOD_modifiertypes.h"
71
71
 
 
72
static ModifierTypeInfo *modifier_types[NUM_MODIFIER_TYPES] = {NULL};
 
73
static VirtualModifierData virtualModifierCommonData;
 
74
 
 
75
void BKE_modifier_init(void)
 
76
{
 
77
        ModifierData *md;
 
78
 
 
79
        /* Initialize modifier types */
 
80
        modifier_type_init(modifier_types); /* MOD_utils.c */
 
81
 
 
82
        /* Initialize global cmmon storage used for virtual modifier list */
 
83
        md = modifier_new(eModifierType_Armature);
 
84
        virtualModifierCommonData.amd = *((ArmatureModifierData *) md);
 
85
        modifier_free(md);
 
86
 
 
87
        md = modifier_new(eModifierType_Curve);
 
88
        virtualModifierCommonData.cmd = *((CurveModifierData *) md);
 
89
        modifier_free(md);
 
90
 
 
91
        md = modifier_new(eModifierType_Lattice);
 
92
        virtualModifierCommonData.lmd = *((LatticeModifierData *) md);
 
93
        modifier_free(md);
 
94
 
 
95
        md = modifier_new(eModifierType_ShapeKey);
 
96
        virtualModifierCommonData.smd = *((ShapeKeyModifierData *) md);
 
97
        modifier_free(md);
 
98
 
 
99
        virtualModifierCommonData.amd.modifier.mode |= eModifierMode_Virtual;
 
100
        virtualModifierCommonData.cmd.modifier.mode |= eModifierMode_Virtual;
 
101
        virtualModifierCommonData.lmd.modifier.mode |= eModifierMode_Virtual;
 
102
        virtualModifierCommonData.smd.modifier.mode |= eModifierMode_Virtual;
 
103
}
 
104
 
72
105
ModifierTypeInfo *modifierType_getInfo(ModifierType type)
73
106
{
74
 
        static ModifierTypeInfo *types[NUM_MODIFIER_TYPES] = {NULL};
75
 
        static int types_init = 1;
76
 
 
77
 
        if (types_init) {
78
 
                modifier_type_init(types); /* MOD_utils.c */
79
 
                types_init = 0;
80
 
        }
81
 
 
82
107
        /* type unsigned, no need to check < 0 */
83
 
        if (type < NUM_MODIFIER_TYPES && types[type]->name[0] != '\0') {
84
 
                return types[type];
 
108
        if (type < NUM_MODIFIER_TYPES && modifier_types[type]->name[0] != '\0') {
 
109
                return modifier_types[type];
85
110
        }
86
111
        else {
87
112
                return NULL;
289
314
 */
290
315
int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *lastPossibleCageIndex_r, int virtual_)
291
316
{
292
 
        ModifierData *md = (virtual_) ? modifiers_getVirtualModifierList(ob) : ob->modifiers.first;
 
317
        VirtualModifierData virtualModifierData;
 
318
        ModifierData *md = (virtual_) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
293
319
        int i, cageIndex = -1;
294
320
 
295
321
        if (lastPossibleCageIndex_r) {
435
461
/* NOTE: This is to support old files from before Blender supported modifiers,
436
462
 * in some cases versioning code updates these so for new files this will
437
463
 * return an empty list. */
438
 
ModifierData *modifiers_getVirtualModifierList(Object *ob)
 
464
ModifierData *modifiers_getVirtualModifierList(Object *ob, VirtualModifierData *virtualModifierData)
439
465
{
440
 
        /* Kinda hacky, but should be fine since we are never
441
 
         * re-entrant and avoid free hassles.
442
 
         */
443
 
        static ArmatureModifierData amd;
444
 
        static CurveModifierData cmd;
445
 
        static LatticeModifierData lmd;
446
 
        static ShapeKeyModifierData smd;
447
 
        static int init = 1;
448
466
        ModifierData *md;
449
467
 
450
 
        if (init) {
451
 
                md = modifier_new(eModifierType_Armature);
452
 
                amd = *((ArmatureModifierData *) md);
453
 
                modifier_free(md);
454
 
 
455
 
                md = modifier_new(eModifierType_Curve);
456
 
                cmd = *((CurveModifierData *) md);
457
 
                modifier_free(md);
458
 
 
459
 
                md = modifier_new(eModifierType_Lattice);
460
 
                lmd = *((LatticeModifierData *) md);
461
 
                modifier_free(md);
462
 
 
463
 
                md = modifier_new(eModifierType_ShapeKey);
464
 
                smd = *((ShapeKeyModifierData *) md);
465
 
                modifier_free(md);
466
 
 
467
 
                amd.modifier.mode |= eModifierMode_Virtual;
468
 
                cmd.modifier.mode |= eModifierMode_Virtual;
469
 
                lmd.modifier.mode |= eModifierMode_Virtual;
470
 
                smd.modifier.mode |= eModifierMode_Virtual;
471
 
 
472
 
                init = 0;
473
 
        }
474
 
 
475
468
        md = ob->modifiers.first;
476
469
 
 
470
        *virtualModifierData = virtualModifierCommonData;
 
471
 
477
472
        if (ob->parent) {
478
473
                if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
479
 
                        amd.object = ob->parent;
480
 
                        amd.modifier.next = md;
481
 
                        amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
482
 
                        md = &amd.modifier;
 
474
                        virtualModifierData->amd.object = ob->parent;
 
475
                        virtualModifierData->amd.modifier.next = md;
 
476
                        virtualModifierData->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
 
477
                        md = &virtualModifierData->amd.modifier;
483
478
                }
484
479
                else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
485
 
                        cmd.object = ob->parent;
486
 
                        cmd.defaxis = ob->trackflag + 1;
487
 
                        cmd.modifier.next = md;
488
 
                        md = &cmd.modifier;
 
480
                        virtualModifierData->cmd.object = ob->parent;
 
481
                        virtualModifierData->cmd.defaxis = ob->trackflag + 1;
 
482
                        virtualModifierData->cmd.modifier.next = md;
 
483
                        md = &virtualModifierData->cmd.modifier;
489
484
                }
490
485
                else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
491
 
                        lmd.object = ob->parent;
492
 
                        lmd.modifier.next = md;
493
 
                        md = &lmd.modifier;
 
486
                        virtualModifierData->lmd.object = ob->parent;
 
487
                        virtualModifierData->lmd.modifier.next = md;
 
488
                        md = &virtualModifierData->lmd.modifier;
494
489
                }
495
490
        }
496
491
 
497
492
        /* shape key modifier, not yet for curves */
498
493
        if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
499
494
                if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
500
 
                        smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
 
495
                        virtualModifierData->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
501
496
                else
502
 
                        smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
 
497
                        virtualModifierData->smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
503
498
 
504
 
                smd.modifier.next = md;
505
 
                md = &smd.modifier;
 
499
                virtualModifierData->smd.modifier.next = md;
 
500
                md = &virtualModifierData->smd.modifier;
506
501
        }
507
502
 
508
503
        return md;
513
508
 */
514
509
Object *modifiers_isDeformedByArmature(Object *ob)
515
510
{
516
 
        ModifierData *md = modifiers_getVirtualModifierList(ob);
 
511
        VirtualModifierData virtualModifierData;
 
512
        ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
517
513
        ArmatureModifierData *amd = NULL;
518
514
        
519
515
        /* return the first selected armature, this lets us use multiple armatures */
536
532
 */
537
533
Object *modifiers_isDeformedByLattice(Object *ob)
538
534
{
539
 
        ModifierData *md = modifiers_getVirtualModifierList(ob);
 
535
        VirtualModifierData virtualModifierData;
 
536
        ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
540
537
        LatticeModifierData *lmd = NULL;
541
538
        
542
539
        /* return the first selected lattice, this lets us use multiple lattices */
559
556
 */
560
557
Object *modifiers_isDeformedByCurve(Object *ob)
561
558
{
562
 
        ModifierData *md = modifiers_getVirtualModifierList(ob);
 
559
        VirtualModifierData virtualModifierData;
 
560
        ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
563
561
        CurveModifierData *cmd = NULL;
564
562
        
565
563
        /* return the first selected curve, this lets us use multiple curves */
579
577
 
580
578
bool modifiers_usesArmature(Object *ob, bArmature *arm)
581
579
{
582
 
        ModifierData *md = modifiers_getVirtualModifierList(ob);
 
580
        VirtualModifierData virtualModifierData;
 
581
        ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
583
582
 
584
583
        for (; md; md = md->next) {
585
584
                if (md->type == eModifierType_Armature) {
594
593
 
595
594
bool modifier_isCorrectableDeformed(ModifierData *md)
596
595
{
597
 
        if (md->type == eModifierType_Armature)
598
 
                return true;
599
 
        if (md->type == eModifierType_ShapeKey)
600
 
                return true;
601
 
        
602
 
        return false;
 
596
        ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 
597
        return (mti->deformMatricesEM != NULL);
603
598
}
604
599
 
605
 
bool modifiers_isCorrectableDeformed(Object *ob)
 
600
bool modifiers_isCorrectableDeformed(struct Scene *scene, Object *ob)
606
601
{
607
 
        ModifierData *md = modifiers_getVirtualModifierList(ob);
 
602
        VirtualModifierData virtualModifierData;
 
603
        ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 
604
        int required_mode = eModifierMode_Realtime;
 
605
 
 
606
        if (ob->mode == OB_MODE_EDIT)
 
607
                required_mode |= eModifierMode_Editmode;
608
608
        
609
609
        for (; md; md = md->next) {
610
 
                if (ob->mode == OB_MODE_EDIT && (md->mode & eModifierMode_Editmode) == 0) {
 
610
                if (!modifier_isEnabled(scene, md, required_mode)) {
611
611
                        /* pass */
612
612
                }
613
613
                else if (modifier_isCorrectableDeformed(md)) {