← Back to branch summary

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

« back to all changes in this revision

Viewing changes to source/blender/blenkernel/intern/cdderivedmesh.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/blenkernel/intern/cdderivedmesh.c
40
40
#include "BLI_blenlib.h"
41
41
#include "BLI_edgehash.h"
42
42
#include "BLI_math.h"
43
 
#include "BLI_array.h"
44
43
#include "BLI_smallhash.h"
45
44
#include "BLI_utildefines.h"
46
45
#include "BLI_scanfill.h"
1424
1423
 
1425
1424
static void cdDM_drawMappedFacesMat(DerivedMesh *dm,
1426
1425
                                    void (*setMaterial)(void *userData, int, void *attribs),
1427
 
                                    int (*setFace)(void *userData, int index), void *userData)
 
1426
                                    bool (*setFace)(void *userData, int index), void *userData)
1428
1427
{
1429
1428
        CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
1430
1429
        GPUVertexAttribs gattribs;
1548
1547
static void cdDM_foreachMappedVert(
1549
1548
        DerivedMesh *dm,
1550
1549
        void (*func)(void *userData, int index, const float co[3], const float no_f[3], const short no_s[3]),
1551
 
        void *userData)
 
1550
        void *userData,
 
1551
        DMForeachFlag flag)
1552
1552
{
1553
1553
        MVert *mv = CDDM_get_verts(dm);
1554
 
        int i, orig, *index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
 
1554
        int *index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
 
1555
        int i;
1555
1556
 
1556
 
        for (i = 0; i < dm->numVertData; i++, mv++) {
1557
 
                if (index) {
1558
 
                        orig = *index++;
 
1557
        if (index) {
 
1558
                for (i = 0; i < dm->numVertData; i++, mv++) {
 
1559
                        const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
 
1560
                        const int orig = *index++;
1559
1561
                        if (orig == ORIGINDEX_NONE) continue;
1560
 
                        func(userData, orig, mv->co, NULL, mv->no);
1561
 
                }
1562
 
                else
1563
 
                        func(userData, i, mv->co, NULL, mv->no);
 
1562
                        func(userData, orig, mv->co, NULL, no);
 
1563
                }
 
1564
        }
 
1565
        else {
 
1566
                for (i = 0; i < dm->numVertData; i++, mv++) {
 
1567
                        const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
 
1568
                        func(userData, i, mv->co, NULL, no);
 
1569
                }
1564
1570
        }
1565
1571
}
1566
1572
 
1588
1594
static void cdDM_foreachMappedFaceCenter(
1589
1595
        DerivedMesh *dm,
1590
1596
        void (*func)(void *userData, int index, const float cent[3], const float no[3]),
1591
 
        void *userData)
 
1597
        void *userData,
 
1598
        DMForeachFlag flag)
