← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/bmesh/intern/bmesh_marking.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/bmesh/intern/bmesh_marking.c
70
70
}
71
71
 
72
72
/**
 
73
 * \brief Select Mode Clean
 
74
 *
 
75
 * Remove isolated selected elements when in a mode doesn't support them.
 
76
 * eg: in edge-mode a selected vertex must be connected to a selected edge.
 
77
 *
 
78
 * \note this could be made apart of #BM_mesh_select_mode_flush_ex
 
79
 */
 
80
void BM_mesh_select_mode_clean_ex(BMesh *bm, const short selectmode)
 
81
{
 
82
        if (selectmode & SCE_SELECT_VERTEX) {
 
83
                /* pass */
 
84
        }
 
85
        else if (selectmode & SCE_SELECT_EDGE) {
 
86
                BMIter iter;
 
87
 
 
88
                if (bm->totvertsel) {
 
89
                        BMVert *v;
 
90
                        BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
 
91
                                BM_elem_flag_disable(v, BM_ELEM_SELECT);
 
92
                        }
 
93
                        bm->totvertsel = 0;
 
94
                }
 
95
 
 
96
                if (bm->totedgesel) {
 
97
                        BMEdge *e;
 
98
                        BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
 
99
                                if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
 
100
                                        BM_vert_select_set(bm, e->v1, true);
 
101
                                        BM_vert_select_set(bm, e->v2, true);
 
102
                                }
 
103
                        }
 
104
                }
 
105
        }
 
106
        else if (selectmode & SCE_SELECT_FACE) {
 
107
                BMIter iter;
 
108
 
 
109
                if (bm->totvertsel) {
 
110
                        BMVert *v;
 
111
                        BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
 
112
                                BM_elem_flag_disable(v, BM_ELEM_SELECT);
 
113
                        }
 
114
                        bm->totvertsel = 0;
 
115
                }
 
116
 
 
117
                if (bm->totedgesel) {
 
118
                        BMEdge *e;
 
119
                        BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
 
120
                                BM_elem_flag_disable(e, BM_ELEM_SELECT);
 
121
                        }
 
122
                        bm->totedgesel = 0;
 
123
                }
 
124
 
 
125
                if (bm->totfacesel) {
 
126
                        BMFace *f;
 
127
                        BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
 
128
                                if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
 
129
                                        BMLoop *l_iter, *l_first;
 
130
                                        l_iter = l_first = BM_FACE_FIRST_LOOP(f);
 
131
                                        do {
 
132
                                                BM_edge_select_set(bm, l_iter->e, true);
 
133
                                        } while ((l_iter = l_iter->next) != l_first);
 
134
                                }
 
135
                        }
 
136
                }
 
137
        }
 
138
}
 
139
 
 
140
void BM_mesh_select_mode_clean(BMesh *bm)
 
141
{
 
142
        BM_mesh_select_mode_clean_ex(bm, bm->selectmode);
 
143
}
 
144
 
 
145
/**
73
146
 * \brief Select Mode Flush
74
147
 *
75
148
 * Makes sure to flush selections 'upwards'
329
402
                if (BM_elem_flag_test(e, BM_ELEM_SELECT)) bm->totedgesel -= 1;
330
403
                BM_elem_flag_disable(e, BM_ELEM_SELECT);
331
404
 
332
 
                if (bm->selectmode == SCE_SELECT_EDGE ||
333
 
                    bm->selectmode == SCE_SELECT_FACE ||
334
 
                    bm->selectmode == (SCE_SELECT_EDGE | SCE_SELECT_FACE))
335
 
                {
336
 
 
 
405
                if ((bm->selectmode & SCE_SELECT_VERTEX) == 0) {
337
406
                        BMIter iter;
338
407
                        BMVert *verts[2] = {e->v1, e->v2};
339
408
                        BMEdge *e2;
340
409
                        int i;
341
410
 
 
411
                        /* check if the vert is used by a selected edge */
