← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/bmesh/intern/bmesh_mesh_conv.c
98
98
#include "bmesh.h"
99
99
#include "intern/bmesh_private.h" /* for element checking */
100
100
 
101
 
/* Mesh -> BMesh */
102
 
void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
 
101
void BM_mesh_cd_flag_ensure(BMesh *bm, Mesh *mesh, const char cd_flag)
 
102
{
 
103
        const char cd_flag_all = BM_mesh_cd_flag_from_bmesh(bm) | cd_flag;
 
104
        BM_mesh_cd_flag_apply(bm, cd_flag_all);
 
105
        if (mesh) {
 
106
                mesh->cd_flag = cd_flag_all;
 
107
        }
 
108
}
 
109
 
 
110
void BM_mesh_cd_flag_apply(BMesh *bm, const char cd_flag)
 
111
{
 
112
        /* CustomData_bmesh_init_pool() must run first */
 
113
        BLI_assert(bm->vdata.totlayer == 0 || bm->vdata.pool != NULL);
 
114
        BLI_assert(bm->edata.totlayer == 0 || bm->edata.pool != NULL);
 
115
 
 
116
        if (cd_flag & ME_CDFLAG_VERT_BWEIGHT) {
 
117
                if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
 
118
                        BM_data_layer_add(bm, &bm->vdata, CD_BWEIGHT);
 
119
                }
 
120
        }
 
121
        else {
 
122
                if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
 
123
                        BM_data_layer_free(bm, &bm->vdata, CD_BWEIGHT);
 
124
                }
 
125
        }
 
126
 
 
127
        if (cd_flag & ME_CDFLAG_EDGE_BWEIGHT) {
 
128
                if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
 
129
                        BM_data_layer_add(bm, &bm->edata, CD_BWEIGHT);
 
130
                }
 
131
        }
 
132
        else {
 
133
                if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
 
134
                        BM_data_layer_free(bm, &bm->edata, CD_BWEIGHT);
 
135
                }
 
136
        }
 
137
 
 
138
        if (cd_flag & ME_CDFLAG_EDGE_CREASE) {
 
139
                if (!CustomData_has_layer(&bm->edata, CD_CREASE)) {
 
140
                        BM_data_layer_add(bm, &bm->edata, CD_CREASE);
 
141
                }
 
142
        }
 
143
        else {
 
144
                if (CustomData_has_layer(&bm->edata, CD_CREASE)) {
 
145
                        BM_data_layer_free(bm, &bm->edata, CD_CREASE);
 
146
                }
 
147
        }
 
148
}
 
149
 
 
150
char BM_mesh_cd_flag_from_bmesh(BMesh *bm)
 
151
{
 
152
        char cd_flag = 0;
 
153
        if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
 
154
                cd_flag |= ME_CDFLAG_VERT_BWEIGHT;
 
155
        }
 
156
        if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
 
157
                cd_flag |= ME_CDFLAG_EDGE_BWEIGHT;
 
158
        }
 
159
        if (CustomData_has_layer(&bm->edata, CD_CREASE)) {
 
160
                cd_flag |= ME_CDFLAG_EDGE_CREASE;
 
161
        }
 
162
        return cd_flag;
 
163
}
 
164
 
 
165
/**
 
166
 * \brief Mesh -> BMesh
 
167
 *
 
168
 * \warning This function doesn't calculate face normals.
 
169
 */
 
170
void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, bool set_key, int act_key_nr)
103
171
{
104
172
        MVert *mvert;
105
173
        BLI_array_declare(verts);
110
178
        BMVert *v, **vt = NULL, **verts = NULL;
111
179
        BMEdge *e, **fedges = NULL, **et = NULL;
112
180
        BMFace *f;
113
 
        BMLoop *l;
114
181
        BLI_array_declare(fedges);
115
182
        float (*keyco)[3] = NULL;
116
183
        int *keyi;
117
184
        int totuv, i, j;
118
185
 
 
186
        int cd_vert_bweight_offset;
 
187
        int cd_edge_bweight_offset;
 
188
        int cd_edge_crease_offset;
 
189
 
119
190
        /* free custom data */
120
191
        /* this isnt needed in most cases but do just incase */
121
192
        CustomData_free(&bm->vdata, bm->totvert);
152
223
                CustomData_set_layer_name(&bm->ldata, CD_MLOOPUV, i, bm->pdata.layers[li].name);
153
224
        }
