Cleanup: remove unused derived-mesh API calls

1 files changed, 4 insertions, 868 deletions

diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c
index 28bd9c0cea5..a55b5dc7817 100644
--- a/source/blender/blenkernel/intern/cdderivedmesh.c
+++ b/source/blender/blenkernel/intern/cdderivedmesh.c
@@ -173,16 +173,6 @@ static void cdDM_getVertCo(DerivedMesh *dm, int index, float r_co[3])
   copy_v3_v3(r_co, cddm->mvert[index].co);
 }
 
-static void cdDM_getVertCos(DerivedMesh *dm, float (*r_cos)[3])
-{
-  MVert *mv = CDDM_get_verts(dm);
-  int i;
-
-  for (i = 0; i < dm->numVertData; i++, mv++) {
-    copy_v3_v3(r_cos[i], mv->co);
-  }
-}
-
 static void cdDM_getVertNo(DerivedMesh *dm, int index, float r_no[3])
 {
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
@@ -203,278 +193,6 @@ static const MeshElemMap *cdDM_getPolyMap(Object *ob, DerivedMesh *dm)
   return cddm->pmap;
 }
 
-static bool check_sculpt_object_deformed(Object *object, bool for_construction)
-{
-  bool deformed = false;
-
-  /* Active modifiers means extra deformation, which can't be handled correct
-   * on birth of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
-   * stuff and show final DerivedMesh so user would see actual object shape.
-   */
-  deformed |= object->sculpt->modifiers_active;
-
-  if (for_construction) {
-    deformed |= object->sculpt->kb != NULL;
-  }
-  else {
-    /* As in case with modifiers, we can't synchronize deformation made against
-     * PBVH and non-locked keyblock, so also use PBVH only for brushes and
-     * final DM to give final result to user.
-     */
-    deformed |= object->sculpt->kb && (object->shapeflag & OB_SHAPE_LOCK) == 0;
-  }
-
-  return deformed;
-}
-
-static bool can_pbvh_draw(Object *ob, DerivedMesh *dm)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-  Mesh *me = ob->data;
-  bool deformed = check_sculpt_object_deformed(ob, false);
-
-  if (deformed) {
-    return false;
-  }
-
-  return cddm->mvert == me->mvert || ob->sculpt->kb;
-}
-
-static PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-
-  if (!ob) {
-    cddm->pbvh = NULL;
-    return NULL;
-  }
-
-  if (!ob->sculpt) {
-    return NULL;
-  }
-
-  if (ob->sculpt->pbvh) {
-    cddm->pbvh = ob->sculpt->pbvh;
-    cddm->pbvh_draw = can_pbvh_draw(ob, dm);
-  }
-
-  /* Sculpting on a BMesh (dynamic-topology) gets a special PBVH */
-  if (!cddm->pbvh && ob->sculpt->bm) {
-    cddm->pbvh = BKE_pbvh_new();
-    cddm->pbvh_draw = true;
-
-    BKE_pbvh_build_bmesh(cddm->pbvh,
-                         ob->sculpt->bm,
-                         ob->sculpt->bm_smooth_shading,
-                         ob->sculpt->bm_log,
-                         ob->sculpt->cd_vert_node_offset,
-                         ob->sculpt->cd_face_node_offset);
-
-    pbvh_show_mask_set(cddm->pbvh, ob->sculpt->show_mask);
-  }
-
-  /* always build pbvh from original mesh, and only use it for drawing if
-   * this derivedmesh is just original mesh. it's the multires subsurf dm
-   * that this is actually for, to support a pbvh on a modified mesh */
-  if (!cddm->pbvh && ob->type == OB_MESH) {
-    Mesh *me = BKE_object_get_original_mesh(ob);
-    const int looptris_num = poly_to_tri_count(me->totpoly, me->totloop);
-    MLoopTri *looptri;
-    bool deformed;
-
-    cddm->pbvh = BKE_pbvh_new();
-    cddm->pbvh_draw = can_pbvh_draw(ob, dm);
-
-    looptri = MEM_malloc_arrayN(looptris_num, sizeof(*looptri), __func__);
-
-    BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri);
-
-    BKE_pbvh_build_mesh(cddm->pbvh,
-                        me->mpoly,
-                        me->mloop,
-                        me->mvert,
-                        me->totvert,
-                        &me->vdata,
-                        &me->ldata,
-                        looptri,
-                        looptris_num);
-
-    pbvh_show_mask_set(cddm->pbvh, ob->sculpt->show_mask);
-
-    deformed = check_sculpt_object_deformed(ob, true);
-
-    if (deformed && ob->derivedDeform) {
-      DerivedMesh *deformdm = ob->derivedDeform;
-      float(*vertCos)[3];
-      int totvert;
-
-      totvert = deformdm->getNumVerts(deformdm);
-      vertCos = MEM_malloc_arrayN(totvert, sizeof(float[3]), "cdDM_getPBVH vertCos");
-      deformdm->getVertCos(deformdm, vertCos);
-      BKE_pbvh_apply_vertCos(cddm->pbvh, vertCos, totvert);
-      MEM_freeN(vertCos);
-    }
-  }
-
-  return cddm->pbvh;
-}
-
-static void cdDM_foreachMappedVert(DerivedMesh *dm,
-                                   void (*func)(void *userData,
-                                                int index,
-                                                const float co[3],
-                                                const float no_f[3],
-                                                const short no_s[3]),
-                                   void *userData,
-                                   DMForeachFlag flag)
-{
-  MVert *mv = CDDM_get_verts(dm);
-  const int *index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
-  int i;
-
-  if (index) {
-    for (i = 0; i < dm->numVertData; i++, mv++) {
-      const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
-      const int orig = *index++;
-      if (orig == ORIGINDEX_NONE) {
-        continue;
-      }
-      func(userData, orig, mv->co, NULL, no);
-    }
-  }
-  else {
-    for (i = 0; i < dm->numVertData; i++, mv++) {
-      const short *no = (flag & DM_FOREACH_USE_NORMAL) ? mv->no : NULL;
-      func(userData, i, mv->co, NULL, no);
-    }
-  }
-}
-
-static void cdDM_foreachMappedEdge(
-    DerivedMesh *dm,
-    void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
-    void *userData)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-  MVert *mv = cddm->mvert;
-  MEdge *med = cddm->medge;
-  int i, orig, *index = DM_get_edge_data_layer(dm, CD_ORIGINDEX);
-
-  for (i = 0; i < dm->numEdgeData; i++, med++) {
-    if (index) {
-      orig = *index++;
-      if (orig == ORIGINDEX_NONE) {
-        continue;
-      }
-      func(userData, orig, mv[med->v1].co, mv[med->v2].co);
-    }
-    else {
-      func(userData, i, mv[med->v1].co, mv[med->v2].co);
-    }
-  }
-}
-
-static void cdDM_foreachMappedLoop(DerivedMesh *dm,
-                                   void (*func)(void *userData,
-                                                int vertex_index,
-                                                int face_index,
-                                                const float co[3],
-                                                const float no[3]),
-                                   void *userData,
-                                   DMForeachFlag flag)
-{
-  /* We can't use dm->getLoopDataLayout(dm) here,
-   * we want to always access dm->loopData, EditDerivedBMesh would
-   * return loop data from bmesh itself. */
-  const float(*lnors)[3] = (flag & DM_FOREACH_USE_NORMAL) ? DM_get_loop_data_layer(dm, CD_NORMAL) :
-                                                            NULL;
-
-  const MVert *mv = CDDM_get_verts(dm);
-  const MLoop *ml = CDDM_get_loops(dm);
-  const MPoly *mp = CDDM_get_polys(dm);
-  const int *v_index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
-  const int *f_index = DM_get_poly_data_layer(dm, CD_ORIGINDEX);
-  int p_idx, i;
-
-  for (p_idx = 0; p_idx < dm->numPolyData; ++p_idx, ++mp) {
-    for (i = 0; i < mp->totloop; ++i, ++ml) {
-      const int v_idx = v_index ? v_index[ml->v] : ml->v;
-      const int f_idx = f_index ? f_index[p_idx] : p_idx;
-      const float *no = lnors ? *lnors++ : NULL;
-      if (!ELEM(ORIGINDEX_NONE, v_idx, f_idx)) {
-        func(userData, v_idx, f_idx, mv[ml->v].co, no);
-      }
-    }
-  }
-}
-
-static void cdDM_foreachMappedFaceCenter(
-    DerivedMesh *dm,
-    void (*func)(void *userData, int index, const float cent[3], const float no[3]),
-    void *userData,
-    DMForeachFlag flag)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-  MVert *mvert = cddm->mvert;
-  MPoly *mp;
-  MLoop *ml;
-  int i, orig, *index;
-
-  index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
-  mp = cddm->mpoly;
-  for (i = 0; i < dm->numPolyData; i++, mp++) {
-    float cent[3];
-    float *no, _no[3];
-
-    if (index) {
-      orig = *index++;
-      if (orig == ORIGINDEX_NONE) {
-        continue;
-      }
-    }
-    else {
-      orig = i;
-    }
-
-    ml = &cddm->mloop[mp->loopstart];
-    BKE_mesh_calc_poly_center(mp, ml, mvert, cent);
-
-    if (flag & DM_FOREACH_USE_NORMAL) {
-      BKE_mesh_calc_poly_normal(mp, ml, mvert, (no = _no));
-    }
-    else {
-      no = NULL;
-    }
-
-    func(userData, orig, cent, no);
-  }
-}
-
-void CDDM_recalc_tessellation_ex(DerivedMesh *dm, const bool do_face_nor_cpy)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-
-  dm->numTessFaceData = BKE_mesh_recalc_tessellation(&dm->faceData,
-                                                     &dm->loopData,
-                                                     &dm->polyData,
-                                                     cddm->mvert,
-                                                     dm->numTessFaceData,
-                                                     dm->numLoopData,
-                                                     dm->numPolyData,
-                                                     do_face_nor_cpy);
-
-  cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
-
-  /* Tessellation recreated faceData, and the active layer indices need to get re-propagated
-   * from loops and polys to faces */
-  CustomData_bmesh_update_active_layers(&dm->faceData, &dm->loopData);
-}
-
-void CDDM_recalc_tessellation(DerivedMesh *dm)
-{
-  CDDM_recalc_tessellation_ex(dm, true);
-}
-
 void CDDM_recalc_looptri(DerivedMesh *dm)
 {
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
@@ -547,25 +265,13 @@ static CDDerivedMesh *cdDM_create(const char *desc)
   dm->getEdgeDataArray = DM_get_edge_data_layer;
   dm->getTessFaceDataArray = DM_get_tessface_data_layer;
 
-  dm->calcNormals = CDDM_calc_normals;
-  dm->calcLoopNormals = CDDM_calc_loop_normals;
-  dm->calcLoopNormalsSpaceArray = CDDM_calc_loop_normals_spacearr;
-  dm->calcLoopTangents = DM_calc_loop_tangents;
-  dm->recalcTessellation = CDDM_recalc_tessellation;
   dm->recalcLoopTri = CDDM_recalc_looptri;
 
-  dm->getVertCos = cdDM_getVertCos;
   dm->getVertCo = cdDM_getVertCo;
   dm->getVertNo = cdDM_getVertNo;
 
-  dm->getPBVH = cdDM_getPBVH;
   dm->getPolyMap = cdDM_getPolyMap;
 
-  dm->foreachMappedVert = cdDM_foreachMappedVert;
-  dm->foreachMappedEdge = cdDM_foreachMappedEdge;
-  dm->foreachMappedLoop = cdDM_foreachMappedLoop;
-  dm->foreachMappedFaceCenter = cdDM_foreachMappedFaceCenter;
-
   dm->release = cdDM_release;
 
   return cddm;
@@ -664,123 +370,12 @@ DerivedMesh *CDDM_from_mesh_ex(Mesh *mesh,
   return dm;
 }
 
-DerivedMesh *CDDM_from_curve(Object *ob)
-{
-  ListBase disp = {NULL, NULL};
-
-  if (ob->runtime.curve_cache) {
-    disp = ob->runtime.curve_cache->disp;
-  }
-
-  return CDDM_from_curve_displist(ob, &disp);
-}
-
-DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase)
-{
-  Curve *cu = (Curve *)ob->data;
-  DerivedMesh *dm;
-  CDDerivedMesh *cddm;
-  MVert *allvert;
-  MEdge *alledge;
-  MLoop *allloop;
-  MPoly *allpoly;
-  MLoopUV *alluv = NULL;
-  int totvert, totedge, totloop, totpoly;
-  bool use_orco_uv = (cu->flag & CU_UV_ORCO) != 0;
-
-  if (BKE_mesh_nurbs_displist_to_mdata(ob,
-                                       dispbase,
-                                       &allvert,
-                                       &totvert,
-                                       &alledge,
-                                       &totedge,
-                                       &allloop,
-                                       &allpoly,
-                                       (use_orco_uv) ? &alluv : NULL,
-                                       &totloop,
-                                       &totpoly) != 0) {
-    /* Error initializing mdata. This often happens when curve is empty */
-    return CDDM_new(0, 0, 0, 0, 0);
-  }
-
-  dm = CDDM_new(totvert, totedge, 0, totloop, totpoly);
-  dm->deformedOnly = 1;
-  dm->dirty |= DM_DIRTY_NORMALS;
-
-  cddm = (CDDerivedMesh *)dm;
-
-  memcpy(cddm->mvert, allvert, totvert * sizeof(MVert));
-  memcpy(cddm->medge, alledge, totedge * sizeof(MEdge));
-  memcpy(cddm->mloop, allloop, totloop * sizeof(MLoop));
-  memcpy(cddm->mpoly, allpoly, totpoly * sizeof(MPoly));
-
-  if (alluv) {
-    const char *uvname = "Orco";
-    CustomData_add_layer_named(&cddm->dm.loopData, CD_MLOOPUV, CD_ASSIGN, alluv, totloop, uvname);
-  }
-
-  MEM_freeN(allvert);
-  MEM_freeN(alledge);
-  MEM_freeN(allloop);
-  MEM_freeN(allpoly);
-
-  return dm;
-}
-
-static void loops_to_customdata_corners(
-    BMesh *bm, CustomData *facedata, int cdindex, const BMLoop *l3[3], int numCol, int numUV)
-{
-  const BMLoop *l;
-  //  BMFace *f = l3[0]->f;
-  MTFace *texface;
-  MCol *mcol;
-  MLoopCol *mloopcol;
-  MLoopUV *mloopuv;
-  int i, j, hasPCol = CustomData_has_layer(&bm->ldata, CD_PREVIEW_MLOOPCOL);
-
-  for (i = 0; i < numUV; i++) {
-    texface = CustomData_get_n(facedata, CD_MTFACE, cdindex, i);
-
-    for (j = 0; j < 3; j++) {
-      l = l3[j];
-      mloopuv = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPUV, i);
-      copy_v2_v2(texface->uv[j], mloopuv->uv);
-    }
-  }
-
-  for (i = 0; i < numCol; i++) {
-    mcol = CustomData_get_n(facedata, CD_MCOL, cdindex, i);
-
-    for (j = 0; j < 3; j++) {
-      l = l3[j];
-      mloopcol = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPCOL, i);
-      MESH_MLOOPCOL_TO_MCOL(mloopcol, &mcol[j]);
-    }
-  }
-
-  if (hasPCol) {
-    mcol = CustomData_get(facedata, cdindex, CD_PREVIEW_MCOL);
-
-    for (j = 0; j < 3; j++) {
-      l = l3[j];
-      mloopcol = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_PREVIEW_MLOOPCOL);
-      MESH_MLOOPCOL_TO_MCOL(mloopcol, &mcol[j]);
-    }
-  }
-}
-
 /* TODO(campbell): remove, use BKE_mesh_from_bmesh_for_eval_nomain instead. */
 
 /* used for both editbmesh and bmesh */
