← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/src/editconstraint.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/src/editconstraint.c
1
1
/**
2
 
 * $Id: editconstraint.c,v 1.15 2004/01/03 03:53:18 hos Exp $
 
2
 * $Id: editconstraint.c,v 1.20 2004/09/05 21:20:03 theeth Exp $
3
3
 *
4
4
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5
5
 *
406
406
                                                        break;
407
407
                                                }
408
408
                                                
 
409
                                                if ( (data->tar == owner) &&
 
410
                                                         (!get_named_bone(get_armature(owner), 
 
411
                                                                                          data->subtarget))) {
 
412
                                                        curcon->flag |= CONSTRAINT_DISABLE;
 
413
                                                        result = 1;
 
414
                                                        break;
 
415
                                                }
409
416
                                                if (add_constraint_element (data->tar, data->subtarget, owner, substring)){
410
417
                                                        curcon->flag |= CONSTRAINT_DISABLE;
411
418
                                                        result = 1;
429
436
                                                        break;
430
437
                                                }
431
438
                                                
 
439
                                                if ( (data->tar == owner) &&
 
440
                                                         (!get_named_bone(get_armature(owner), 
 
441
                                                                                          data->subtarget))) {
 
442
                                                        curcon->flag |= CONSTRAINT_DISABLE;
 
443
                                                        result = 1;
 
444
                                                        break;
 
445
                                                }
432
446
                                                if (add_constraint_element (data->tar, data->subtarget, owner, substring)){
433
447
                                                        curcon->flag |= CONSTRAINT_DISABLE;
434
448
                                                        result = 1;
452
466
                                                        break;
453
467
                                                }
454
468
                                                
 
469
                                                if ( (data->tar == owner) &&
 
470
                                                         (!get_named_bone(get_armature(owner), 
 
471
                                                                                          data->subtarget))) {
 
472
                                                        curcon->flag |= CONSTRAINT_DISABLE;
 
473
                                                        result = 1;
 
474
                                                        break;
 
475
                                                }
455
476
                                                if (add_constraint_element (data->tar, data->subtarget, owner, substring)){
456
477
                                                        curcon->flag |= CONSTRAINT_DISABLE;
457
478
                                                        result = 1;
473
494
                                                        data->tar = NULL;
474
495
                                                        break;
475
496
                                                }
476
 
                                                
 
497
 
 
498
                                                if ( (data->tar == owner) &&
 
499
                                                         (!get_named_bone(get_armature(owner), 
 
500
                                                                                          data->subtarget))) {
 
501
                                                        curcon->flag |= CONSTRAINT_DISABLE;
 
502
                                                        result = 1;
 
503
                                                        break;
 
504
                                                }
477
505
                                                if (add_constraint_element (data->tar, data->subtarget, owner, substring)){
478
506
                                                        curcon->flag |= CONSTRAINT_DISABLE;
479
507
                                                        result = 1;
496
524
                                                        break;
497
525
                                                }
498
526
                                                
 
527
                                                if ( (data->tar == owner) &&
 
528
                                                         (!get_named_bone(get_armature(owner), 
 
529
                                                                                          data->subtarget))) {
 
530
                                                        curcon->flag |= CONSTRAINT_DISABLE;
 
531
                                                        result = 1;
 
532
                                                        break;
 
533
                                                }
499
534
                                                if (typefrom != CONSTRAINT_TYPE_TRACKTO && typefrom != CONSTRAINT_TYPE_LOCKTRACK){
500
535
                                                        if (add_constraint_element (data->tar, data->subtarget, owner, substring)){
501
536
                                                                curcon->flag |= CONSTRAINT_DISABLE;
537
572
                                                        break;
538
573
                                                }
539
574
                                                
 
575
                                                if ( (data->tar == owner) &&
 
576
                                                         (!get_named_bone(get_armature(owner), 
 
577
                                                                                          data->subtarget))) {
 
578
                                                        curcon->flag |= CONSTRAINT_DISABLE;
 
579
                                                        result = 1;
 
580
                                                        break;
 
581
                                                }
540
582
                                                if (typefrom != CONSTRAINT_TYPE_TRACKTO && typefrom != CONSTRAINT_TYPE_LOCKTRACK){
541
583
                                                        if (add_constraint_element (data->tar, data->subtarget, owner, substring)){
542
584
                                                                curcon->flag |= CONSTRAINT_DISABLE;
569
611
                                                }
570
612
                                        }
571
613
                                        break;
 
614
                                case CONSTRAINT_TYPE_STRETCHTO:
 
615
                                        {
 
616
                                                bStretchToConstraint *data = curcon->data;
 
617
                                        
 
618
                                                if (!exist_object(data->tar)){
 
619
                                                        data->tar = NULL;
 
620
                                                        break;
 
621
                                                }
 
622
 
 
623
                                                if ( (data->tar == owner) &&
 
624
                                                         (!get_named_bone(get_armature(owner), 
 
625
                                                                                          data->subtarget))) {
 
626
                                                        curcon->flag |= CONSTRAINT_DISABLE;
 
627
                                                        result = 1;
 
628
                                                        break;
 
629
                                                }
 
630
                                                if (detect_constraint_loop (data->tar, data->subtarget, disable, CONSTRAINT_TYPE_LOCKTRACK)){
 
631
                                                        curcon->flag |= CONSTRAINT_DISABLE;
 
632
                                                        result = 1;
 
633
                                                        break;
 
634
                                                        //              return 1;
 
635
                                                }
 
636
                                        }
 
637
                                        break;
572
638
                                case CONSTRAINT_TYPE_FOLLOWPATH:
573
639
                                        {
574
640
                                                bFollowPathConstraint *data = curcon->data;
818
884
                        if (data->tar==target) return data->subtarget;
819
885
                }
820
886
                break;
 
887
                case CONSTRAINT_TYPE_STRETCHTO:
 
888
                {
 
889
                        bStretchToConstraint *data = constraint->data;
 
890
                        if (data->tar==target) return data->subtarget;
 
891
                }
 
892
                break;
821
893
                case CONSTRAINT_TYPE_FOLLOWPATH: 
822
894
                        /* wonder if this is relevent, since this constraint 
823
895
                         * cannot have a subtarget - theeth 
834
906
        return NULL;  
835
907
}
836
908
 
837
 
Object *get_con_target(bConstraint *constraint)
838
 
{
839
 
        /*
840
 
         * If the target for this constraint is target, return a pointer 
841
 
         * to the name for this constraints subtarget ... NULL otherwise
842
 
         */
