← Back to branch summary

~ubuntu-branches/ubuntu/utopic/blender/utopic-proposed

« back to all changes in this revision

Viewing changes to source/blender/bmesh/intern/bmesh_walkers_impl.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_walkers_impl.c
26
26
 * BMesh Walker Code.
27
27
 */
28
28
 
 
29
#include <string.h>
 
30
 
29
31
#include "BLI_utildefines.h"
30
32
 
31
33
#include "BKE_customdata.h"
34
36
#include "intern/bmesh_private.h"
35
37
#include "intern/bmesh_walkers_private.h"
36
38
 
 
39
/* pop into stack memory (common operation) */
 
40
#define BMW_state_remove_r(walker, owalk)  { \
 
41
        memcpy(owalk, BMW_current_state(walker), sizeof(*(owalk))); \
 
42
        BMW_state_remove(walker); \
 
43
} (void)0
 
44
 
37
45
static bool bmw_mask_check_vert(BMWalker *walker, BMVert *v)
38
46
{
39
47
        if ((walker->flag & BMW_FLAG_TEST_HIDDEN) && BM_elem_flag_test(v, BM_ELEM_HIDDEN)) {
85
93
{
86
94
        BMwShellWalker *shellWalk = NULL;
87
95
 
88
 
        if (BLI_ghash_haskey(walker->visithash, e)) {
 
96
        if (BLI_gset_haskey(walker->visit_set, e)) {
89
97
                return;
90
98
        }
91
99
 
95
103
 
96
104
        shellWalk = BMW_state_add(walker);
97
105
        shellWalk->curedge = e;
98
 
        BLI_ghash_insert(walker->visithash, e, NULL);
 
106
        BLI_gset_insert(walker->visit_set, e);
99
107
}
100
108
 
101
109
static void bmw_ShellWalker_begin(BMWalker *walker, void *data)
140
148
 
141
149
static void *bmw_ShellWalker_step(BMWalker *walker)
142
150
{
143
 
        BMwShellWalker *swalk = BMW_current_state(walker);
 
151
        BMwShellWalker *swalk, owalk;
144
152
        BMEdge *e, *e2;
145
153
        BMVert *v;
146
154
        BMIter iter;
147
155
        int i;
148
156
 
 
157
        BMW_state_remove_r(walker, &owalk);
 
158
        swalk = &owalk;
 
159
 
149
160
        e = swalk->curedge;
150
 
        BMW_state_remove(walker);
151
161
 
152
162
        for (i = 0; i < 2; i++) {
153
163
                v = i ? e->v2 : e->v1;
167
177
        bool restrictpass = true;
168
178
        BMwShellWalker shellWalk = *((BMwShellWalker *)BMW_current_state(walker));
169
179
        
170
 
        if (!BLI_ghash_haskey(walker->visithash, shellWalk.base)) {
171
 
                BLI_ghash_insert(walker->visithash, shellWalk.base, NULL);
 
180
        if (!BLI_gset_haskey(walker->visit_set, shellWalk.base)) {
 
181
                BLI_gset_insert(walker->visit_set, shellWalk.base);
172
182
        }
173
183
 
174
184
        BMW_state_remove(walker);
177
187
        /* find the next edge whose other vertex has not been visite */
178
188
        curedge = shellWalk.curedge;
179
189
        do {
180
 
                if (!BLI_ghash_haskey(walker->visithash, curedge)) {
 
190
                if (!BLI_gset_haskey(walker->visit_set, curedge)) {
181
191
                        if (!walker->restrictflag ||
182
192
                            (walker->restrictflag && BMO_elem_flag_test(walker->bm, curedge, walker->restrictflag)))
183
193
                        {
187
197
                                
188
198
                                /* push a new state onto the stac */
189
199
                                newState = BMW_state_add(walker);
190
 
                                BLI_ghash_insert(walker->visithash, curedge, NULL);
 
200
                                BLI_gset_insert(walker->visit_set, curedge);
191
201
                                
192
202
                                /* populate the new stat */
193
203
 
211
221
{
212
222
        BMwConnectedVertexWalker *vwalk;
213
223
 
214
 
        if (BLI_ghash_haskey(walker->visithash, v)) {
 
224
        if (BLI_gset_haskey(walker->visit_set, v)) {
215
225
                /* already visited */
216
226
                return;
217
227
        }
223
233
 
224
234
        vwalk = BMW_state_add(walker);
225
235
        vwalk->curvert = v;
226
 
        BLI_ghash_insert(walker->visithash, v, NULL);
 
236
        BLI_gset_insert(walker->visit_set, v);
227
237
}
228
238
 
229
239
static void bmw_ConnectedVertexWalker_begin(BMWalker *walker, void *data)
240
250
 
241
251
static void *bmw_ConnectedVertexWalker_step(BMWalker *walker)
242
252
{
243
 
        BMwConnectedVertexWalker *vwalk = BMW_current_state(walker);
 
253
        BMwConnectedVertexWalker *vwalk, owalk;
244
254
        BMVert *v, *v2;
245
255
        BMEdge *e;
246
256
        BMIter iter;
247
257
 
 
258
        BMW_state_remove_r(walker, &owalk);
 
259
        vwalk = &owalk;
 
260
 
248
261
        v = vwalk->curvert;
249
262
 
250
 
        BMW_state_remove(walker);
251
 
 
252
263
        BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
253
264
                v2 = BM_edge_other_vert(e, v);
254
 
                if (!BLI_ghash_haskey(walker->visithash, v2)) {
 
265
                if (!BLI_gset_haskey(walker->visit_set, v2)) {
255
266
                        bmw_ConnectedVertexWalker_visitVertex(walker, v2);
256
267
                }
257
268
        }
276
287
        iwalk->base = iwalk->curloop = l;
277
288
        iwalk->lastv = l->v;
278
289
 
279
 
        BLI_ghash_insert(walker->visithash, data, NULL);
 
290
        BLI_gset_insert(walker->visit_set, data);
280
291
 
281
292
}
282
293
 
289
300
 
290
301
static void *bmw_IslandboundWalker_step(BMWalker *walker)
291
302
{
292
 
        BMwIslandboundWalker *iwalk = BMW_current_state(walker), owalk;
 
303
        BMwIslandboundWalker *iwalk, owalk;
293
304
        BMVert *v;
294
 
        BMEdge *e = iwalk->curloop->e;
 
305
        BMEdge *e;
295
306
        BMFace *f;
296
 
        BMLoop *l = iwalk->curloop;
 
307
        BMLoop *l;
297
308
        /* int found = 0; */
298
309
 
299
 
        owalk = *iwalk;
 
310
        memcpy(&owalk, BMW_current_state(walker), sizeof(owalk));
 
311
        /* normally we'd remove here, but delay until after error checking */
 
312
        iwalk = &owalk;
 
313
 
 
314
        l = iwalk->curloop;
 
315
        e = l->e;
300
316
 
301
317
        v = BM_edge_other_vert(e, iwalk->lastv);
302
318
 
307
323
                return NULL;
308
324
        }
309
325
        
310
 
        /* pop off current stat */
 
326
        /* pop off current state */
311
327
        BMW_state_remove(walker);
312
328
        
313
329
        f = l->f;
334
350
        if (l == owalk.curloop) {
335
351
                return NULL;
336
352
        }
337
 
        else if (BLI_ghash_haskey(walker->visithash, l)) {
 
353
        else if (BLI_gset_haskey(walker->visit_set, l)) {
338
354
                return owalk.curloop;
339
355
        }
340
356
 
341
 
        BLI_ghash_insert(walker->visithash, l, NULL);
 
357
        BLI_gset_insert(walker->visit_set, l);
342
358
        iwalk = BMW_state_add(walker);
343
359
        iwalk->base = owalk.base;
344
360
 
367
383
        }
368
384
 
369
385
        iwalk = BMW_state_add(walker);
370
 
        BLI_ghash_insert(walker->visithash, data, NULL);
 
386
        BLI_gset_insert(walker->visit_set, data);
371
387
 
372
388
        iwalk->cur = data;
373
389
}
381
397
 
382
398
static void *bmw_IslandWalker_step(BMWalker *walker)
383
399
{
384
 
        BMwIslandWalker *iwalk = BMW_current_state(walker);
385
 
        /* BMwIslandWalker *owalk = iwalk; */ /* UNUSED */
 
400
        BMwIslandWalker *iwalk, owalk;
386
401
        BMIter iter, liter;
387
 
        BMFace *f, *curf = iwalk->cur;
 
402
        BMFace *f;
388
403
        BMLoop *l;
389
404
        
390
 
        BMW_state_remove(walker);
 
405
        BMW_state_remove_r(walker, &owalk);
 
406
        iwalk = &owalk;
391
407
 
392
408
        l = BM_iter_new(&liter, walker->bm, BM_LOOPS_OF_FACE, iwalk->cur);
393
409
        for ( ; l; l = BM_iter_step(&liter)) {
403
419
                                continue;
404
420
                        }
405
421
 
406
 
                        /* saves checking BLI_ghash_haskey below (manifold edges theres a 50% chance) */
 
422
                        /* saves checking BLI_gset_haskey below (manifold edges theres a 50% chance) */
407
423
                        if (f == iwalk->cur) {
408
424
                                continue;
409
425
                        }
410
426
 
411
 
                        if (BLI_ghash_haskey(walker->visithash, f)) {
 
427
                        if (BLI_gset_haskey(walker->visit_set, f)) {
412
428
                                continue;
413
429
                        }
414
430
                        
415
431
                        iwalk = BMW_state_add(walker);
416
432
                        iwalk->cur = f;
417
 
                        BLI_ghash_insert(walker->visithash, f, NULL);
 
433
                        BLI_gset_insert(walker->visit_set, f);
418
434
                        break;
419
435
                }
420
436
        }
421
437
        
422
 
        return curf;
 
438
        return owalk.cur;
423
439
}
424
440
 
425
441
 
448
464
        v = e->v1;
449
465
 
450
466
        lwalk = BMW_state_add(walker);
451
 
        BLI_ghash_insert(walker->visithash, e, NULL);
 
467
        BLI_gset_insert(walker->visit_set, e);
452
468
 
453
469
        lwalk->cur = lwalk->start = e;
454
470
        lwalk->lastv = lwalk->startv = v;
494
510
 
495
511
        lwalk->lastv = lwalk->startv = BM_edge_other_vert(owalk.cur, lwalk->lastv);
496
512
 
497
 
        BLI_ghash_free(walker->visithash, NULL, NULL);
498
 
        walker->visithash = BLI_ghash_ptr_new("bmesh walkers 2");
499
 
        BLI_ghash_insert(walker->visithash, owalk.cur, NULL);
 
513
        BLI_gset_clear(walker->visit_set, NULL);
 
514
        BLI_gset_insert(walker->visit_set, owalk.cur);
500
515
}
501
516
 
502
517
static void *bmw_LoopWalker_yield(BMWalker *walker)
508
523
 
509
524
static void *bmw_LoopWalker_step(BMWalker *walker)
510
525
{
511
 
        BMwLoopWalker *lwalk = BMW_current_state(walker), owalk;
512
 
        BMEdge *e = lwalk->cur, *nexte = NULL;
 
526
        BMwLoopWalker *lwalk, owalk;
 
527
        BMEdge *e, *nexte = NULL;
513
528
        BMLoop *l;
514
529
        BMVert *v;
515
530
        int i = 0;
516
531
 
517
 
        owalk = *lwalk;
518
 
        BMW_state_remove(walker);
 
532
        BMW_state_remove_r(walker, &owalk);
 
533
        lwalk = &owalk;
519
534
 
 
535
        e = lwalk->cur;
520
536
        l = e->l;
521
537
 
522
538
        if (owalk.f_hub) { /* NGON EDGE */
531
547
                        nexte = BM_edge_exists(v, l->v);
532
548
 
533
549
                        if (bmw_mask_check_edge(walker, nexte) &&
534
 
                            !BLI_ghash_haskey(walker->visithash, nexte) &&
 
550
                            !BLI_gset_haskey(walker->visit_set, nexte) &&
535
551
                            /* never step onto a boundary edge, this gives odd-results */
536
552
                            (BM_edge_is_boundary(nexte) == false))
537
553
                        {
543
559
                                lwalk->is_single = owalk.is_single;
544
560
                                lwalk->f_hub = owalk.f_hub;
545
561
 
546
 
                                BLI_ghash_insert(walker->visithash, nexte, NULL);
 
562
                                BLI_gset_insert(walker->visit_set, nexte);
547
563
                        }
548
564
                }
549
565
        }
557
573
                        BM_ITER_ELEM (nexte, &eiter, v, BM_EDGES_OF_VERT) {
558
574
                                if ((nexte->l == NULL) &&
559
575
                                    bmw_mask_check_edge(walker, nexte) &&
560
 
                                    !BLI_ghash_haskey(walker->visithash, nexte))
 
576
                                    !BLI_gset_haskey(walker->visit_set, nexte))
561
577
                                {
562
578
                                        lwalk = BMW_state_add(walker);
563
579
                                        lwalk->cur = nexte;
567
583
                                        lwalk->is_single = owalk.is_single;
568
584
                                        lwalk->f_hub = owalk.f_hub;
569
585
 
570
 
                                        BLI_ghash_insert(walker->visithash, nexte, NULL);
 
586
                                        BLI_gset_insert(walker->visit_set, nexte);
571
587
                                }
572
588
                        }
573
589
                }
602
618
                if (l != NULL) {
603
619
                        if (l != e->l &&
604
620
                            bmw_mask_check_edge(walker, l->e) &&
605
 
                            !BLI_ghash_haskey(walker->visithash, l->e))
 
621
                            !BLI_gset_haskey(walker->visit_set, l->e))
606
622
                        {
607
623
                                lwalk = BMW_state_add(walker);
608
624
                                lwalk->cur = l->e;
612
628
                                lwalk->is_single = owalk.is_single;
613
629
                                lwalk->f_hub = owalk.f_hub;
614
630
 
615
 
                                BLI_ghash_insert(walker->visithash, l->e, NULL);
 
631
                                BLI_gset_insert(walker->visit_set, l->e);
616
632
                        }
617
633
                }
618
634
        }
655
671
                if (l != NULL) {
656
672
                        if (l != e->l &&
657
673
                            bmw_mask_check_edge(walker, l->e) &&
658
 
                            !BLI_ghash_haskey(walker->visithash, l->e))
 
674
                            !BLI_gset_haskey(walker->visit_set, l->e))
659
675
                        {
660
676
                                lwalk = BMW_state_add(walker);
661
677
                                lwalk->cur = l->e;
665
681
                                lwalk->is_single = owalk.is_single;
666
682
                                lwalk->f_hub = owalk.f_hub;
667
683
 
668
 
                                BLI_ghash_insert(walker->visithash, l->e, NULL);
 
684
                                BLI_gset_insert(walker->visit_set, l->e);
669
685
                        }
670
686
                }
671
687
        }
694
710
                return false;
695
711
        }
696
712
 
697
 
        /* the face must not have been already visite */
698
 
        if (BLI_ghash_haskey(walker->visithash, l->f) && BLI_ghash_haskey(walker->secvisithash, l->e)) {
 
713
        /* the face must not have been already visited */
 
714
        if (BLI_gset_haskey(walker->visit_set, l->f) && BLI_gset_haskey(walker->visit_set_alt, l->e)) {
699
715
                return false;
700
716
        }
701
717
 
739
755
        lwalk = BMW_state_add(walker);
740
756
        lwalk->l = e->l;
741
757
        lwalk->no_calc = false;
742
 
        BLI_ghash_insert(walker->visithash, lwalk->l->f, NULL);
 
758
        BLI_gset_insert(walker->visit_set, lwalk->l->f);
743
759
 
744
 
        /* rewin */
 
760
        /* rewind */
745
761
        while ((owalk_pt = BMW_current_state(walker))) {
746
762
                owalk = *((BMwFaceLoopWalker *)owalk_pt);
747
763
                BMW_walk(walker);
751
767
        *lwalk = owalk;
752
768
        lwalk->no_calc = false;
753
769
 
754
 
        BLI_ghash_free(walker->secvisithash, NULL, NULL);
755
 
        walker->secvisithash = BLI_ghash_ptr_new("bmesh walkers 3");
756
 
        BLI_ghash_insert(walker->visithash, lwalk->l->e, NULL);
 
770
        BLI_gset_clear(walker->visit_set_alt, NULL);
 
771
        BLI_gset_insert(walker->visit_set_alt, lwalk->l->e);
757
772
 
758
 
        BLI_ghash_free(walker->visithash, NULL, NULL);
759
 
        walker->visithash = BLI_ghash_ptr_new("bmesh walkers 3");
760
 
        BLI_ghash_insert(walker->visithash, lwalk->l->f, NULL);
 
773
        BLI_gset_clear(walker->visit_set, NULL);
 
774
        BLI_gset_insert(walker->visit_set, lwalk->l->f);
761
775
}
762
776
 
763
777
static void *bmw_FaceLoopWalker_yield(BMWalker *walker)
773
787
 
774
788
static void *bmw_FaceLoopWalker_step(BMWalker *walker)
775
789
{
776
 
        BMwFaceLoopWalker *lwalk = BMW_current_state(walker);
777
 
        BMFace *f = lwalk->l->f;
778
 
        BMLoop *l = lwalk->l, *origl = lwalk->l;
779
 
 
780
 
        BMW_state_remove(walker);
781
 
 
782
 
        l = l->radial_next;
 
790
        BMwFaceLoopWalker *lwalk, owalk;
 
791
        BMFace *f;
 
792
        BMLoop *l;
 
793
 
 
794
        BMW_state_remove_r(walker, &owalk);
 
795
        lwalk = &owalk;
 
796
 
 
797
        f = lwalk->l->f;
 
798
        l = lwalk->l->radial_next;
783
799
        
784
800
        if (lwalk->no_calc) {
785
801
                return f;
800
816
 
801
817
                if (l->f->len != 4) {
802
818
                        lwalk->no_calc = true;
803
 
                        lwalk->l = origl;
 
819
                        lwalk->l = owalk.l;
804
820
                }
805
821
                else {
806
822
                        lwalk->no_calc = false;
807
823
                }
808
824
 
809
 
                BLI_ghash_insert(walker->secvisithash, l->e, NULL);
810
 
                BLI_ghash_insert(walker->visithash, l->f, NULL);
 
825
                /* both may already exist */
 
826
                BLI_gset_reinsert(walker->visit_set_alt, l->e, NULL);
 
827
                BLI_gset_reinsert(walker->visit_set, l->f, NULL);
811
828
        }
812
829
 
813
830
        return f;
838
855
                lwalk->wireedge = NULL;
839
856
        }
840
857
 
841
 
        BLI_ghash_insert(walker->visithash, lwalk->l->e, NULL);
 
858
        BLI_gset_insert(walker->visit_set, lwalk->l->e);
842
859
 
843
860
        /* rewind */
844
861
        while ((owalk_pt = BMW_current_state(walker))) {
858
875
                lwalk->l = lwalk->l->radial_next;
859
876
        }
860
877
 
861
 
        BLI_ghash_free(walker->visithash, NULL, NULL);
862
 
        walker->visithash = BLI_ghash_ptr_new("bmesh walkers 4");
863
 
        BLI_ghash_insert(walker->visithash, lwalk->l->e, NULL);
 
878
        BLI_gset_clear(walker->visit_set, NULL);
 
879
        BLI_gset_insert(walker->visit_set, lwalk->l->e);
864
880
}
865
881
 
866
882
static void *bmw_EdgeringWalker_yield(BMWalker *walker)
881
897
 
882
898
static void *bmw_EdgeringWalker_step(BMWalker *walker)
883
899
{
884
 
        BMwEdgeringWalker *lwalk = BMW_current_state(walker);
885
 
        BMEdge *e, *wireedge = lwalk->wireedge;
886
 
        BMLoop *l = lwalk->l, *origl = lwalk->l;
 
900
        BMwEdgeringWalker *lwalk, owalk;
 
901
        BMEdge *e;
 
902
        BMLoop *l;
887
903
#ifdef BMW_EDGERING_NGON
888
904
        int i, len;
889
905
#endif
890
906
 
891
907
#define EDGE_CHECK(e) (bmw_mask_check_edge(walker, e) && (BM_edge_is_boundary(e) || BM_edge_is_manifold(e)))
892
908
 
893
 
        BMW_state_remove(walker);
 
909
        BMW_state_remove_r(walker, &owalk);
 
910
        lwalk = &owalk;
894
911
 
 
912
        l = lwalk->l;
895
913
        if (!l)
896
 
                return wireedge;
 
914
                return lwalk->wireedge;
897
915
 
898
916
        e = l->e;
899
917
        if (!EDGE_CHECK(e)) {
916
934
        if ((len <= 0) || (len % 2 != 0) || !EDGE_CHECK(l->e) ||
917
935
                !bmw_mask_check_face(walker, l->f))
918
936
        {
919
 
                l = origl;
 
937
                l = owalk.l;
920
938
                i = len;
921
939
                while (i > 0) {
922
940
                        l = l->next;
925
943
        }
926
944
        /* only walk to manifold edge */
927
945
        if ((l->f->len % 2 == 0) && EDGE_CHECK(l->e) &&
928
 
            !BLI_ghash_haskey(walker->visithash, l->e))
 
946
            !BLI_gset_haskey(walker->visit_set, l->e))
929
947
 
930
948
#else
931
949
 
933
951
        l = l->next->next;
934
952
        
935
953
        if ((l->f->len != 4) || !EDGE_CHECK(l->e) || !bmw_mask_check_face(walker, l->f)) {
936
 
                l = origl->next->next;
 
954
                l = owalk.l->next->next;
937
955
        }
938
956
        /* only walk to manifold edge */
939
957
        if ((l->f->len == 4) && EDGE_CHECK(l->e) &&
940
 
            !BLI_ghash_haskey(walker->visithash, l->e))
 
958
            !BLI_gset_haskey(walker->visit_set, l->e))
941
959
#endif
942
960
        {
943
961
                lwalk = BMW_state_add(walker);
944
962
                lwalk->l = l;
945
963
                lwalk->wireedge = NULL;
946
964
 
947
 
                BLI_ghash_insert(walker->visithash, l->e, NULL);
 
965
                BLI_gset_insert(walker->visit_set, l->e);
948
966
        }
949
967
 
950
968
        return e;
957
975
        BMwUVEdgeWalker *lwalk;
958
976
        BMLoop *l = data;
959
977
 
960
 
        if (BLI_ghash_haskey(walker->visithash, l))
 
978
        if (BLI_gset_haskey(walker->visit_set, l))
961
979
                return;
962
980
 
963
981
        lwalk = BMW_state_add(walker);
964
982
        lwalk->l = l;
965
 
        BLI_ghash_insert(walker->visithash, l, NULL);
 
983
        BLI_gset_insert(walker->visit_set, l);
966
984
}
967
985
 
968
986
static void *bmw_UVEdgeWalker_yield(BMWalker *walker)
978
996
 
979
997
static void *bmw_UVEdgeWalker_step(BMWalker *walker)
980
998
{
981
 
        BMwUVEdgeWalker *lwalk = BMW_current_state(walker);
 
999
        const int type = walker->bm->ldata.layers[walker->layer].type;
 
1000
        BMwUVEdgeWalker *lwalk, owalk;
982
1001
        BMLoop *l, *l2, *l3, *nl, *cl;
983
1002
        BMIter liter;
984
1003
        void *d1, *d2;
985
 
        int i, j, rlen, type;
 
1004
        int i, j, rlen;
 
1005
 
 
1006
        BMW_state_remove_r(walker, &owalk);
 
1007
        lwalk = &owalk;
986
1008
 
987
1009
        l = lwalk->l;
988
1010
        nl = l->next;
989
 
        type = walker->bm->ldata.layers[walker->layer].type;
990
 
 
991
 
        BMW_state_remove(walker);
992
1011
 
993
1012
        if (!bmw_mask_check_edge(walker, l->e)) {
994
1013
                return l;
1004
1023
                        
1005
1024
                        rlen = BM_edge_face_count(l2->e);
1006
1025
                        for (j = 0; j < rlen; j++) {
1007
 
                                if (BLI_ghash_haskey(walker->visithash, l2)) {
 
1026
                                if (BLI_gset_haskey(walker->visit_set, l2)) {
1008
1027
                                        continue;
1009
1028
                                }
1010
1029
 
1022
1041
                                        continue;
1023
1042
                                
1024
1043
                                lwalk = BMW_state_add(walker);
1025
 
                                BLI_ghash_insert(walker->visithash, l2, NULL);
 
1044
                                BLI_gset_insert(walker->visit_set, l2);
1026
1045
 
1027
1046
                                lwalk->l = l2;
1028
1047