← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/bmesh/intern/bmesh_construct.c

  • Committer: Reinhard Tartler
  • Date: 2014-05-31 01:50:05 UTC
  • mfrom: (14.2.27 sid)
  • Revision ID: siretart@tauware.de-20140531015005-ml6druahuj82nsav
merge from debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/bmesh/intern/bmesh_construct.c
394
394
        float far_cross_vec[3];
395
395
        float sign_vec[3]; /* work out if we are pos/neg angle */
396
396
 
397
 
        float far_dist, far_best;
 
397
        float far_dist_sq, far_dist_max_sq;
398
398
        float far_cross_dist, far_cross_best = 0.0f;
399
399
 
400
400
        /* get the center point and collect vector array since we loop over these a lot */
405
405
 
406
406
 
407
407
        /* find the far point from cent */
408
 
        far_best = 0.0f;
 
408
        far_dist_max_sq = 0.0f;
409
409
        for (i = 0; i < len; i++) {
410
 
                far_dist = len_squared_v3v3(vert_arr[i]->co, cent);
411
 
                if (far_dist > far_best || far == NULL) {
 
410
                far_dist_sq = len_squared_v3v3(vert_arr[i]->co, cent);
 
411
                if (far_dist_sq > far_dist_max_sq || far == NULL) {
412
412
                        far = vert_arr[i]->co;
413
 
                        far_best = far_dist;
 
413
                        far_dist_max_sq = far_dist_sq;
414
414
                }
415
415
        }
416
416
 
494
494
        return f;
495
495
}
496
496
 
497
 
/**
498
 
 * Called by operators to remove elements that they have marked for
499
 
 * removal.
500
 
 */
501
 
void BMO_remove_tagged_faces(BMesh *bm, const short oflag)
502
 
{
503
 
        BMFace *f, *f_next;
504
 
        BMIter iter;
505
 
 
506
 
        BM_ITER_MESH_MUTABLE (f, f_next, &iter, bm, BM_FACES_OF_MESH) {
507
 
                if (BMO_elem_flag_test(bm, f, oflag)) {
508
 
                        BM_face_kill(bm, f);
509
 
                }
510
 
        }
511
 
}
512
 
 
513
 
void BMO_remove_tagged_edges(BMesh *bm, const short oflag)
514
 
{
515
 
        BMEdge *e, *e_next;
516
 
        BMIter iter;
517
 
 
518
 
        BM_ITER_MESH_MUTABLE (e, e_next, &iter, bm, BM_EDGES_OF_MESH) {
519
 
                if (BMO_elem_flag_test(bm, e, oflag)) {
520
 
                        BM_edge_kill(bm, e);
521
 
                }
522
 
        }
523
 
}
524
 
 
525
 
void BMO_remove_tagged_verts(BMesh *bm, const short oflag)
526
 
{
527
 
        BMVert *v, *v_next;
528
 
        BMIter iter;
529
 
 
530
 
        BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) {
531
 
                if (BMO_elem_flag_test(bm, v, oflag)) {
532
 
                        BM_vert_kill(bm, v);
533
 
                }
534
 
        }
535
 
}
536
 
 
537
 
/**
538
 
 * you need to make remove tagged verts/edges/faces
539
 
 * api functions that take a filter callback.....
540
 
 * and this new filter type will be for opstack flags.
541
 
 * This is because the BM_remove_taggedXXX functions bypass iterator API.
542
 
 *  - Ops don't care about 'UI' considerations like selection state, hide state, etc.
543
 
 *    If you want to work on unhidden selections for instance,
544
 
 *    copy output from a 'select context' operator to another operator....
545
 
 */
546
 
 
547
 
static void bmo_remove_tagged_context_verts(BMesh *bm, const short oflag)
548
 
{
549
 
        BMVert *v;
550
 
        BMEdge *e;
551
 
        BMFace *f;
552
 
 
553
 
        BMIter iter;
554
 
        BMIter itersub;
555
 
 
556
 
        BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
557
 
                if (BMO_elem_flag_test(bm, v, oflag)) {
558
 
                        /* Visit edge */
559
 
                        BM_ITER_ELEM (e, &itersub, v, BM_EDGES_OF_VERT) {
560
 
                                BMO_elem_flag_enable(bm, e, oflag);
561
 
                        }
562
 
                        /* Visit face */
563
 
                        BM_ITER_ELEM (f, &itersub, v, BM_FACES_OF_VERT) {
564
 
                                BMO_elem_flag_enable(bm, f, oflag);
565
 
                        }
566
 
                }
567
 
        }
568
 
 
569
 
        BMO_remove_tagged_faces(bm, oflag);
570
 
        BMO_remove_tagged_edges(bm, oflag);
571
 
        BMO_remove_tagged_verts(bm, oflag);
572
 
}
573
 
 
574
 
static void bmo_remove_tagged_context_edges(BMesh *bm, const short oflag)
575
 
{
576
 
        BMEdge *e;
577
 
        BMFace *f;
578
 
 
579
 
        BMIter iter;
580
 
        BMIter itersub;
581
 
 
582
 
        BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
583
 
                if (BMO_elem_flag_test(bm, e, oflag)) {
584
 
                        BM_ITER_ELEM (f, &itersub, e, BM_FACES_OF_EDGE) {
585
 
                                BMO_elem_flag_enable(bm, f, oflag);
586
 
                        }
587
 
                }
588
 
        }