843
 
        switch (constraint->type) {
844
 
 
845
 
                case CONSTRAINT_TYPE_ACTION:
846
 
                {
847
 
                        bActionConstraint *data = constraint->data;
848
 
                        return data->tar;
849
 
                }
850
 
                break;
851
 
                case CONSTRAINT_TYPE_LOCLIKE:
852
 
                {
853
 
                        bLocateLikeConstraint *data = constraint->data;
854
 
                        return data->tar;
855
 
                }
856
 
                break;
857
 
                case CONSTRAINT_TYPE_ROTLIKE:
858
 
                {
859
 
                        bRotateLikeConstraint *data = constraint->data;
860
 
                        return data->tar;
861
 
                }
862
 
                break;
863
 
                case CONSTRAINT_TYPE_KINEMATIC:
864
 
                {
865
 
                        bKinematicConstraint *data = constraint->data;
866
 
                        return data->tar;
867
 
                }
868
 
                break;
869
 
                case CONSTRAINT_TYPE_TRACKTO:
870
 
                {
871
 
                        bTrackToConstraint *data = constraint->data;
872
 
                        return data->tar;
873
 
                }
874
 
                break;
875
 
                case CONSTRAINT_TYPE_LOCKTRACK:
876
 
                {
877
 
                        bLockTrackConstraint *data = constraint->data;
878
 
                        return data->tar;
879
 
                }
880
 
                break;
881
 
                case CONSTRAINT_TYPE_FOLLOWPATH: 
882
 
                {
883
 
                        bFollowPathConstraint *data = constraint->data;
884
 
                        return data->tar;
885
 
                }
886
 
                break;
887
 
        }
888
 
        
889
 
        return NULL;  
890
 
}