1592
1599
{
1593
1600
        CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
1594
1601
        MVert *mvert = cddm->mvert;
1595
1602
        MPoly *mp;
1596
1603
        MLoop *ml;
1597
 
        int i, j, orig, *index;
 
1604
        int i, orig, *index;
1598
1605
 
1599
1606
        index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
1600
1607
        mp = cddm->mpoly;
1601
1608
        for (i = 0; i < dm->numPolyData; i++, mp++) {
1602
1609
                float cent[3];
1603
 
                float no[3];
 
1610
                float *no, _no[3];
1604
1611
 
1605
1612
                if (index) {
1606
1613
                        orig = *index++;
1607
1614
                        if (orig == ORIGINDEX_NONE) continue;
1608
1615
                }
1609
 
                else
 
1616
                else {
1610
1617
                        orig = i;
 
1618
                }
1611
1619
                
1612
1620
                ml = &cddm->mloop[mp->loopstart];
1613
 
                cent[0] = cent[1] = cent[2] = 0.0f;
1614
 
                for (j = 0; j < mp->totloop; j++, ml++) {
1615
 
                        add_v3_v3v3(cent, cent, mvert[ml->v].co);
1616
 
                }
1617
 
                mul_v3_fl(cent, 1.0f / (float)j);
 
1621
                BKE_mesh_calc_poly_center(mp, ml, mvert, cent);
1618
1622
 
1619
 
                ml = &cddm->mloop[mp->loopstart];
1620
 
                if (j > 3) {
1621
 
                        normal_quad_v3(no,
1622
 
                                       mvert[(ml + 0)->v].co,
1623
 
                                       mvert[(ml + 1)->v].co,
1624
 
                                       mvert[(ml + 2)->v].co,
1625
 
                                       mvert[(ml + 3)->v].co);
 
1623
                if (flag & DM_FOREACH_USE_NORMAL) {
 
1624
                        BKE_mesh_calc_poly_normal(mp, ml, mvert, (no = _no));
1626
1625
                }
1627
1626
                else {
1628
 
                        normal_tri_v3(no,
1629
 
                                      mvert[(ml + 0)->v].co,
1630
 
                                      mvert[(ml + 1)->v].co,
1631
 
                                      mvert[(ml + 2)->v].co);
 
1627
                        no = NULL;
1632
1628
                }
1633
1629
 
1634
1630
                func(userData, orig, cent, no);
1818
1814
 
1819
1815
DerivedMesh *CDDM_from_curve(Object *ob)
1820
1816
{
1821
 
        return CDDM_from_curve_displist(ob, &ob->disp);
 
1817
        ListBase disp = {NULL, NULL};
 
1818
 
 
1819
        if (ob->curve_cache) {
 
1820
                disp = ob->curve_cache->disp;
 
1821
        }
 
1822
 
 
1823
        return CDDM_from_curve_displist(ob, &disp);
1822
1824
}
1823
1825
 
1824
1826
DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase)
1973
1975
 
1974
1976
        index = dm->getVertDataArray(dm, CD_ORIGINDEX);
1975
1977
 
1976
 
        eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
1977
 
        for (i = 0; eve; eve = BM_iter_step(&iter), i++, index++) {
 
1978
        BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
1978
1979
                MVert *mv = &mvert[i];
1979
1980
 
1980
1981
                copy_v3_v3(mv->co, eve->co);
1987
1988
 
1988
1989
                if (cd_vert_bweight_offset != -1) mv->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
1989
1990
 
1990
 
                if (add_orig) *index = i;
 
1991
                if (add_orig) *index++ = i;
1991
1992
 
1992
1993
                CustomData_from_bmesh_block(&bm->vdata, &dm->vertData, eve->head.data, i);
1993
1994
        }
1994
1995
        bm->elem_index_dirty &= ~BM_VERT;
1995
1996
 
1996
1997
        index = dm->getEdgeDataArray(dm, CD_ORIGINDEX);
1997
 
        eed = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL);
1998
 
        for (i = 0; eed; eed = BM_iter_step(&iter), i++, index++) {
 
1998
        BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
1999
1999
                MEdge *med = &medge[i];
2000
2000
 
2001
2001
                BM_elem_index_set(eed, i); /* set_inline */
2017
2017
                if (cd_edge_bweight_offset != -1) med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_bweight_offset);
2018
2018
 
2019
2019
                CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i);
2020
 
                if (add_orig) *index = i;
 
2020
                if (add_orig) *index++ = i;
2021
2021
        }
2022
2022
        bm->elem_index_dirty &= ~BM_EDGE;
2023
2023
 
2027
2027
                BM_mesh_elem_index_ensure(bm, BM_FACE);
2028
2028
 
2029
2029
                index = dm->getTessFaceDataArray(dm, CD_ORIGINDEX);
2030
 
                for (i = 0; i < dm->numTessFaceData; i++, index++) {
 
2030
                for (i = 0; i < dm->numTessFaceData; i++) {
2031
2031
                        MFace *mf = &mface[i];
2032
2032
                        const BMLoop **l = em_looptris[i];
2033
2033
                        efa = l[0]->f;
2040
2040
                        mf->flag = BM_face_flag_to_mflag(efa);
2041
2041
 
2042
2042
                        /* map mfaces to polygons in the same cddm intentionally */
2043
 
                        *index = BM_elem_index_get(efa);
 
2043
                        *index++ = BM_elem_index_get(efa);
2044
2044
 
2045
2045
                        loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numTex);
2046
2046
                        test_index_face(mf, &dm->faceData, i, 3);
2049
2049
        
2050
2050
        index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
2051
2051
        j = 0;
2052
 
        efa = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL);
2053
 
        for (i = 0; efa; i++, efa = BM_iter_step(&iter), index++) {
 
2052
        BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
2054
2053
                BMLoop *l_iter;
2055
2054
                BMLoop *l_first;
2056
2055
                MPoly *mp = &mpoly[i];
2074
2073
 
2075
2074
                CustomData_from_bmesh_block(&bm->pdata, &dm->polyData, efa->head.data, i);
2076
2075
 
2077
 
                if (add_orig) *index = i;
 
2076
                if (add_orig) *index++ = i;
2078
2077
        }