154
225
 
155
 
        if (!CustomData_has_layer(&bm->edata, CD_CREASE))
156
 
                CustomData_add_layer(&bm->edata, CD_CREASE, CD_ASSIGN, NULL, 0);
157
 
 
158
 
        if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT))
159
 
                CustomData_add_layer(&bm->edata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
160
 
 
161
 
        if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT))
162
 
                CustomData_add_layer(&bm->vdata, CD_BWEIGHT, CD_ASSIGN, NULL, 0);
163
 
 
164
226
        if ((act_key_nr != 0) && (me->key != NULL)) {
165
227
                actkey = BLI_findlink(&me->key->block, act_key_nr - 1);
166
228
        }
205
267
        CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP);
206
268
        CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE);
207
269
 
 
270
        BM_mesh_cd_flag_apply(bm, me->cd_flag);
 
271
 
 
272
        cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
 
273
        cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
 
274
        cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
 
275
 
208
276
        for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
209
 
                v = BM_vert_create(bm, keyco && set_key ? keyco[i] : mvert->co, NULL);
 
277
                v = BM_vert_create(bm, keyco && set_key ? keyco[i] : mvert->co, NULL, BM_CREATE_SKIP_CD);
210
278
                BM_elem_index_set(v, i); /* set_ok */
211
279
                vt[i] = v;
212
280
 
215
283
 
216
284
                /* this is necessary for selection counts to work properly */
217
285
                if (mvert->flag & SELECT) {
218
 
                        BM_vert_select_set(bm, v, TRUE);
 
286
                        BM_vert_select_set(bm, v, true);
219
287
                }
220
288
 
221
289
                normal_short_to_float_v3(v->no, mvert->no);
222
290
 
223
 
                BM_elem_float_data_set(&bm->vdata, v, CD_BWEIGHT, (float)mvert->bweight / 255.0f);
 
291
                /* Copy Custom Data */
 
292
                CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data, true);
224
293
 
225
 
                /* Copy Custom Dat */
226
 
                CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data);
 
294
                if (cd_vert_bweight_offset != -1) BM_ELEM_CD_SET_FLOAT(v, cd_vert_bweight_offset, (float)mvert->bweight / 255.0f);
227
295
 
228
296
                /* set shapekey data */
229
297
                if (me->key) {
254
322
 
255
323
        medge = me->medge;
256
324
        for (i = 0; i < me->totedge; i++, medge++) {
257
 
                e = BM_edge_create(bm, vt[medge->v1], vt[medge->v2], NULL, FALSE);
 
325
                e = BM_edge_create(bm, vt[medge->v1], vt[medge->v2], NULL, BM_CREATE_SKIP_CD);
258
326
                BM_elem_index_set(e, i); /* set_ok */
259
327
                et[i] = e;
260
328
 
263
331
 
264
332
                /* this is necessary for selection counts to work properly */
265
333
                if (medge->flag & SELECT) {
266
 
                        BM_edge_select_set(bm, e, TRUE);
 
334
                        BM_edge_select_set(bm, e, true);
267
335
                }
268
336
 
269
337
                /* Copy Custom Data */
270
 
                CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data);
271
 
 
272
 
                BM_elem_float_data_set(&bm->edata, e, CD_CREASE, (float)medge->crease / 255.0f);
273
 
                BM_elem_float_data_set(&bm->edata, e, CD_BWEIGHT, (float)medge->bweight / 255.0f);
 
338
                CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data, true);
 
339
 
 
340
                if (cd_edge_bweight_offset != -1) BM_ELEM_CD_SET_FLOAT(e, cd_edge_bweight_offset, (float)medge->bweight / 255.0f);
 
