Merge branch 'master' into blender2.8
[blender.git] / source / blender / modifiers / intern / MOD_solidify.c
index 572898c1982ba3d7d7cef87b2bd2b35bf74f1072..6d830cabb27bebeed90753779ff73cb8f852d094 100644 (file)
@@ -73,7 +73,7 @@ BLI_INLINE bool edgeref_is_init(const EdgeFaceRef *edge_ref)
  * \param face_nors  Precalculated face normals.
  * \param r_vert_nors  Return vert normals.
  */
-static void dm_calc_normal(DerivedMesh *dm, float (*face_nors)[3], float (*r_vert_nors)[3])
+static void mesh_calc_hq_normal(Mesh *mesh, float (*face_nors)[3], float (*r_vert_nors)[3])
 {
        int i, numVerts, numEdges, numFaces;
        MPoly *mpoly, *mp;
@@ -81,13 +81,13 @@ static void dm_calc_normal(DerivedMesh *dm, float (*face_nors)[3], float (*r_ver
        MEdge *medge, *ed;
        MVert *mvert, *mv;
 
-       numVerts = dm->getNumVerts(dm);
-       numEdges = dm->getNumEdges(dm);
-       numFaces = dm->getNumPolys(dm);
-       mpoly = dm->getPolyArray(dm);
-       medge = dm->getEdgeArray(dm);
-       mvert = dm->getVertArray(dm);
-       mloop = dm->getLoopArray(dm);
+       numVerts = mesh->totvert;
+       numEdges = mesh->totedge;
+       numFaces = mesh->totface;
+       mpoly = mesh->mpoly;
+       medge = mesh->medge;
+       mvert = mesh->mvert;
+       mloop = mesh->mloop;
 
        /* we don't want to overwrite any referenced layers */
 
@@ -195,26 +195,25 @@ BLI_INLINE void madd_v3v3short_fl(float r[3], const short a[3], const float f)
        r[2] += (float)a[2] * f;
 }
 
-static DerivedMesh *applyModifier(
-        ModifierData *md, Object *ob,
-        DerivedMesh *dm,
-        ModifierApplyFlag UNUSED(flag))
+static Mesh *applyModifier(
+        ModifierData *md, const ModifierEvalContext *ctx,
+        Mesh *mesh)
 {
-       DerivedMesh *result;
+       Mesh *result;
        const SolidifyModifierData *smd = (SolidifyModifierData *) md;
 
        MVert *mv, *mvert, *orig_mvert;
        MEdge *ed, *medge, *orig_medge;
        MLoop *ml, *mloop, *orig_mloop;
        MPoly *mp, *mpoly, *orig_mpoly;
-       const unsigned int numVerts = (unsigned int)dm->getNumVerts(dm);
-       const unsigned int numEdges = (unsigned int)dm->getNumEdges(dm);
-       const unsigned int numFaces = (unsigned int)dm->getNumPolys(dm);
-       const unsigned int numLoops = (unsigned int)dm->getNumLoops(dm);
+       const unsigned int numVerts = (unsigned int)mesh->totvert;
+       const unsigned int numEdges = (unsigned int)mesh->totedge;
+       const unsigned int numFaces = (unsigned int)mesh->totpoly;
+       const unsigned int numLoops = (unsigned int)mesh->totloop;
        unsigned int newLoops = 0, newFaces = 0, newEdges = 0, newVerts = 0, rimVerts = 0;
 
        /* only use material offsets if we have 2 or more materials  */
-       const short mat_nr_max = ob->totcol > 1 ? ob->totcol - 1 : 0;
+       const short mat_nr_max = ctx->object->totcol > 1 ? ctx->object->totcol - 1 : 0;
        const short mat_ofs = mat_nr_max ? smd->mat_ofs : 0;
        const short mat_ofs_rim = mat_nr_max ? smd->mat_ofs_rim : 0;
 
@@ -252,12 +251,12 @@ static DerivedMesh *applyModifier(
        /* array size is doubled in case of using a shell */
        const unsigned int stride = do_shell ? 2 : 1;
 
-       modifier_get_vgroup(ob, dm, smd->defgrp_name, &dvert, &defgrp_index);
+       modifier_get_vgroup_mesh(ctx->object, mesh, smd->defgrp_name, &dvert, &defgrp_index);
 
-       orig_mvert = dm->getVertArray(dm);
-       orig_medge = dm->getEdgeArray(dm);
-       orig_mloop = dm->getLoopArray(dm);
-       orig_mpoly = dm->getPolyArray(dm);
+       orig_mvert = mesh->mvert;
+       orig_medge = mesh->medge;
+       orig_mloop = mesh->mloop;
+       orig_mpoly = mesh->mpoly;
 
        if (need_face_normals) {
                /* calculate only face normals */
@@ -358,49 +357,49 @@ static DerivedMesh *applyModifier(
 
        if (smd->flag & MOD_SOLIDIFY_NORMAL_CALC) {
                vert_nors = MEM_calloc_arrayN(numVerts, 3 * sizeof(float), "mod_solid_vno_hq");
-               dm_calc_normal(dm, face_nors, vert_nors);
+               mesh_calc_hq_normal(mesh, face_nors, vert_nors);
        }
 
-       result = CDDM_from_template(dm,
-                                   (int)((numVerts * stride) + newVerts),
-                                   (int)((numEdges * stride) + newEdges + rimVerts), 0,
-                                   (int)((numLoops * stride) + newLoops),
-                                   (int)((numFaces * stride) + newFaces));
+       result = BKE_mesh_from_template(mesh,
+                                       (int)((numVerts * stride) + newVerts),
+                                       (int)((numEdges * stride) + newEdges + rimVerts), 0,
+                                       (int)((numLoops * stride) + newLoops),
+                                       (int)((numFaces * stride) + newFaces));
 
-       mpoly = CDDM_get_polys(result);
-       mloop = CDDM_get_loops(result);
-       medge = CDDM_get_edges(result);
-       mvert = CDDM_get_verts(result);
+       mpoly = result->mpoly;
+       mloop = result->mloop;
+       medge = result->medge;
+       mvert = result->mvert;
 
        if (do_shell) {
-               DM_copy_vert_data(dm, result, 0, 0, (int)numVerts);
-               DM_copy_vert_data(dm, result, 0, (int)numVerts, (int)numVerts);
+               CustomData_copy_data(&mesh->vdata, &result->vdata, 0, 0, (int)numVerts);
+               CustomData_copy_data(&mesh->vdata, &result->vdata, 0, (int)numVerts, (int)numVerts);
 
-               DM_copy_edge_data(dm, result, 0, 0, (int)numEdges);
-               DM_copy_edge_data(dm, result, 0, (int)numEdges, (int)numEdges);
+               CustomData_copy_data(&mesh->edata, &result->edata, 0, 0, (int)numEdges);
+               CustomData_copy_data(&mesh->edata, &result->edata, 0, (int)numEdges, (int)numEdges);
 
-               DM_copy_loop_data(dm, result, 0, 0, (int)numLoops);
-               DM_copy_loop_data(dm, result, 0, (int)numLoops, (int)numLoops);
+               CustomData_copy_data(&mesh->ldata, &result->ldata, 0, 0, (int)numLoops);
+               CustomData_copy_data(&mesh->ldata, &result->ldata, 0, (int)numLoops, (int)numLoops);
 
-               DM_copy_poly_data(dm, result, 0, 0, (int)numFaces);
-               DM_copy_poly_data(dm, result, 0, (int)numFaces, (int)numFaces);
+               CustomData_copy_data(&mesh->pdata, &result->pdata, 0, 0, (int)numFaces);
+               CustomData_copy_data(&mesh->pdata, &result->pdata, 0, (int)numFaces, (int)numFaces);
        }
        else {
                int i, j;
-               DM_copy_vert_data(dm, result, 0, 0, (int)numVerts);
+               CustomData_copy_data(&mesh->vdata, &result->vdata, 0, 0, (int)numVerts);
                for (i = 0, j = (int)numVerts; i < numVerts; i++) {
                        if (old_vert_arr[i] != INVALID_UNUSED) {
-                               DM_copy_vert_data(dm, result, i, j, 1);
+                               CustomData_copy_data(&mesh->vdata, &result->vdata, i, j, 1);
                                j++;
                        }
                }
 
-               DM_copy_edge_data(dm, result, 0, 0, (int)numEdges);
+               CustomData_copy_data(&mesh->edata, &result->edata, 0, 0, (int)numEdges);
 
                for (i = 0, j = (int)numEdges; i < numEdges; i++) {
                        if (!ELEM(edge_users[i], INVALID_UNUSED, INVALID_PAIR)) {
                                MEdge *ed_src, *ed_dst;
-                               DM_copy_edge_data(dm, result, i, j, 1);
+                               CustomData_copy_data(&mesh->edata, &result->edata, i, j, 1);
 
                                ed_src = &medge[i];
                                ed_dst = &medge[j];
@@ -411,8 +410,8 @@ static DerivedMesh *applyModifier(
                }
 
                /* will be created later */
-               DM_copy_loop_data(dm, result, 0, 0, (int)numLoops);
-               DM_copy_poly_data(dm, result, 0, 0, (int)numFaces);
+               CustomData_copy_data(&mesh->ldata, &result->ldata, 0, 0, (int)numLoops);
+               CustomData_copy_data(&mesh->pdata, &result->pdata, 0, 0, (int)numFaces);
        }
 
 #undef INVALID_UNUSED
@@ -445,7 +444,7 @@ static DerivedMesh *applyModifier(
                unsigned int i;
 
                mp = mpoly + numFaces;
-               for (i = 0; i < dm->numPolyData; i++, mp++) {
+               for (i = 0; i < mesh->totpoly; i++, mp++) {
                        const int loop_end = mp->totloop - 1;
                        MLoop *ml2;
                        unsigned int e;
@@ -453,19 +452,19 @@ static DerivedMesh *applyModifier(
 
                        /* reverses the loop direction (MLoop.v as well as custom-data)
                         * MLoop.e also needs to be corrected too, done in a separate loop below. */
-                       ml2 = mloop + mp->loopstart + dm->numLoopData;
+                       ml2 = mloop + mp->loopstart + mesh->totloop;
 #if 0
                        for (j = 0; j < mp->totloop; j++) {
-                               CustomData_copy_data(&dm->loopData, &result->loopData, mp->loopstart + j,
-                                                    mp->loopstart + (loop_end - j) + dm->numLoopData, 1);
+                               CustomData_copy_data(&mesh->ldata, &result->ldata, mp->loopstart + j,
+                                                    mp->loopstart + (loop_end - j) + mesh->totloop, 1);
                        }
 #else
                        /* slightly more involved, keep the first vertex the same for the copy,
                         * ensures the diagonals in the new face match the original. */
                        j = 0;
                        for (int j_prev = loop_end; j < mp->totloop; j_prev = j++) {
-                               CustomData_copy_data(&dm->loopData, &result->loopData, mp->loopstart + j,
-                                                    mp->loopstart + (loop_end - j_prev) + dm->numLoopData, 1);
+                               CustomData_copy_data(&mesh->ldata, &result->ldata, mp->loopstart + j,
+                                                    mp->loopstart + (loop_end - j_prev) + mesh->totloop, 1);
                        }
 #endif
 
@@ -480,7 +479,7 @@ static DerivedMesh *applyModifier(
                        }
                        ml2[loop_end].e = e;
 
-                       mp->loopstart += dm->numLoopData;
+                       mp->loopstart += mesh->totloop;
 
                        for (j = 0; j < mp->totloop; j++) {
                                ml2[j].e += numEdges;
@@ -727,8 +726,8 @@ static DerivedMesh *applyModifier(
                MEM_freeN(vert_nors);
 
        /* must recalculate normals with vgroups since they can displace unevenly [#26888] */
-       if ((dm->dirty & DM_DIRTY_NORMALS) || (smd->flag & MOD_SOLIDIFY_RIM) || dvert) {
-               result->dirty |= DM_DIRTY_NORMALS;
+       if ((mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL) || (smd->flag & MOD_SOLIDIFY_RIM) || dvert) {
+               result->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
        }
        else if (do_shell) {
                unsigned int i;
@@ -754,7 +753,9 @@ static DerivedMesh *applyModifier(
 #define SOLIDIFY_SIDE_NORMALS
 
 #ifdef SOLIDIFY_SIDE_NORMALS
-               const bool do_side_normals = !(result->dirty & DM_DIRTY_NORMALS);
+               /* Note that, due to the code setting cd_dirty_vert a few lines above,
+                * do_side_normals is always false. - Sybren */
+               const bool do_side_normals = !(result->runtime.cd_dirty_vert & CD_MASK_NORMAL);
                /* annoying to allocate these since we only need the edge verts, */
                float (*edge_vert_nos)[3] = do_side_normals ? MEM_calloc_arrayN(numVerts, 3 * sizeof(float), __func__) : NULL;
                float nor[3];
@@ -772,7 +773,8 @@ static DerivedMesh *applyModifier(
                }
 
                /* add faces & edges */
-               origindex_edge = result->getEdgeDataArray(result, CD_ORIGINDEX);
+               origindex_edge = CustomData_get_layer(&result->edata, CD_ORIGINDEX);
+               BLI_assert(origindex_edge != NULL);
                ed = &medge[(numEdges * stride) + newEdges];  /* start after copied edges */
                orig_ed = &origindex_edge[(numEdges * stride) + newEdges];
                for (i = 0; i < rimVerts; i++, ed++, orig_ed++) {
@@ -808,7 +810,7 @@ static DerivedMesh *applyModifier(
                        ed = medge + eidx;
 
                        /* copy most of the face settings */
-                       DM_copy_poly_data(dm, result, (int)fidx, (int)((numFaces * stride) + i), 1);
+                       CustomData_copy_data(&mesh->pdata, &result->pdata, (int)fidx, (int)((numFaces * stride) + i), 1);
                        mp->loopstart = (int)(j + (numLoops * stride));
                        mp->flag = mpoly[fidx].flag;
 
@@ -820,10 +822,10 @@ static DerivedMesh *applyModifier(
 
                        mp->totloop = 4;
 
-                       CustomData_copy_data(&dm->loopData, &result->loopData, k2, (int)((numLoops * stride) + j + 0), 1);
-                       CustomData_copy_data(&dm->loopData, &result->loopData, k1, (int)((numLoops * stride) + j + 1), 1);
-                       CustomData_copy_data(&dm->loopData, &result->loopData, k1, (int)((numLoops * stride) + j + 2), 1);
-                       CustomData_copy_data(&dm->loopData, &result->loopData, k2, (int)((numLoops * stride) + j + 3), 1);
+                       CustomData_copy_data(&mesh->ldata, &result->ldata, k2, (int)((numLoops * stride) + j + 0), 1);
+                       CustomData_copy_data(&mesh->ldata, &result->ldata, k1, (int)((numLoops * stride) + j + 1), 1);
+                       CustomData_copy_data(&mesh->ldata, &result->ldata, k1, (int)((numLoops * stride) + j + 2), 1);
+                       CustomData_copy_data(&mesh->ldata, &result->ldata, k2, (int)((numLoops * stride) + j + 3), 1);
 
                        if (flip == false) {
                                ml[j].v = ed->v1;
@@ -898,6 +900,7 @@ static DerivedMesh *applyModifier(
                                int k;
 
                                /* note, only the first vertex (lower half of the index) is calculated */
+                               BLI_assert(ed->v1 < numVerts);
                                normalize_v3_v3(nor_cpy, edge_vert_nos[ed_orig->v1]);
 
                                for (k = 0; k < 2; k++) { /* loop over both verts of the edge */
@@ -955,17 +958,25 @@ ModifierTypeInfo modifierType_Solidify = {
                                eModifierTypeFlag_EnableInEditmode,
 
        /* copyData */          modifier_copyData_generic,
+
+       /* deformVerts_DM */    NULL,
+       /* deformMatrices_DM */ NULL,
+       /* deformVertsEM_DM */  NULL,
+       /* deformMatricesEM_DM*/NULL,
+       /* applyModifier_DM */  NULL,
+       /* applyModifierEM_DM */NULL,
+
        /* deformVerts */       NULL,
        /* deformMatrices */    NULL,
        /* deformVertsEM */     NULL,
        /* deformMatricesEM */  NULL,
        /* applyModifier */     applyModifier,
        /* applyModifierEM */   NULL,
+
        /* initData */          initData,
        /* requiredDataMask */  requiredDataMask,
        /* freeData */          NULL,
        /* isDisabled */        NULL,
-       /* updateDepgraph */    NULL,
        /* updateDepsgraph */   NULL,
        /* dependsOnTime */     NULL,
        /* dependsOnNormals */  dependsOnNormals,