-static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
-                                       const bool use_mdisps,
-                                       /* EditBMesh vars for use_tessface */
-                                       const bool use_tessface,
-                                       const int em_tottri,
-                                       const BMLoop *(*em_looptris)[3])
+static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm, const bool use_mdisps)
 {
-  DerivedMesh *dm = CDDM_new(
-      bm->totvert, bm->totedge, use_tessface ? em_tottri : 0, bm->totloop, bm->totface);
+  DerivedMesh *dm = CDDM_new(bm->totvert, bm->totedge, 0, bm->totloop, bm->totface);
 
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
   BMIter iter;
@@ -789,11 +384,8 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
   BMFace *efa;
   MVert *mvert = cddm->mvert;
   MEdge *medge = cddm->medge;
-  MFace *mface = cddm->mface;
   MLoop *mloop = cddm->mloop;
   MPoly *mpoly = cddm->mpoly;
-  int numCol = CustomData_number_of_layers(&bm->ldata, CD_MLOOPCOL);
-  int numUV = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
   int *index, add_orig;
   CustomData_MeshMasks mask = {0};
   unsigned int i, j;
@@ -820,11 +412,6 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
   CustomData_merge(&bm->ldata, &dm->loopData, mask.lmask, CD_CALLOC, dm->numLoopData);
   CustomData_merge(&bm->pdata, &dm->polyData, mask.pmask, CD_CALLOC, dm->numPolyData);
 
-  /* add tessellation mface layers */
-  if (use_tessface) {
-    CustomData_from_bmeshpoly(&dm->faceData, &dm->loopData, em_tottri);
-  }
-
   index = dm->getVertDataArray(dm, CD_ORIGINDEX);
 
   BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
@@ -883,32 +470,6 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
   }
   bm->elem_index_dirty &= ~BM_EDGE;
 