589
 
        BMO_remove_tagged_faces(bm, oflag);
590
 
        BMO_remove_tagged_edges(bm, oflag);
591
 
}
592
 
 
593
 
#define DEL_WIREVERT    (1 << 10)
594
 
 
595
 
/**
596
 
 * \warning oflag applies to different types in some contexts,
597
 
 * not just the type being removed.
598
 
 *
599
 
 * \warning take care, uses operator flag DEL_WIREVERT
600
 
 */
601
 
void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
602
 
{
603
 
        BMVert *v;
604
 
        BMEdge *e;
605
 
        BMFace *f;
606
 
 
607
 
        BMIter viter;
608
 
        BMIter eiter;
609
 
        BMIter fiter;
610
 
 
611
 
        switch (type) {
612
 
                case DEL_VERTS:
613
 
                {
614
 
                        bmo_remove_tagged_context_verts(bm, oflag);
615
 
 
616
 
                        break;
617
 
                }
618
 
                case DEL_EDGES:
619
 
                {
620
 
                        /* flush down to vert */
621
 
                        BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
622
 
                                if (BMO_elem_flag_test(bm, e, oflag)) {
623
 
                                        BMO_elem_flag_enable(bm, e->v1, oflag);
624
 
                                        BMO_elem_flag_enable(bm, e->v2, oflag);
625
 
                                }
626
 
                        }
627
 
                        bmo_remove_tagged_context_edges(bm, oflag);
628
 
                        /* remove loose vertice */
629
 
                        BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
630
 
                                if (BMO_elem_flag_test(bm, v, oflag) && (!(v->e)))
631
 
                                        BMO_elem_flag_enable(bm, v, DEL_WIREVERT);
632
 
                        }
633
 
                        BMO_remove_tagged_verts(bm, DEL_WIREVERT);
634
 
 
635
 
                        break;
636
 
                }
637
 
                case DEL_EDGESFACES:
638
 
                {
639
 
                        bmo_remove_tagged_context_edges(bm, oflag);
640
 
 
641
 
                        break;
642
 
                }
643
 
                case DEL_ONLYFACES:
644
 
                {
645
 
                        BMO_remove_tagged_faces(bm, oflag);
646
 
 
647
 
                        break;
648
 
                }
649
 
                case DEL_ONLYTAGGED:
650
 
                {
651
 
                        BMO_remove_tagged_faces(bm, oflag);
652
 
                        BMO_remove_tagged_edges(bm, oflag);
653
 
                        BMO_remove_tagged_verts(bm, oflag);
654
 
 
655
 
                        break;
656
 
                }
657
 
                case DEL_FACES:
658
 
                {
659
 
                        /* go through and mark all edges and all verts of all faces for delete */
660
 
                        BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
661
 
                                if (BMO_elem_flag_test(bm, f, oflag)) {
662
 
                                        for (e = BM_iter_new(&eiter, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&eiter))
663
 
                                                BMO_elem_flag_enable(bm, e, oflag);
664
 
                                        for (v = BM_iter_new(&viter, bm, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&viter))
665
 
                                                BMO_elem_flag_enable(bm, v, oflag);
666
 
                                }
667
 
                        }
668
 
                        /* now go through and mark all remaining faces all edges for keeping */
669
 
                        BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
670
 
                                if (!BMO_elem_flag_test(bm, f, oflag)) {
671
 
                                        for (e = BM_iter_new(&eiter, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&eiter)) {
672
 
                                                BMO_elem_flag_disable(bm, e, oflag);
673
 
                                        }
674
 
                                        for (v = BM_iter_new(&viter, bm, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&viter)) {
675
 
                                                BMO_elem_flag_disable(bm, v, oflag);
676
 
                                        }
677
 
                                }
678
 
                        }
679
 
                        /* also mark all the vertices of remaining edges for keeping */
680
 
                        BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
681
 
                                if (!BMO_elem_flag_test(bm, e, oflag)) {
682
 
                                        BMO_elem_flag_disable(bm, e->v1, oflag);
683
 
                                        BMO_elem_flag_disable(bm, e->v2, oflag);
684
 
                                }
685
 
                        }
686
 
                        /* now delete marked face */
687
 
                        BMO_remove_tagged_faces(bm, oflag);
688
 
                        /* delete marked edge */
689
 
                        BMO_remove_tagged_edges(bm, oflag);
690
 
                        /* remove loose vertice */
691
 
                        BMO_remove_tagged_verts(bm, oflag);
692
 
 
693
 
                        break;
694
 
                }
695
 
                case DEL_ALL:
696
 
                {
697
 
                        /* does this option even belong in here? */
698
 
                        BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
699
 
                                BMO_elem_flag_enable(bm, f, oflag);
700
 
                        }
701
 
                        BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
702
 
                                BMO_elem_flag_enable(bm, e, oflag);
703
 
                        }
704
 
                        BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
705
 
                                BMO_elem_flag_enable(bm, v, oflag);
706
 
                        }
707
 
 
708
 
                        BMO_remove_tagged_faces(bm, oflag);
709
 
                        BMO_remove_tagged_edges(bm, oflag);
710
 
                        BMO_remove_tagged_verts(bm, oflag);
711
 
 
712
 
                        break;
713
 
                }
714
 
        }
715
 
}
716
497
/*************************************************************/
717
498
 
718
499