342
412
                        for (i = 0; i < 2; i++) {
343
 
                                int deselect = 1;
 
413
                                bool deselect = true;
344
414
 
345
415
                                for (e2 = BM_iter_new(&iter, bm, BM_EDGES_OF_VERT, verts[i]); e2; e2 = BM_iter_step(&iter)) {
346
416
                                        if (e2 == e) {
348
418
                                        }
349
419
 
350
420
                                        if (BM_elem_flag_test(e2, BM_ELEM_SELECT)) {
351
 
                                                deselect = 0;
 
421
                                                deselect = false;
352
422
                                                break;
353
423
                                        }
354
424
                                }
501
571
        BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
502
572
 
503
573
        if (htype & BM_VERT) {
504
 
                for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); ele; ele = BM_iter_step(&iter)) {
 
574
                BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
505
575
                        if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) continue;
506
576
                        if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) tot++;
507
577
                }
508
578
        }
509
579
        if (htype & BM_EDGE) {
510
 
                for (ele = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); ele; ele = BM_iter_step(&iter)) {
 
580
                BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
511
581
                        if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) continue;
512
582
                        if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) tot++;
513
583
                }
514
584
        }
515
585
        if (htype & BM_FACE) {
516
 
                for (ele = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); ele; ele = BM_iter_step(&iter)) {
 
586
                BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
517
587
                        if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) continue;
518
588
                        if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) tot++;
519
589
                }
746
816
        }
747
817
}
748
818
 
 
819
static BMEditSelection *bm_select_history_create(BMHeader *ele)
 
820
{
 
821
        BMEditSelection *ese = (BMEditSelection *) MEM_callocN(sizeof(BMEditSelection), "BMEdit Selection");
 
822
        ese->htype = ele->htype;
 
823
        ese->ele = (BMElem *)ele;
 
824
        return ese;
 
825
}
749
826
 
750
827
/* --- macro wrapped funcs --- */
751
828
bool _bm_select_history_check(BMesh *bm, const BMHeader *ele)
767
844
 
768
845
void _bm_select_history_store_notest(BMesh *bm, BMHeader *ele)
769
846
{
770
 
        BMEditSelection *ese = (BMEditSelection *) MEM_callocN(sizeof(BMEditSelection), "BMEdit Selection");
771
 
        ese->htype = ele->htype;
772
 
        ese->ele = (BMElem *)ele;
 
847
        BMEditSelection *ese = bm_select_history_create(ele);
773
848
        BLI_addtail(&(bm->selected), ese);
774
849
}
775
850
 
779
854
                BM_select_history_store_notest(bm, (BMElem *)ele);
780
855
        }
781
856
}
 
857
 
 
858
 
 
859
void _bm_select_history_store_after_notest(BMesh *bm, BMEditSelection *ese_ref, BMHeader *ele)
 
860
{
 
861
        BMEditSelection *ese = bm_select_history_create(ele);
 
862
        BLI_insertlinkafter(&(bm->selected), ese_ref, ese);
 
863
}
 
864
 
 
865
void _bm_select_history_store_after(BMesh *bm, BMEditSelection *ese_ref, BMHeader *ele)
 
866
{
 
867
        if (!BM_select_history_check(bm, (BMElem *)ele)) {
 
868
                BM_select_history_store_after_notest(bm, ese_ref, (BMElem *)ele);
 
869
        }
 
870
}
782
871
/* --- end macro wrapped funcs --- */
783
872
 
784
873
 
791
880
 
792
881
void BM_select_history_validate(BMesh *bm)
793
882
{
794
 
        BMEditSelection *ese, *nextese;
795
 
 
796
 
        ese = bm->selected.first;
797
 
 
798
 
        while (ese) {
799
 
                nextese = ese->next;
 
883
        BMEditSelection *ese, *ese_next;
 
884
 
 
885
        for (ese = bm->selected.first; ese; ese = ese_next) {
 
886
                ese_next = ese->next;
800
887
                if (!BM_elem_flag_test(ese->ele, BM_ELEM_SELECT)) {
801
888
                        BLI_freelinkN(&(bm->selected), ese);
802
889
                }
803
 
                ese = nextese;
804
890
        }
805
891
}
806
892