-  /* avoid this where possiblem, takes extra memory */
-  if (use_tessface) {
-
-    BM_mesh_elem_index_ensure(bm, BM_FACE);
-
-    index = dm->getTessFaceDataArray(dm, CD_ORIGINDEX);
-    for (i = 0; i < dm->numTessFaceData; i++) {
-      MFace *mf = &mface[i];
-      const BMLoop **l = em_looptris[i];
-      efa = l[0]->f;
-
-      mf->v1 = BM_elem_index_get(l[0]->v);
-      mf->v2 = BM_elem_index_get(l[1]->v);
-      mf->v3 = BM_elem_index_get(l[2]->v);
-      mf->v4 = 0;
-      mf->mat_nr = efa->mat_nr;
-      mf->flag = BM_face_flag_to_mflag(efa);
-
-      /* map mfaces to polygons in the same cddm intentionally */
-      *index++ = BM_elem_index_get(efa);
-
-      loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numUV);
-      test_index_face(mf, &dm->faceData, i, 3);
-    }
-  }
-
   index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
   j = 0;
   BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
@@ -948,24 +509,9 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm,
   return dm;
 }
 
-struct DerivedMesh *CDDM_from_bmesh(struct BMesh *bm, const bool use_mdisps)
+DerivedMesh *CDDM_from_editbmesh(BMEditMesh *em, const bool use_mdisps)
 {
-  return cddm_from_bmesh_ex(bm,
-                            use_mdisps,
-                            false,
-                            /* these vars are for editmesh only */
-                            0,
-                            NULL);
-}
-
-DerivedMesh *CDDM_from_editbmesh(BMEditMesh *em, const bool use_mdisps, const bool use_tessface)
-{
-  return cddm_from_bmesh_ex(em->bm,
-                            use_mdisps,
-                            /* editmesh */
-                            use_tessface,
-                            em->tottri,
-                            (const BMLoop *(*)[3])em->looptris);
+  return cddm_from_bmesh_ex(em->bm, use_mdisps);
 }
 
 DerivedMesh *CDDM_copy(DerivedMesh *source)