341
                if (cd_edge_crease_offset  != -1) BM_ELEM_CD_SET_FLOAT(e, cd_edge_crease_offset,  (float)medge->crease  / 255.0f);
 
342
 
274
343
        }
275
344
 
276
345
        bm->elem_index_dirty &= ~BM_EDGE; /* added in order, clear dirty flag */
277
346
 
278
347
        mpoly = me->mpoly;
279
348
        for (i = 0; i < me->totpoly; i++, mpoly++) {
280
 
                BMIter iter;
 
349
                BMLoop *l_iter;
 
350
                BMLoop *l_first;
281
351
 
282
352
                BLI_array_empty(fedges);
283
353
                BLI_array_empty(verts);
284
354
 
285
 
                BLI_array_growitems(fedges, mpoly->totloop);
286
 
                BLI_array_growitems(verts, mpoly->totloop);
 
355
                BLI_array_grow_items(fedges, mpoly->totloop);
 
356
                BLI_array_grow_items(verts, mpoly->totloop);
287
357
 
288
358
                for (j = 0; j < mpoly->totloop; j++) {
289
359
                        ml = &me->mloop[mpoly->loopstart + j];
312
382
                }
313
383
#endif
314
384
 
315
 
                f = BM_face_create(bm, verts, fedges, mpoly->totloop, FALSE);
 
385
                f = BM_face_create(bm, verts, fedges, mpoly->totloop, BM_CREATE_SKIP_CD);
316
386
 
317
 
                if (!f) {
 
387
                if (UNLIKELY(f == NULL)) {
318
388
                        printf("%s: Warning! Bad face in mesh"
319
389
                               " \"%s\" at index %d!, skipping\n",
320
390
                               __func__, me->id.name + 2, i);
329
399
 
330
400
                /* this is necessary for selection counts to work properly */
331
401
                if (mpoly->flag & ME_FACE_SEL) {
332
 
                        BM_face_select_set(bm, f, TRUE);
 
402
                        BM_face_select_set(bm, f, true);
333
403
                }
334
404
 
335
405
                f->mat_nr = mpoly->mat_nr;
336
406
                if (i == me->act_face) bm->act_face = f;
337
407
 
338
 
                j = 0;
339
 
                BM_ITER_ELEM_INDEX (l, &iter, f, BM_LOOPS_OF_FACE, j) {
 
408
                j = mpoly->loopstart;
 
409
                l_iter = l_first = BM_FACE_FIRST_LOOP(f);
 
410
                do {
340
411
                        /* Save index of correspsonding MLoop */
341
 
                        BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */
342
 
                }
 
412
                        CustomData_to_bmesh_block(&me->ldata, &bm->ldata, j++, &l_iter->head.data, true);
 
413
                } while ((l_iter = l_iter->next) != l_first);
343
414
 
344
415
                /* Copy Custom Data */
345
 
                CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data);
 
416
                CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data, true);
346
417
        }
347
418
 
348
419
        bm->elem_index_dirty &= ~BM_FACE; /* added in order, clear dirty flag */
349
420
 
350
 
        {
351
 
                BMIter fiter;
352
 
                BMIter liter;
353
 
 
354
 
                /* Copy over loop CustomData. Doing this in a separate loop isn't necessary
355
 
                 * but is an optimization, to avoid copying a bunch of interpolated customdata
356
 
                 * for each BMLoop (from previous BMLoops using the same edge), always followed
357
 
                 * by freeing the interpolated data and overwriting it with data from the Mesh. */
358
 
                BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
359
 
                        BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
360
 
                                int li = BM_elem_index_get(l);
361
 
                                CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
362
 
                                BM_elem_index_set(l, 0); /* set_loop */
363
 
                        }
364
 
                }
365
 
        }