2079
2078
        bm->elem_index_dirty &= ~BM_FACE;
2080
2079
 
2406
2405
        STACK_DECLARE(mpoly);
2407
2406
        STACK_DECLARE(oldp);
2408
2407
 
2409
 
        EdgeHash *ehash = BLI_edgehash_new();
 
2408
        EdgeHash *ehash = BLI_edgehash_new_ex(__func__, totedge);
2410
2409
 
2411
2410
        int i, j, c;
2412
2411
        
2608
2607
        EdgeHashIterator *ehi;
2609
2608
        MFace *mf = cddm->mface;
2610
2609
        MEdge *med;
2611
 
        EdgeHash *eh = BLI_edgehash_new();
2612
 
        int i, *index, numEdges, maxFaces = dm->numTessFaceData;
2613
 
 
2614
 
        for (i = 0; i < maxFaces; i++, mf++) {
 
2610
        EdgeHash *eh;
 
2611
        int i, *index, numEdges, numFaces = dm->numTessFaceData;
 
2612
 
 
2613
        eh = BLI_edgehash_new_ex(__func__, BLI_EDGEHASH_SIZE_GUESS_FROM_POLYS(numFaces));
 
2614
 
 
2615
        for (i = 0; i < numFaces; i++, mf++) {
2615
2616
                if (!BLI_edgehash_haskey(eh, mf->v1, mf->v2))
2616
2617
                        BLI_edgehash_insert(eh, mf->v1, mf->v2, NULL);
2617
2618
                if (!BLI_edgehash_haskey(eh, mf->v2, mf->v3))
2641
2642
 
2642
2643
        for (ehi = BLI_edgehashIterator_new(eh), i = 0;
2643
2644
             BLI_edgehashIterator_isDone(ehi) == FALSE;
2644
 
             BLI_edgehashIterator_step(ehi), ++i, ++med, ++index)
 
2645
             BLI_edgehashIterator_step(ehi), i++, med++, index++)
2645
2646
        {
2646
2647
                BLI_edgehashIterator_getKey(ehi, &med->v1, &med->v2);
2647
2648
 
2669
2670
        MPoly *mp = cddm->mpoly;
2670
2671
        MLoop *ml;
2671
2672
        MEdge *med, *origmed;
2672
 
        EdgeHash *eh = BLI_edgehash_new();
 
2673
        EdgeHash *eh;
 
2674
        unsigned int eh_reserve;
2673
2675
        int v1, v2;
2674
2676
        int *eindex;
2675
 
        int i, j, *index, numEdges = cddm->dm.numEdgeData, maxFaces = dm->numPolyData;
 
2677
        int i, j, *index;
 
2678
        const int numFaces = dm->numPolyData;
 
2679
        const int numLoops = dm->numLoopData;
 
2680
        int numEdges = dm->numEdgeData;
2676
2681
 
2677
2682
        eindex = DM_get_edge_data_layer(dm, CD_ORIGINDEX);
 
2683
        med = cddm->medge;
2678
2684
 
2679
 
        med = cddm->medge;
 
2685
        eh_reserve = max_ii(med ? numEdges : 0, BLI_EDGEHASH_SIZE_GUESS_FROM_LOOPS(numLoops));
 
2686
        eh = BLI_edgehash_new_ex(__func__, eh_reserve);
2680
2687
        if (med) {
2681
2688
                for (i = 0; i < numEdges; i++, med++) {
2682
2689
                        BLI_edgehash_insert(eh, med->v1, med->v2, SET_INT_IN_POINTER(i + 1));
2683
2690
                }
2684
2691
        }
2685
2692
 
2686
 
        for (i = 0; i < maxFaces; i++, mp++) {
 
2693
        for (i = 0; i < numFaces; i++, mp++) {
2687
2694
                ml = cddm->mloop + mp->loopstart;
2688
2695
                for (j = 0; j < mp->totloop; j++, ml++) {
2689
2696
                        v1 = ml->v;
2733
2740
        cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
2734
2741
 
2735
2742
        mp = cddm->mpoly;
2736
 
        for (i = 0; i < maxFaces; i++, mp++) {
 
2743
        for (i = 0; i < numFaces; i++, mp++) {
2737
2744
                ml = cddm->mloop + mp->loopstart;
2738
2745
                for (j = 0; j < mp->totloop; j++, ml++) {
2739
2746
                        v1 = ml->v;