@@ -1014,366 +560,11 @@ DerivedMesh *CDDM_copy(DerivedMesh *source)
   return dm;
 }
 
-/* note, the CD_ORIGINDEX layers are all 0, so if there is a direct
- * relationship between mesh data this needs to be set by the caller. */
-DerivedMesh *CDDM_from_template_ex(DerivedMesh *source,
-                                   int numVerts,
-                                   int numEdges,
-                                   int numTessFaces,
-                                   int numLoops,
-                                   int numPolys,
-                                   const CustomData_MeshMasks *mask)
-{
-  CDDerivedMesh *cddm = cdDM_create("CDDM_from_template dest");
-  DerivedMesh *dm = &cddm->dm;
-
-  /* ensure these are created if they are made on demand */
-  source->getVertDataArray(source, CD_ORIGINDEX);
-  source->getEdgeDataArray(source, CD_ORIGINDEX);
-  source->getTessFaceDataArray(source, CD_ORIGINDEX);
-  source->getPolyDataArray(source, CD_ORIGINDEX);
-
-  /* this does a copy of all non mvert/medge/mface layers */
-  DM_from_template_ex(
-      dm, source, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces, numLoops, numPolys, mask);
-
-  /* now add mvert/medge/mface layers */
-  CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL, numVerts);
-  CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL, numEdges);
-  CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL, numTessFaces);
-  CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL, numLoops);
-  CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL, numPolys);
-
-  if (!CustomData_get_layer(&dm->vertData, CD_ORIGINDEX)) {
-    CustomData_add_layer(&dm->vertData, CD_ORIGINDEX, CD_CALLOC, NULL, numVerts);
-  }
-  if (!CustomData_get_layer(&dm->edgeData, CD_ORIGINDEX)) {
-    CustomData_add_layer(&dm->edgeData, CD_ORIGINDEX, CD_CALLOC, NULL, numEdges);
-  }
-  if (!CustomData_get_layer(&dm->faceData, CD_ORIGINDEX)) {
-    CustomData_add_layer(&dm->faceData, CD_ORIGINDEX, CD_CALLOC, NULL, numTessFaces);
-  }
-
-  cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
-  cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
-  cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
-  cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
-  cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
-
-  return dm;
-}
-DerivedMesh *CDDM_from_template(
-    DerivedMesh *source, int numVerts, int numEdges, int numTessFaces, int numLoops, int numPolys)
-{
-  return CDDM_from_template_ex(
-      source, numVerts, numEdges, numTessFaces, numLoops, numPolys, &CD_MASK_DERIVEDMESH);
-}
-
-void CDDM_apply_vert_coords(DerivedMesh *dm, float (*vertCoords)[3])
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-  MVert *vert;
-  int i;
-
-  /* this will just return the pointer if it wasn't a referenced layer */
-  vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
-  cddm->mvert = vert;
-
-  for (i = 0; i < dm->numVertData; ++i, ++vert) {
-    copy_v3_v3(vert->co, vertCoords[i]);
-  }
-
-  cddm->dm.dirty |= DM_DIRTY_NORMALS;
-}
-
-void CDDM_apply_vert_normals(DerivedMesh *dm, short (*vertNormals)[3])
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-  MVert *vert;
-  int i;
-
-  /* this will just return the pointer if it wasn't a referenced layer */
-  vert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
-  cddm->mvert = vert;
-
-  for (i = 0; i < dm->numVertData; ++i, ++vert) {
-    copy_v3_v3_short(vert->no, vertNormals[i]);
-  }
-
-  cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
-}
-
-void CDDM_calc_normals_mapping_ex(DerivedMesh *dm, const bool only_face_normals)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-  float(*face_nors)[3] = NULL;
-
-  if (dm->numVertData == 0) {
-    cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
-    return;
-  }
-
-  /* now we skip calculating vertex normals for referenced layer,
-   * no need to duplicate verts.
-   * WATCH THIS, bmesh only change!,
-   * need to take care of the side effects here - campbell */
-#if 0
-  /* we don't want to overwrite any referenced layers */
-  cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
-#endif
-
-#if 0
-  if (dm->numTessFaceData == 0) {
-    /* No tessellation on this mesh yet, need to calculate one.
-     *
-     * Important not to update face normals from polys since it
-     * interferes with assigning the new normal layer in the following code.
-     */
-    CDDM_recalc_tessellation_ex(dm, false);
-  }
-  else {
-    /* A tessellation already exists, it should always have a CD_ORIGINDEX */
-    BLI_assert(CustomData_has_layer(&dm->faceData, CD_ORIGINDEX));
-    CustomData_free_layers(&dm->faceData, CD_NORMAL, dm->numTessFaceData);
-  }
-#endif
-
-  face_nors = MEM_malloc_arrayN(dm->numPolyData, sizeof(*face_nors), "face_nors");
-
-  /* calculate face normals */
-  BKE_mesh_calc_normals_poly(cddm->mvert,
-                             NULL,
-                             dm->numVertData,
-                             CDDM_get_loops(dm),
-                             CDDM_get_polys(dm),
-                             dm->numLoopData,
-                             dm->numPolyData,
-                             face_nors,
-                             only_face_normals);
-
-  CustomData_add_layer(&dm->polyData, CD_NORMAL, CD_ASSIGN, face_nors, dm->numPolyData);
-
-  cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
-}
-
-void CDDM_calc_normals_mapping(DerivedMesh *dm)
-{
-  /* use this to skip calculating normals on original vert's, this may need to be changed */
-  const bool only_face_normals = CustomData_is_referenced_layer(&dm->vertData, CD_MVERT);
-
-  CDDM_calc_normals_mapping_ex(dm, only_face_normals);
-}
-
-#if 0
-/* bmesh note: this matches what we have in trunk */
-void CDDM_calc_normals(DerivedMesh *dm)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-  float(*poly_nors)[3];
-
-  if (dm->numVertData == 0) {
-    return;
-  }
-
-  /* we don't want to overwrite any referenced layers */
-  cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
-
-  /* fill in if it exists */
-  poly_nors = CustomData_get_layer(&dm->polyData, CD_NORMAL);
-  if (!poly_nors) {
-    poly_nors = CustomData_add_layer(&dm->polyData, CD_NORMAL, CD_CALLOC, NULL, dm->numPolyData);
-  }
-
-  BKE_mesh_calc_normals_poly(cddm->mvert,
-                             dm->numVertData,
-                             CDDM_get_loops(dm),
-                             CDDM_get_polys(dm),
-                             dm->numLoopData,
-                             dm->numPolyData,
-                             poly_nors,
-                             false);
-
-  cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
-}
-#else
-
-/* poly normal layer is now only for final display */
-void CDDM_calc_normals(DerivedMesh *dm)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-
-  /* we don't want to overwrite any referenced layers */
-  cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
-
-  BKE_mesh_calc_normals_poly(cddm->mvert,
-                             NULL,
-                             dm->numVertData,
-                             CDDM_get_loops(dm),
-                             CDDM_get_polys(dm),
-                             dm->numLoopData,
-                             dm->numPolyData,
-                             NULL,
-                             false);
-
-  cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
-}
-
-#endif
-
-void CDDM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, const float split_angle)
-{
-  CDDM_calc_loop_normals_spacearr(dm, use_split_normals, split_angle, NULL);
-}
-
 /* #define DEBUG_CLNORS */
 #ifdef DEBUG_CLNORS
 #  include "BLI_linklist.h"
 #endif
 