366
 
 
367
421
        if (me->mselect && me->totselect != 0) {
368
422
 
369
 
                BMVert **vert_array = MEM_callocN(sizeof(BMVert *) * bm->totvert,
370
 
                                                  "Selection Conversion Vertex Pointer Array");
371
 
                BMEdge **edge_array = MEM_callocN(sizeof(BMEdge *) * bm->totedge,
372
 
                                                  "Selection Conversion Edge Pointer Array");
373
 
                BMFace **face_array = MEM_callocN(sizeof(BMFace *) * bm->totface,
374
 
                                                  "Selection Conversion Face Pointer Array");
375
 
 
376
 
                BMIter  iter;
377
 
                BMVert  *vert;
378
 
                BMEdge  *edge;
379
 
                BMFace  *face;
 
423
                BMVert **vert_array = MEM_mallocN(sizeof(BMVert *) * bm->totvert, "VSelConv");
 
424
                BMEdge **edge_array = MEM_mallocN(sizeof(BMEdge *) * bm->totedge, "ESelConv");
 
425
                BMFace **face_array = MEM_mallocN(sizeof(BMFace *) * bm->totface, "FSelConv");
380
426
                MSelect *msel;
381
427
 
382
 
                BM_ITER_MESH_INDEX (vert, &iter, bm, BM_VERTS_OF_MESH, i) { vert_array[i] = vert; }
383
 
                BM_ITER_MESH_INDEX (edge, &iter, bm, BM_EDGES_OF_MESH, i) { edge_array[i] = edge; }
384
 
                BM_ITER_MESH_INDEX (face, &iter, bm, BM_FACES_OF_MESH, i) { face_array[i] = face; }
 
428
#pragma omp parallel sections if (bm->totvert + bm->totedge + bm->totface >= BM_OMP_LIMIT)
 
429
                {
 
430
#pragma omp section
 
431
                        { BM_iter_as_array(bm, BM_VERTS_OF_MESH, NULL, (void **)vert_array, bm->totvert); }
 
432
#pragma omp section
 
433
                        { BM_iter_as_array(bm, BM_EDGES_OF_MESH, NULL, (void **)edge_array, bm->totedge); }
 
434
#pragma omp section
 
435
                        { BM_iter_as_array(bm, BM_FACES_OF_MESH, NULL, (void **)face_array, bm->totface); }
 
436
                }
385
437
 
386
438
                for (i = 0, msel = me->mselect; i < me->totselect; i++, msel++) {
387
439
                        switch (msel->type) {
417
469
}
418
470
 
419
471
 
420
 
/* BMesh -> Mesh */
 
472
/**
 
473
 * \brief BMesh -> Mesh
 
474
 */
421
475
static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
422
476
{
423
477
        BMVert **vertMap = NULL;
495
549
        {
496
550
                med->flag &= ~ME_EDGEDRAW;
497
551
        }
 
552
        else {
 
553
                med->flag |= ME_EDGEDRAW;
 
554
        }
498
555
}
499
556
 
500
 
void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
 
557
void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, bool do_tessface)
501
558
{
502
559
        MLoop *mloop;
503
560
        MPoly *mpoly;
510
567
        BMIter iter, liter;
511
568
        int i, j, ototvert;
512
569
 
 
570
        const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
 
571
        const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
 
572
        const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
 
573
 
513
574
        ototvert = me->totvert;
514
575
 
515
576
        /* new vertex block */
533
594
        oldverts = me->mvert;
534
595
 
535
596
        /* don't free this yet */
536
 
        CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
 
597
        if (oldverts) {
 
598
                CustomData_set_layer(&me->vdata, CD_MVERT, NULL);
 
599
        }
537
600
 
538
601
        /* free custom data */
539
602
        CustomData_free(&me->vdata, me->totvert);
562
625
        CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop);
563
626
        CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly);
564
627
 
 
628
        me->cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
 
629
 
565
630
        /* this is called again, 'dotess' arg is used there */
566
631
        mesh_update_customdata_pointers(me, 0);
567
632
 
568
633
        i = 0;
569
634
        BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
570
 
                float *bweight = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_BWEIGHT);
571
 
 
572
 
                mvert->bweight = bweight ? (char)((*bweight) * 255) : 0;