-void CDDM_calc_loop_normals_spacearr(DerivedMesh *dm,
-                                     const bool use_split_normals,
-                                     const float split_angle,
-                                     MLoopNorSpaceArray *r_lnors_spacearr)
-{
-  MVert *mverts = dm->getVertArray(dm);
-  MEdge *medges = dm->getEdgeArray(dm);
-  MLoop *mloops = dm->getLoopArray(dm);
-  MPoly *mpolys = dm->getPolyArray(dm);
-
-  CustomData *ldata, *pdata;
-
-  float(*lnors)[3];
-  short(*clnor_data)[2];
-  float(*pnors)[3];
-
-  const int numVerts = dm->getNumVerts(dm);
-  const int numEdges = dm->getNumEdges(dm);
-  const int numLoops = dm->getNumLoops(dm);
-  const int numPolys = dm->getNumPolys(dm);
-
-  ldata = dm->getLoopDataLayout(dm);
-  if (CustomData_has_layer(ldata, CD_NORMAL)) {
-    lnors = CustomData_get_layer(ldata, CD_NORMAL);
-  }
-  else {
-    lnors = CustomData_add_layer(ldata, CD_NORMAL, CD_CALLOC, NULL, numLoops);
-  }
-
-  /* Compute poly (always needed) and vert normals. */
-  /* Note we can't use DM_ensure_normals, since it won't keep computed poly nors... */
-  pdata = dm->getPolyDataLayout(dm);
-  pnors = CustomData_get_layer(pdata, CD_NORMAL);
-  if (!pnors) {
-    pnors = CustomData_add_layer(pdata, CD_NORMAL, CD_CALLOC, NULL, numPolys);
-  }
-  BKE_mesh_calc_normals_poly(mverts,
-                             NULL,
-                             numVerts,
-                             mloops,
-                             mpolys,
-                             numLoops,
-                             numPolys,
-                             pnors,
-                             (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
-
-  dm->dirty &= ~DM_DIRTY_NORMALS;
-
-  clnor_data = CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL);
-
-  BKE_mesh_normals_loop_split(mverts,
-                              numVerts,
-                              medges,
-                              numEdges,
-                              mloops,
-                              lnors,
-                              numLoops,
-                              mpolys,
-                              (const float(*)[3])pnors,
-                              numPolys,
-                              use_split_normals,
-                              split_angle,
-                              r_lnors_spacearr,
-                              clnor_data,
-                              NULL);
-#ifdef DEBUG_CLNORS
-  if (r_lnors_spacearr) {
-    int i;
-    for (i = 0; i < numLoops; i++) {
-      if (r_lnors_spacearr->lspacearr[i]->ref_alpha != 0.0f) {
-        LinkNode *loops = r_lnors_spacearr->lspacearr[i]->loops;
-        printf("Loop %d uses lnor space %p:\n", i, r_lnors_spacearr->lspacearr[i]);
-        print_v3("\tfinal lnor", lnors[i]);
-        print_v3("\tauto lnor", r_lnors_spacearr->lspacearr[i]->vec_lnor);
-        print_v3("\tref_vec", r_lnors_spacearr->lspacearr[i]->vec_ref);
-        printf("\talpha: %f\n\tbeta: %f\n\tloops: %p\n",
-               r_lnors_spacearr->lspacearr[i]->ref_alpha,
-               r_lnors_spacearr->lspacearr[i]->ref_beta,
-               r_lnors_spacearr->lspacearr[i]->loops);
-        printf("\t\t(shared with loops");
-        while (loops) {
-          printf(" %d", POINTER_AS_INT(loops->link));
-          loops = loops->next;
-        }
-        printf(")\n");
-      }
-      else {
-        printf("Loop %d has no lnor space\n", i);
-      }
-    }
-  }
-#endif
-}
-
-void CDDM_lower_num_verts(DerivedMesh *dm, int numVerts)
-{
-  BLI_assert(numVerts >= 0);
-  if (numVerts < dm->numVertData) {
-    CustomData_free_elem(&dm->vertData, numVerts, dm->numVertData - numVerts);
-  }
-
-  dm->numVertData = numVerts;
-}
-
-void CDDM_lower_num_edges(DerivedMesh *dm, int numEdges)
-{
-  BLI_assert(numEdges >= 0);
-  if (numEdges < dm->numEdgeData) {
-    CustomData_free_elem(&dm->edgeData, numEdges, dm->numEdgeData - numEdges);
-  }
-
-  dm->numEdgeData = numEdges;
-}
-
-void CDDM_lower_num_tessfaces(DerivedMesh *dm, int numTessFaces)
-{
-  BLI_assert(numTessFaces >= 0);
-  if (numTessFaces < dm->numTessFaceData) {
-    CustomData_free_elem(&dm->faceData, numTessFaces, dm->numTessFaceData - numTessFaces);
-  }
-
-  dm->numTessFaceData = numTessFaces;
-}
-
-void CDDM_lower_num_loops(DerivedMesh *dm, int numLoops)
-{
-  BLI_assert(numLoops >= 0);
-  if (numLoops < dm->numLoopData) {
-    CustomData_free_elem(&dm->loopData, numLoops, dm->numLoopData - numLoops);
-  }
-
-  dm->numLoopData = numLoops;
-}
-
-void CDDM_lower_num_polys(DerivedMesh *dm, int numPolys)
-{
-  BLI_assert(numPolys >= 0);
-  if (numPolys < dm->numPolyData) {
-    CustomData_free_elem(&dm->polyData, numPolys, dm->numPolyData - numPolys);
-  }
-
-  dm->numPolyData = numPolys;
-}
-
 /* mesh element access functions */
 
 MVert *CDDM_get_vert(DerivedMesh *dm, int index)
@@ -1427,58 +618,3 @@ MPoly *CDDM_get_polys(DerivedMesh *dm)
 {
   return ((CDDerivedMesh *)dm)->mpoly;
 }
-
-void CDDM_set_mvert(DerivedMesh *dm, MVert *mvert)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-
-  if (!CustomData_has_layer(&dm->vertData, CD_MVERT)) {
-    CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, mvert, dm->numVertData);
-  }
-
-  cddm->mvert = mvert;
-}
-
-void CDDM_set_medge(DerivedMesh *dm, MEdge *medge)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-
-  if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE)) {
-    CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, medge, dm->numEdgeData);
-  }
-
-  cddm->medge = medge;
-}
-
-void CDDM_set_mface(DerivedMesh *dm, MFace *mface)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-
-  if (!CustomData_has_layer(&dm->faceData, CD_MFACE)) {
-    CustomData_add_layer(&dm->faceData, CD_MFACE, CD_ASSIGN, mface, dm->numTessFaceData);
-  }
-
-  cddm->mface = mface;
-}
-
-void CDDM_set_mloop(DerivedMesh *dm, MLoop *mloop)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-
-  if (!CustomData_has_layer(&dm->loopData, CD_MLOOP)) {
-    CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_ASSIGN, mloop, dm->numLoopData);
-  }
-
-  cddm->mloop = mloop;
-}
-
-void CDDM_set_mpoly(DerivedMesh *dm, MPoly *mpoly)
-{
-  CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-
-  if (!CustomData_has_layer(&dm->polyData, CD_MPOLY)) {
-    CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_ASSIGN, mpoly, dm->numPolyData);
-  }
-
-  cddm->mpoly = mpoly;
-}