573
 
 
574
635
                copy_v3_v3(mvert->co, v->co);
575
636
                normal_float_to_short_v3(mvert->no, v->no);
576
637
 
581
642
                /* copy over customdat */
582
643
                CustomData_from_bmesh_block(&bm->vdata, &me->vdata, v->head.data, i);
583
644
 
 
645
                if (cd_vert_bweight_offset != -1) mvert->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(v, cd_vert_bweight_offset);
 
646
 
584
647
                i++;
585
648
                mvert++;
586
649
 
591
654
        med = medge;
592
655
        i = 0;
593
656
        BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
594
 
                float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE);
595
 
                float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT);
596
 
 
597
657
                med->v1 = BM_elem_index_get(e->v1);
598
658
                med->v2 = BM_elem_index_get(e->v2);
599
 
                med->crease = crease ? (char)((*crease) * 255) : 0;
600
 
                med->bweight = bweight ? (char)((*bweight) * 255) : 0;
601
659
 
602
660
                med->flag = BM_edge_flag_to_mflag(e);
603
661
 
608
666
 
609
667
                bmesh_quick_edgedraw_flag(med, e);
610
668
 
 
669
                if (cd_edge_crease_offset  != -1) med->crease  = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(e, cd_edge_crease_offset);
 
670
                if (cd_edge_bweight_offset != -1) med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(e, cd_edge_bweight_offset);
 
671
 
611
672
                i++;
612
673
                med++;
613
674
                BM_CHECK_ELEMENT(e);
701
762
                if (vertMap) MEM_freeN(vertMap);
702
763
        }
703
764
 
704
 
        if (dotess) {
 
765
        if (do_tessface) {
705
766
                BKE_mesh_tessface_calc(me);
706
767
        }
707
768
 
708
 
        mesh_update_customdata_pointers(me, dotess);
 
769
        mesh_update_customdata_pointers(me, do_tessface);
709
770
 
710
771
        {
711
772
                BMEditSelection *selected;
755
816
                        }
756
817
 
757
818
                        if (!currkey) {
758
 
                                currkey = add_keyblock(me->key, bm->vdata.layers[i].name);
 
819
                                currkey = BKE_keyblock_add(me->key, bm->vdata.layers[i].name);
759
820
                                currkey->uid = bm->vdata.layers[i].uid;
760
821
                        }
761
822
 
765
826
 
766
827
                /* editing the base key should update others */
767
828
                if ((me->key->type == KEY_RELATIVE) && /* only need offsets for relative shape keys */
768
 
                    (actkey   != NULL) &&              /* unlikely, but the active key may not be valid if the
 
829
                    (actkey != NULL) &&                /* unlikely, but the active key may not be valid if the
769
830
                                                        * bmesh and the mesh are out of sync */
770
831
                    (oldverts != NULL))                /* not used here, but 'oldverts' is used later for applying 'ofs' */
771
832
                {
772
 
                        int act_is_basis = FALSE;
 
833
                        bool act_is_basis = false;
773
834
 
774
835
                        /* find if this key is a basis for any others */
775
836
                        for (currkey = me->key->block.first; currkey; currkey = currkey->next) {
776
837
                                if (bm->shapenr - 1 == currkey->relative) {
777
 
                                        act_is_basis = TRUE;
 
838
                                        act_is_basis = true;
778
839
                                        break;
779
840
                                }
780
841
                        }
790
851
                                        if (keyi && *keyi != ORIGINDEX_NONE) {
791
852
                                                sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
792
853
                                        }
 
854
                                        else {
 
855
                                                /* if there are new vertices in the mesh, we can't propagate the offset
 
856
                                                 * because it will only work for the existing vertices and not the new
 
857
                                                 * ones, creating a mess when doing e.g. subdivide + translate */
 
858
                                                MEM_freeN(ofs);
 
859
                                                ofs = NULL;
 
860
                                                break;
 
861
                                        }
 
862
 
793
863
                                        mvert++;
794
864
                                }
795
865
                        }