TexFace removal part 3

- MTexPoly structure & layer type.
- The 'Mesh.uv_textures' layers.
- DerivedMesh TexFace drawing.
- Scripts & UI.

12 files changed, 99 insertions, 240 deletions

diff --git a/source/blender/blenkernel/BKE_customdata.h b/source/blender/blenkernel/BKE_customdata.h
index 2cdda34b9b5..51cd4da183a 100644
--- a/source/blender/blenkernel/BKE_customdata.h
+++ b/source/blender/blenkernel/BKE_customdata.h
@@ -376,15 +376,14 @@ void CustomData_validate_layer_name(const struct CustomData *data, int type, con
 bool CustomData_verify_versions(struct CustomData *data, int index);
 
 /*BMesh specific customdata stuff*/
-void CustomData_to_bmeshpoly(struct CustomData *fdata, struct CustomData *pdata,
-                             struct CustomData *ldata, int totloop, int totpoly);
-void CustomData_from_bmeshpoly(struct CustomData *fdata, struct CustomData *pdata, struct CustomData *ldata, int total);
-void CustomData_bmesh_update_active_layers(struct CustomData *fdata, struct CustomData *pdata, struct CustomData *ldata);
-void CustomData_bmesh_do_versions_update_active_layers(struct CustomData *fdata, struct CustomData *pdata, struct CustomData *ldata);
+void CustomData_to_bmeshpoly(struct CustomData *fdata, struct CustomData *ldata, int totloop);
+void CustomData_from_bmeshpoly(struct CustomData *fdata, struct CustomData *ldata, int total);
+void CustomData_bmesh_update_active_layers(struct CustomData *fdata, struct CustomData *ldata);
+void CustomData_bmesh_do_versions_update_active_layers(struct CustomData *fdata, struct CustomData *ldata);
 void CustomData_bmesh_init_pool(struct CustomData *data, int totelem, const char htype);
 
 #ifndef NDEBUG
-bool CustomData_from_bmeshpoly_test(CustomData *fdata, CustomData *pdata, CustomData *ldata, bool fallback);
+bool CustomData_from_bmeshpoly_test(CustomData *fdata, CustomData *ldata, bool fallback);
 #endif
 
 /* External file storage */
diff --git a/source/blender/blenkernel/BKE_editmesh.h b/source/blender/blenkernel/BKE_editmesh.h
index 55a9db9b1e5..9ee1bcf2d37 100644
--- a/source/blender/blenkernel/BKE_editmesh.h
+++ b/source/blender/blenkernel/BKE_editmesh.h
@@ -88,7 +88,6 @@ BMEditMesh *BKE_editmesh_copy(BMEditMesh *em);
 BMEditMesh *BKE_editmesh_from_object(struct Object *ob);
 void        BKE_editmesh_free_derivedmesh(BMEditMesh *em);
 void        BKE_editmesh_free(BMEditMesh *em);
-void        BKE_editmesh_update_linked_customdata(BMEditMesh *em);
 
 void        BKE_editmesh_color_free(BMEditMesh *em);
 void        BKE_editmesh_color_ensure(BMEditMesh *em, const char htype);
diff --git a/source/blender/blenkernel/BKE_mesh.h b/source/blender/blenkernel/BKE_mesh.h
index 64f71f0ade5..57922e60f4b 100644
--- a/source/blender/blenkernel/BKE_mesh.h
+++ b/source/blender/blenkernel/BKE_mesh.h
@@ -287,7 +287,7 @@ void BKE_mesh_loops_to_mface_corners(
         const int numTex, const int numCol,
         const bool hasPCol, const bool hasOrigSpace, const bool hasLNor);
 void BKE_mesh_loops_to_tessdata(
-        struct CustomData *fdata, struct CustomData *ldata, struct CustomData *pdata, struct MFace *mface,
+        struct CustomData *fdata, struct CustomData *ldata, struct MFace *mface,
         int *polyindices, unsigned int (*loopindices)[4], const int num_faces);
 void BKE_mesh_tangent_loops_to_tessdata(
         struct CustomData *fdata, struct CustomData *ldata, struct MFace *mface,
@@ -365,7 +365,6 @@ void BKE_mesh_calc_relative_deform(
 /* *** mesh_validate.c *** */
 
 int BKE_mesh_validate(struct Mesh *me, const int do_verbose, const int cddata_check_mask);
-void BKE_mesh_cd_validate(struct Mesh *me);
 int BKE_mesh_validate_material_indices(struct Mesh *me);
 
 bool BKE_mesh_validate_arrays(
diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 871a25b0d7e..93a26082ee3 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -533,7 +533,6 @@ void DM_update_tessface_data(DerivedMesh *dm)
 	MLoop *ml = dm->getLoopArray(dm);
 
 	CustomData *fdata = dm->getTessFaceDataLayout(dm);
-	CustomData *pdata = dm->getPolyDataLayout(dm);
 	CustomData *ldata = dm->getLoopDataLayout(dm);
 
 	const int totface = dm->getNumTessFaces(dm);
@@ -546,7 +545,7 @@ void DM_update_tessface_data(DerivedMesh *dm)
 	if (!polyindex)
 		return;
 
-	CustomData_from_bmeshpoly(fdata, pdata, ldata, totface);
+	CustomData_from_bmeshpoly(fdata, ldata, totface);
 
 	if (CustomData_has_layer(fdata, CD_MTFACE) ||
 	    CustomData_has_layer(fdata, CD_MCOL) ||
@@ -578,7 +577,7 @@ void DM_update_tessface_data(DerivedMesh *dm)
 		 * 0 for quads (because our quads may have been rotated compared to their org poly, see tessellation code).
 		 * So we pass the MFace's, and BKE_mesh_loops_to_tessdata will use MFace->v4 index as quad test.
 		 */
-		BKE_mesh_loops_to_tessdata(fdata, ldata, pdata, mface, polyindex, loopindex, totface);
+		BKE_mesh_loops_to_tessdata(fdata, ldata, mface, polyindex, loopindex, totface);
 
 		MEM_freeN(loopindex);
 	}
@@ -596,7 +595,6 @@ void DM_generate_tangent_tessface_data(DerivedMesh *dm, bool generate)
 	MLoop *ml = dm->getLoopArray(dm);
 
 	CustomData *fdata = dm->getTessFaceDataLayout(dm);
-	CustomData *pdata = dm->getPolyDataLayout(dm);
 	CustomData *ldata = dm->getLoopDataLayout(dm);
 
 	const int totface = dm->getNumTessFaces(dm);
@@ -613,7 +611,7 @@ void DM_generate_tangent_tessface_data(DerivedMesh *dm, bool generate)
 		for (int j = 0; j < ldata->totlayer; j++) {
 			if (ldata->layers[j].type == CD_TANGENT) {
 				CustomData_add_layer_named(fdata, CD_TANGENT, CD_CALLOC, NULL, totface, ldata->layers[j].name);
-				CustomData_bmesh_update_active_layers(fdata, pdata, ldata);
+				CustomData_bmesh_update_active_layers(fdata, ldata);
 
 				if (!loopindex) {
 					loopindex = MEM_mallocN(sizeof(*loopindex) * totface, __func__);
@@ -643,7 +641,7 @@ void DM_generate_tangent_tessface_data(DerivedMesh *dm, bool generate)
 		}
 		if (loopindex)
 			MEM_freeN(loopindex);
-		BLI_assert(CustomData_from_bmeshpoly_test(fdata, pdata, ldata, true));
+		BLI_assert(CustomData_from_bmeshpoly_test(fdata, ldata, true));
 	}
 
 	if (G.debug & G_DEBUG)
diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c
index 63d105e24b1..18fe6d1deee 100644
--- a/source/blender/blenkernel/intern/cdderivedmesh.c
+++ b/source/blender/blenkernel/intern/cdderivedmesh.c
@@ -1784,7 +1784,7 @@ void CDDM_recalc_tessellation_ex(DerivedMesh *dm, const bool do_face_nor_cpy)
 
 	/* 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->polyData, &dm->loopData);
+	CustomData_bmesh_update_active_layers(&dm->faceData, &dm->loopData);
 }
 
 void CDDM_recalc_tessellation(DerivedMesh *dm)
@@ -2031,7 +2031,6 @@ DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase)
 
 	if (alluv) {
 		const char *uvname = "Orco";
-		CustomData_add_layer_named(&cddm->dm.polyData, CD_MTEXPOLY, CD_DEFAULT, NULL, totpoly, uvname);
 		CustomData_add_layer_named(&cddm->dm.loopData, CD_MLOOPUV, CD_ASSIGN, alluv, totloop, uvname);
 	}
 
@@ -2046,7 +2045,7 @@ DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase)
 static void loops_to_customdata_corners(
         BMesh *bm, CustomData *facedata,
         int cdindex, const BMLoop *l3[3],
-        int numCol, int numTex)
+        int numCol, int numUV)
 {
 	const BMLoop *l;
 //	BMFace *f = l3[0]->f;
@@ -2056,7 +2055,7 @@ static void loops_to_customdata_corners(
 	MLoopUV *mloopuv;
 	int i, j, hasPCol = CustomData_has_layer(&bm->ldata, CD_PREVIEW_MLOOPCOL);
 
-	for (i = 0; i < numTex; i++) {
+	for (i = 0; i < numUV; i++) {
 		texface = CustomData_get_n(facedata, CD_MTFACE, cdindex, i);
 	
 		for (j = 0; j < 3; j++) {
@@ -2111,7 +2110,7 @@ static DerivedMesh *cddm_from_bmesh_ex(
 	MLoop *mloop = cddm->mloop;
 	MPoly *mpoly = cddm->mpoly;
 	int numCol = CustomData_number_of_layers(&bm->ldata, CD_MLOOPCOL);
-	int numTex = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
+	int numUV  = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
 	int *index, add_orig;
 	CustomDataMask mask;
 	unsigned int i, j;
@@ -2141,7 +2140,7 @@ static DerivedMesh *cddm_from_bmesh_ex(
 
 	/* add tessellation mface layers */
 	if (use_tessface) {
-		CustomData_from_bmeshpoly(&dm->faceData, &dm->polyData, &dm->loopData, em_tottri);
+		CustomData_from_bmeshpoly(&dm->faceData, &dm->loopData, em_tottri);
 	}
 
 	index = dm->getVertDataArray(dm, CD_ORIGINDEX);
@@ -2213,7 +2212,7 @@ static DerivedMesh *cddm_from_bmesh_ex(
 			/* 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, numTex);
+			loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numUV);
 			test_index_face(mf, &dm->faceData, i, 3);
 		}
 	}
diff --git a/source/blender/blenkernel/intern/customdata.c b/source/blender/blenkernel/intern/customdata.c
index d4f60c62827..c672e77a520 100644
--- a/source/blender/blenkernel/intern/customdata.c
+++ b/source/blender/blenkernel/intern/customdata.c
@@ -1210,10 +1210,9 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
 	 layerInterp_origspace_face, layerSwap_origspace_face, layerDefault_origspace_face},
 	/* 14: CD_ORCO */
 	{sizeof(float) * 3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
-	/* 15: CD_MTEXPOLY */
+	/* 15: CD_MTEXPOLY */  /* DEPRECATED */
 	/* note, when we expose the UV Map / TexFace split to the user, change this back to face Texture */
-	{sizeof(MTexPoly), "MTexPoly", 1, N_("UVMap") /* "Face Texture" */, NULL, NULL, NULL, NULL, NULL,
-	 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, layerMaxNum_tface},
+	{sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
 	/* 16: CD_MLOOPUV */
 	{sizeof(MLoopUV), "MLoopUV", 1, N_("UVMap"), NULL, NULL, layerInterp_mloopuv, NULL, NULL,
 	 layerEqual_mloopuv, layerMultiply_mloopuv, layerInitMinMax_mloopuv, 
@@ -1313,25 +1312,25 @@ const CustomDataMask CD_MASK_MESH =
     CD_MASK_MDEFORMVERT |
     CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS |
     CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MPOLY | CD_MASK_MLOOP |
-    CD_MASK_MTEXPOLY | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
+    CD_MASK_RECAST | CD_MASK_PAINT_MASK |
     CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
     CD_MASK_CUSTOMLOOPNORMAL;
 const CustomDataMask CD_MASK_EDITMESH =
     CD_MASK_MDEFORMVERT | CD_MASK_MLOOPUV |
-    CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_SHAPE_KEYINDEX |
+    CD_MASK_MLOOPCOL | CD_MASK_SHAPE_KEYINDEX |
     CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR |
     CD_MASK_MDISPS | CD_MASK_SHAPEKEY | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
     CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_CUSTOMLOOPNORMAL;
 const CustomDataMask CD_MASK_DERIVEDMESH =
     CD_MASK_MDEFORMVERT |
     CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_CLOTH_ORCO |
-    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_PREVIEW_MLOOPCOL |
+    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_PREVIEW_MLOOPCOL |
     CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORIGSPACE_MLOOP | CD_MASK_ORCO | CD_MASK_TANGENT |
     CD_MASK_PREVIEW_MCOL | CD_MASK_SHAPEKEY | CD_MASK_RECAST |
     CD_MASK_ORIGINDEX | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
     CD_MASK_CUSTOMLOOPNORMAL;
 const CustomDataMask CD_MASK_BMESH =
-    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY |
+    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL |
     CD_MASK_MDEFORMVERT | CD_MASK_PROP_FLT | CD_MASK_PROP_INT |
     CD_MASK_PROP_STR | CD_MASK_SHAPEKEY | CD_MASK_SHAPE_KEYINDEX | CD_MASK_MDISPS |
     CD_MASK_CREASE | CD_MASK_BWEIGHT | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
@@ -1341,7 +1340,7 @@ const CustomDataMask CD_MASK_BMESH =
  * cover values copied by #BKE_mesh_loops_to_tessdata
  */
 const CustomDataMask CD_MASK_FACECORNERS =
-    CD_MASK_MTFACE | CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV |
+    CD_MASK_MTFACE | CD_MASK_MLOOPUV |
     CD_MASK_MCOL | CD_MASK_MLOOPCOL |
     CD_MASK_PREVIEW_MCOL | CD_MASK_PREVIEW_MLOOPCOL |
     CD_MASK_ORIGSPACE | CD_MASK_ORIGSPACE_MLOOP |
@@ -1350,7 +1349,7 @@ const CustomDataMask CD_MASK_FACECORNERS =
 const CustomDataMask CD_MASK_EVERYTHING =
     CD_MASK_MVERT | CD_MASK_MDEFORMVERT | CD_MASK_MEDGE | CD_MASK_MFACE |
     CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_ORIGINDEX | CD_MASK_NORMAL /* | CD_MASK_POLYINDEX */ | CD_MASK_PROP_FLT |
-    CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORCO | CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV |
+    CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORCO | CD_MASK_MLOOPUV |
     CD_MASK_MLOOPCOL | CD_MASK_TANGENT | CD_MASK_MDISPS | CD_MASK_PREVIEW_MCOL | CD_MASK_CLOTH_ORCO | CD_MASK_RECAST |
     /* BMESH ONLY START */
     CD_MASK_MPOLY | CD_MASK_MLOOP | CD_MASK_SHAPE_KEYINDEX | CD_MASK_SHAPEKEY | CD_MASK_BWEIGHT | CD_MASK_CREASE |
@@ -2478,13 +2477,10 @@ void CustomData_set(const CustomData *data, int index, int type, const void *sou
 
 /* BMesh functions */
 /* needed to convert to/from different face reps */
-void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata,
-                             int totloop, int totpoly)
+void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *ldata, int totloop)
 {
-	int i;
-	for (i = 0; i < fdata->totlayer; i++) {
+	for (int i = 0; i < fdata->totlayer; i++) {
 		if (fdata->layers[i].type == CD_MTFACE) {
-			CustomData_add_layer_named(pdata, CD_MTEXPOLY, CD_CALLOC, NULL, totpoly, fdata->layers[i].name);
 			CustomData_add_layer_named(ldata, CD_MLOOPUV, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
 		}
 		else if (fdata->layers[i].type == CD_MCOL) {
@@ -2499,19 +2495,18 @@ void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *l
 	}
 }
 
-void CustomData_from_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata, int total)
+void CustomData_from_bmeshpoly(
+        CustomData *fdata, CustomData *ldata, int total)
 {
 	int i;
 
 	/* avoid accumulating extra layers */
-	BLI_assert(!CustomData_from_bmeshpoly_test(fdata, pdata, ldata, false));
+	BLI_assert(!CustomData_from_bmeshpoly_test(fdata, ldata, false));
 
-	for (i = 0; i < pdata->totlayer; i++) {
-		if (pdata->layers[i].type == CD_MTEXPOLY) {
-			CustomData_add_layer_named(fdata, CD_MTFACE, CD_CALLOC, NULL, total, pdata->layers[i].name);
-		}
-	}
 	for (i = 0; i < ldata->totlayer; i++) {
+		if (ldata->layers[i].type == CD_MLOOPUV) {
+			CustomData_add_layer_named(fdata, CD_MTFACE, CD_CALLOC, NULL, total, ldata->layers[i].name);
+		}
 		if (ldata->layers[i].type == CD_MLOOPCOL) {
 			CustomData_add_layer_named(fdata, CD_MCOL, CD_CALLOC, NULL, total, ldata->layers[i].name);
 		}
@@ -2529,7 +2524,7 @@ void CustomData_from_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData
 		}
 	}
 
-	CustomData_bmesh_update_active_layers(fdata, pdata, ldata);
+	CustomData_bmesh_update_active_layers(fdata, ldata);
 }
 
 #ifndef NDEBUG
@@ -2539,13 +2534,13 @@ void CustomData_from_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData
  * \param fallback: Use when there are no layers to handle,
  * since callers may expect success or failure.
  */
-bool CustomData_from_bmeshpoly_test(CustomData *fdata, CustomData *pdata, CustomData *ldata, bool fallback)
+bool CustomData_from_bmeshpoly_test(CustomData *fdata, CustomData *ldata, bool fallback)
 {
 	int a_num = 0, b_num = 0;
 #define LAYER_CMP(l_a, t_a, l_b, t_b) \
 	((a_num += CustomData_number_of_layers(l_a, t_a)) == (b_num += CustomData_number_of_layers(l_b, t_b)))
 
-	if (!LAYER_CMP(pdata, CD_MTEXPOLY, fdata, CD_MTFACE))
+	if (!LAYER_CMP(ldata, CD_MLOOPUV, fdata, CD_MTFACE))
 		return false;
 	if (!LAYER_CMP(ldata, CD_MLOOPCOL, fdata, CD_MCOL))
 		return false;
@@ -2567,25 +2562,21 @@ bool CustomData_from_bmeshpoly_test(CustomData *fdata, CustomData *pdata, Custom
 #endif
 
 
-void CustomData_bmesh_update_active_layers(CustomData *fdata, CustomData *pdata, CustomData *ldata)
+void CustomData_bmesh_update_active_layers(CustomData *fdata, CustomData *ldata)
 {
 	int act;
 
-	if (CustomData_has_layer(pdata, CD_MTEXPOLY)) {
-		act = CustomData_get_active_layer(pdata, CD_MTEXPOLY);
-		CustomData_set_layer_active(ldata, CD_MLOOPUV, act);
+	if (CustomData_has_layer(ldata, CD_MLOOPUV)) {
+		act = CustomData_get_active_layer(ldata, CD_MLOOPUV);
 		CustomData_set_layer_active(fdata, CD_MTFACE, act);
 
-		act = CustomData_get_render_layer(pdata, CD_MTEXPOLY);
-		CustomData_set_layer_render(ldata, CD_MLOOPUV, act);
+		act = CustomData_get_render_layer(ldata, CD_MLOOPUV);
 		CustomData_set_layer_render(fdata, CD_MTFACE, act);
 
-		act = CustomData_get_clone_layer(pdata, CD_MTEXPOLY);
-		CustomData_set_layer_clone(ldata, CD_MLOOPUV, act);
+		act = CustomData_get_clone_layer(ldata, CD_MLOOPUV);
 		CustomData_set_layer_clone(fdata, CD_MTFACE, act);
 
-		act = CustomData_get_stencil_layer(pdata, CD_MTEXPOLY);
-		CustomData_set_layer_stencil(ldata, CD_MLOOPUV, act);
+		act = CustomData_get_stencil_layer(ldata, CD_MLOOPUV);
 		CustomData_set_layer_stencil(fdata, CD_MTFACE, act);
 	}
 
@@ -2609,25 +2600,21 @@ void CustomData_bmesh_update_active_layers(CustomData *fdata, CustomData *pdata,
  * used by do_versions in readfile.c when creating pdata and ldata for pre-bmesh
  * meshes and needed to preserve active/render/clone/stencil flags set in pre-bmesh files
  */
-void CustomData_bmesh_do_versions_update_active_layers(CustomData *fdata, CustomData *pdata, CustomData *ldata)
+void CustomData_bmesh_do_versions_update_active_layers(CustomData *fdata, CustomData *ldata)
 {
 	int act;
 
 	if (CustomData_has_layer(fdata, CD_MTFACE)) {
 		act = CustomData_get_active_layer(fdata, CD_MTFACE);
-		CustomData_set_layer_active(pdata, CD_MTEXPOLY, act);
 		CustomData_set_layer_active(ldata, CD_MLOOPUV, act);
 
 		act = CustomData_get_render_layer(fdata, CD_MTFACE);
-		CustomData_set_layer_render(pdata, CD_MTEXPOLY, act);
 		CustomData_set_layer_render(ldata, CD_MLOOPUV, act);
 
 		act = CustomData_get_clone_layer(fdata, CD_MTFACE);
-		CustomData_set_layer_clone(pdata, CD_MTEXPOLY, act);
 		CustomData_set_layer_clone(ldata, CD_MLOOPUV, act);
 
 		act = CustomData_get_stencil_layer(fdata, CD_MTFACE);
-		CustomData_set_layer_stencil(pdata, CD_MTEXPOLY, act);
 		CustomData_set_layer_stencil(ldata, CD_MLOOPUV, act);
 	}
 
diff --git a/source/blender/blenkernel/intern/data_transfer.c b/source/blender/blenkernel/intern/data_transfer.c
index 3bc09c0173b..a83ec8f0486 100644
--- a/source/blender/blenkernel/intern/data_transfer.c
+++ b/source/blender/blenkernel/intern/data_transfer.c
@@ -79,7 +79,7 @@ CustomDataMask BKE_object_data_transfer_dttypes_to_cdmask(const int dtdata_types
 			cddata_mask |= CD_MASK_MDEFORMVERT;  /* Exception for vgroups :/ */
 		}
 		else if (cddata_type == CD_FAKE_UV) {
-			cddata_mask |= CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV;
+			cddata_mask |= CD_MASK_MLOOPUV;
 		}
 		else if (cddata_type == CD_FAKE_LNOR) {
 			cddata_mask |= CD_MASK_NORMAL | CD_MASK_CUSTOMLOOPNORMAL;
@@ -962,7 +962,7 @@ static bool data_transfer_layersmapping_generate(
 	}
 	else if (elem_type == ME_POLY) {
 		if (cddata_type == CD_FAKE_UV) {
-			cddata_type = CD_MTEXPOLY;
+			cddata_type = CD_MLOOPUV;
 		}
 
 		if (!(cddata_type & CD_FAKE)) {
diff --git a/source/blender/blenkernel/intern/editderivedmesh.c b/source/blender/blenkernel/intern/editderivedmesh.c
index 4179b79ba73..7d895e36be4 100644
--- a/source/blender/blenkernel/intern/editderivedmesh.c
+++ b/source/blender/blenkernel/intern/editderivedmesh.c
@@ -1457,14 +1457,8 @@ static void *emDM_getTessFaceDataArray(DerivedMesh *dm, int type)
 	if (type == CD_MTFACE || type == CD_MCOL) {
 		const char *bmdata;
 		char *data;
-		bool has_type_source = false;
 
-		if (type == CD_MTFACE) {
-			has_type_source = CustomData_has_layer(&bm->pdata, CD_MTEXPOLY);
-		}
-		else {
-			has_type_source = CustomData_has_layer(&bm->ldata, CD_MLOOPCOL);
-		}
+		bool has_type_source = CustomData_has_layer(&bm->ldata, (type == CD_MTFACE) ? CD_MLOOPUV : CD_MLOOPCOL);
 
 		if (has_type_source) {
 			/* offset = bm->pdata.layers[index].offset; */ /* UNUSED */
@@ -1480,14 +1474,8 @@ static void *emDM_getTessFaceDataArray(DerivedMesh *dm, int type)
 
 			if (type == CD_MTFACE) {
 				const int cd_loop_uv_offset  = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
-				const int cd_poly_tex_offset = CustomData_get_offset(&bm->pdata, CD_MTEXPOLY);
 
 				for (i = 0; i < bmdm->em->tottri; i++, data += size) {
-					BMFace *efa = looptris[i][0]->f;
-
-					// bmdata = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_MTEXPOLY);
-					bmdata = BM_ELEM_CD_GET_VOID_P(efa, cd_poly_tex_offset);
-
 					for (j = 0; j < 3; j++) {
 						// bmdata = CustomData_bmesh_get(&bm->ldata, looptris[i][j]->head.data, CD_MLOOPUV);
 						bmdata = BM_ELEM_CD_GET_VOID_P(looptris[i][j], cd_loop_uv_offset);
diff --git a/source/blender/blenkernel/intern/editmesh.c b/source/blender/blenkernel/intern/editmesh.c
index fea3c24d322..c95da3b2569 100644
--- a/source/blender/blenkernel/intern/editmesh.c
+++ b/source/blender/blenkernel/intern/editmesh.c
@@ -165,26 +165,6 @@ void BKE_editmesh_tessface_calc(BMEditMesh *em)
 #endif
 }
 
-void BKE_editmesh_update_linked_customdata(BMEditMesh *em)
-{
-	BMesh *bm = em->bm;
-	int act;
-
-	if (CustomData_has_layer(&bm->pdata, CD_MTEXPOLY)) {
-		act = CustomData_get_active_layer(&bm->pdata, CD_MTEXPOLY);
-		CustomData_set_layer_active(&bm->ldata, CD_MLOOPUV, act);
-
-		act = CustomData_get_render_layer(&bm->pdata, CD_MTEXPOLY);
-		CustomData_set_layer_render(&bm->ldata, CD_MLOOPUV, act);
-
-		act = CustomData_get_clone_layer(&bm->pdata, CD_MTEXPOLY);
-		CustomData_set_layer_clone(&bm->ldata, CD_MLOOPUV, act);
-
-		act = CustomData_get_stencil_layer(&bm->pdata, CD_MTEXPOLY);
-		CustomData_set_layer_stencil(&bm->ldata, CD_MLOOPUV, act);
-	}
-}
-
 void BKE_editmesh_free_derivedmesh(BMEditMesh *em)
 {
 	if (em->derivedCage) {
diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c
index d45223f2a51..768ca0bd4f7 100644
--- a/source/blender/blenkernel/intern/mesh.c
+++ b/source/blender/blenkernel/intern/mesh.c
@@ -126,7 +126,7 @@ static int customdata_compare(CustomData *c1, CustomData *c2, Mesh *m1, Mesh *m2
 	
 	for (i = 0; i < c1->totlayer; i++) {
 		if (ELEM(c1->layers[i].type, CD_MVERT, CD_MEDGE, CD_MPOLY,
-		         CD_MLOOPUV, CD_MLOOPCOL, CD_MTEXPOLY, CD_MDEFORMVERT))
+		         CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT))
 		{
 			i1++;
 		}
@@ -134,7 +134,7 @@ static int customdata_compare(CustomData *c1, CustomData *c2, Mesh *m1, Mesh *m2
 
 	for (i = 0; i < c2->totlayer; i++) {
 		if (ELEM(c2->layers[i].type, CD_MVERT, CD_MEDGE, CD_MPOLY,
-		         CD_MLOOPUV, CD_MLOOPCOL, CD_MTEXPOLY, CD_MDEFORMVERT))
+		         CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT))
 		{
 			i2++;
 		}
@@ -148,14 +148,14 @@ static int customdata_compare(CustomData *c1, CustomData *c2, Mesh *m1, Mesh *m2
 	i1 = 0; i2 = 0;
 	for (i = 0; i < tot; i++) {
 		while (i1 < c1->totlayer && !ELEM(l1->type, CD_MVERT, CD_MEDGE, CD_MPOLY,
-		                                  CD_MLOOPUV, CD_MLOOPCOL, CD_MTEXPOLY, CD_MDEFORMVERT))
+		                                  CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT))
 		{
 			i1++;
 			l1++;
 		}
 
 		while (i2 < c2->totlayer && !ELEM(l2->type, CD_MVERT, CD_MEDGE, CD_MPOLY,
-		                                  CD_MLOOPUV, CD_MLOOPCOL, CD_MTEXPOLY, CD_MDEFORMVERT))
+		                                  CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT))
 		{
 			i2++;
 			l2++;
@@ -323,7 +323,7 @@ static void mesh_ensure_tessellation_customdata(Mesh *me)
 		 * Callers could also check but safer to do here - campbell */
 	}
 	else {
-		const int tottex_original = CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY);
+		const int tottex_original = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
 		const int totcol_original = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
 
 		const int tottex_tessface = CustomData_number_of_layers(&me->fdata, CD_MTFACE);
@@ -334,7 +334,7 @@ static void mesh_ensure_tessellation_customdata(Mesh *me)
 		{
 			BKE_mesh_tessface_clear(me);
 
-			CustomData_from_bmeshpoly(&me->fdata, &me->pdata, &me->ldata, me->totface);
+			CustomData_from_bmeshpoly(&me->fdata, &me->ldata, me->totface);
 
 			/* TODO - add some --debug-mesh option */
 			if (G.debug & G_DEBUG) {
@@ -343,7 +343,7 @@ static void mesh_ensure_tessellation_customdata(Mesh *me)
 				 * and check if there was any data to begin with, for now just print the warning with
 				 * some info to help troubleshoot whats going on - campbell */
 				printf("%s: warning! Tessellation uvs or vcol data got out of sync, "
-				       "had to reset!\n    CD_MTFACE: %d != CD_MTEXPOLY: %d || CD_MCOL: %d != CD_MLOOPCOL: %d\n",
+				       "had to reset!\n    CD_MTFACE: %d != CD_MLOOPUV: %d || CD_MCOL: %d != CD_MLOOPCOL: %d\n",
 				       __func__, tottex_tessface, tottex_original, totcol_tessface, totcol_original);
 			}
 		}
@@ -395,14 +395,11 @@ void BKE_mesh_ensure_skin_customdata(Mesh *me)
  * versions of the mesh. - campbell*/
 static void mesh_update_linked_customdata(Mesh *me, const bool do_ensure_tess_cd)
 {
-	if (me->edit_btmesh)
-		BKE_editmesh_update_linked_customdata(me->edit_btmesh);
-
 	if (do_ensure_tess_cd) {
 		mesh_ensure_tessellation_customdata(me);
 	}
 
-	CustomData_bmesh_update_active_layers(&me->fdata, &me->pdata, &me->ldata);
+	CustomData_bmesh_update_active_layers(&me->fdata, &me->ldata);
 }
 
 void BKE_mesh_update_customdata_pointers(Mesh *me, const bool do_ensure_tess_cd)
@@ -421,7 +418,6 @@ void BKE_mesh_update_customdata_pointers(Mesh *me, const bool do_ensure_tess_cd)
 	me->mpoly = CustomData_get_layer(&me->pdata, CD_MPOLY);
 	me->mloop = CustomData_get_layer(&me->ldata, CD_MLOOP);
 
-	me->mtpoly = CustomData_get_layer(&me->pdata, CD_MTEXPOLY);
 	me->mloopcol = CustomData_get_layer(&me->ldata, CD_MLOOPCOL);
 	me->mloopuv = CustomData_get_layer(&me->ldata, CD_MLOOPUV);
 }
@@ -585,24 +581,34 @@ bool BKE_mesh_uv_cdlayer_rename_index(Mesh *me, const int poly_index, const int
 		ldata = &me->ldata;
 		fdata = &me->fdata;
 	}
-	cdlp = &pdata->layers[poly_index];
+	cdlp = (poly_index != -1) ? &pdata->layers[poly_index] : NULL;
 	cdlu = &ldata->layers[loop_index];
 	cdlf = fdata && do_tessface ? &fdata->layers[face_index] : NULL;
 
-	if (cdlp->name != new_name) {
+	if (cdlp == NULL && cdlf == NULL) {
+		return false;
+	}
+
+	if (cdlu->name != new_name) {
 		/* Mesh validate passes a name from the CD layer as the new name,
 		 * Avoid memcpy from self to self in this case.
 		 */
-		BLI_strncpy(cdlp->name, new_name, sizeof(cdlp->name));
-		CustomData_set_layer_unique_name(pdata, cdlp - pdata->layers);
+		BLI_strncpy(cdlu->name, new_name, sizeof(cdlu->name));
+		CustomData_set_layer_unique_name(pdata, cdlu - pdata->layers);
 	}
 
 	/* Loop until we do have exactly the same name for all layers! */
-	for (i = 1; !STREQ(cdlp->name, cdlu->name) || (cdlf && !STREQ(cdlp->name, cdlf->name)); i++) {
+	for (i = 1;
+	     (cdlp && !STREQ(cdlp->name, cdlu->name)) ||
+	     (cdlf && !STREQ(cdlp->name, cdlf->name));
+	     i++)
+	{
 		switch (i % step) {
 			case 0:
-				BLI_strncpy(cdlp->name, cdlu->name, sizeof(cdlp->name));
-				CustomData_set_layer_unique_name(pdata, cdlp - pdata->layers);
+				if (cdlp) {
+					BLI_strncpy(cdlp->name, cdlu->name, sizeof(cdlp->name));
+					CustomData_set_layer_unique_name(pdata, cdlp - pdata->layers);
+				}
 				break;
 			case 1:
 				BLI_strncpy(cdlu->name, cdlp->name, sizeof(cdlu->name));
@@ -610,7 +616,7 @@ bool BKE_mesh_uv_cdlayer_rename_index(Mesh *me, const int poly_index, const int
 				break;
 			case 2:
 				if (cdlf) {
-					BLI_strncpy(cdlf->name, cdlp->name, sizeof(cdlf->name));
+					BLI_strncpy(cdlf->name, cdlu->name, sizeof(cdlf->name));
 					CustomData_set_layer_unique_name(fdata, cdlf - fdata->layers);
 				}
 				break;
@@ -622,66 +628,44 @@ bool BKE_mesh_uv_cdlayer_rename_index(Mesh *me, const int poly_index, const int
 
 bool BKE_mesh_uv_cdlayer_rename(Mesh *me, const char *old_name, const char *new_name, bool do_tessface)
 {
-	CustomData *pdata, *ldata, *fdata;
+	CustomData *ldata, *fdata;
 	if (me->edit_btmesh) {
-		pdata = &me->edit_btmesh->bm->pdata;
 		ldata = &me->edit_btmesh->bm->ldata;
 		/* No tessellated data in BMesh! */
 		fdata = NULL;
 		do_tessface = false;
 	}
 	else {
-		pdata = &me->pdata;
 		ldata = &me->ldata;
 		fdata = &me->fdata;
 		do_tessface = (do_tessface && fdata->totlayer);
 	}
 
 	{
-		const int pidx_start = CustomData_get_layer_index(pdata, CD_MTEXPOLY);
 		const int lidx_start = CustomData_get_layer_index(ldata, CD_MLOOPUV);
 		const int fidx_start = do_tessface ? CustomData_get_layer_index(fdata, CD_MTFACE) : -1;
-		int pidx = CustomData_get_named_layer(pdata, CD_MTEXPOLY, old_name);
 		int lidx = CustomData_get_named_layer(ldata, CD_MLOOPUV, old_name);
 		int fidx = do_tessface ? CustomData_get_named_layer(fdata, CD_MTFACE, old_name) : -1;
 
 		/* None of those cases should happen, in theory!
 		 * Note this assume we have the same number of mtexpoly, mloopuv and mtface layers!
 		 */
-		if (pidx == -1) {
-			if (lidx == -1) {
-				if (fidx == -1) {
-					/* No layer found with this name! */
-					return false;
-				}
-				else {
-					lidx = fidx;
-				}
-			}
-			pidx = lidx;
-		}
-		else {
-			if (lidx == -1) {
-				lidx = pidx;
+		if (lidx == -1) {
+			if (fidx == -1) {
+				/* No layer found with this name! */
+				return false;
 			}
-			if (fidx == -1 && do_tessface) {
-				fidx = pidx;
+			else {
+				lidx = fidx;
 			}
 		}
-#if 0
-		/* For now, we do not consider mismatch in indices (i.e. same name leading to (relative) different indices). */
-		else if (pidx != lidx) {
-			lidx = pidx;
-		}
-#endif
 
 		/* Go back to absolute indices! */
-		pidx += pidx_start;
 		lidx += lidx_start;
 		if (fidx != -1)
 			fidx += fidx_start;
 
-		return BKE_mesh_uv_cdlayer_rename_index(me, pidx, lidx, fidx, new_name, do_tessface);
+		return BKE_mesh_uv_cdlayer_rename_index(me, -1, lidx, fidx, new_name, do_tessface);
 	}
 }
 
@@ -1381,7 +1365,6 @@ void BKE_mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, const bool use
 
 		if (alluv) {
 			const char *uvname = "Orco";
-			me->mtpoly = CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DEFAULT, NULL, me->totpoly, uvname);
 			me->mloopuv = CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_ASSIGN, alluv, me->totloop, uvname);
 		}
 
diff --git a/source/blender/blenkernel/intern/mesh_evaluate.c b/source/blender/blenkernel/intern/mesh_evaluate.c
index 127d211e3f1..2c769c3ce03 100644
--- a/source/blender/blenkernel/intern/mesh_evaluate.c
+++ b/source/blender/blenkernel/intern/mesh_evaluate.c
@@ -2166,7 +2166,7 @@ void BKE_mesh_loops_to_mface_corners(
         const int mf_len, /* 3 or 4 */
 
         /* cache values to avoid lookups every time */
-        const int numTex, /* CustomData_number_of_layers(pdata, CD_MTEXPOLY) */
+        const int numUV, /* CustomData_number_of_layers(ldata, CD_MLOOPUV) */
         const int numCol, /* CustomData_number_of_layers(ldata, CD_MLOOPCOL) */
         const bool hasPCol, /* CustomData_has_layer(ldata, CD_PREVIEW_MLOOPCOL) */
         const bool hasOrigSpace, /* CustomData_has_layer(ldata, CD_ORIGSPACE_MLOOP) */
@@ -2179,7 +2179,7 @@ void BKE_mesh_loops_to_mface_corners(
 	MLoopUV *mloopuv;
 	int i, j;
 
-	for (i = 0; i < numTex; i++) {
+	for (i = 0; i < numUV; i++) {
 		texface = CustomData_get_n(fdata, CD_MTFACE, findex, i);
 
 		for (j = 0; j < mf_len; j++) {
@@ -2232,14 +2232,14 @@ void BKE_mesh_loops_to_mface_corners(
  *
  * \note when mface is not NULL, mface[face_index].v4 is used to test quads, else, loopindices[face_index][3] is used.
  */
-void BKE_mesh_loops_to_tessdata(CustomData *fdata, CustomData *ldata, CustomData *pdata, MFace *mface,
+void BKE_mesh_loops_to_tessdata(CustomData *fdata, CustomData *ldata, MFace *mface,
                                 int *polyindices, unsigned int (*loopindices)[4], const int num_faces)
 {
 	/* Note: performances are sub-optimal when we get a NULL mface, we could be ~25% quicker with dedicated code...
 	 *       Issue is, unless having two different functions with nearly the same code, there's not much ways to solve
 	 *       this. Better imho to live with it for now. :/ --mont29
 	 */
-	const int numTex = CustomData_number_of_layers(pdata, CD_MTEXPOLY);
+	const int numUV = CustomData_number_of_layers(ldata, CD_MLOOPUV);
 	const int numCol = CustomData_number_of_layers(ldata, CD_MLOOPCOL);
 	const bool hasPCol = CustomData_has_layer(ldata, CD_PREVIEW_MLOOPCOL);
 	const bool hasOrigSpace = CustomData_has_layer(ldata, CD_ORIGSPACE_MLOOP);
@@ -2249,7 +2249,7 @@ void BKE_mesh_loops_to_tessdata(CustomData *fdata, CustomData *ldata, CustomData
 	const int *pidx;
 	unsigned int (*lidx)[4];
 
-	for (i = 0; i < numTex; i++) {
+	for (i = 0; i < numUV; i++) {
 		MTFace *texface = CustomData_get_layer_n(fdata, CD_MTFACE, i);
 		MLoopUV *mloopuv = CustomData_get_layer_n(ldata, CD_MLOOPUV, i);
 
@@ -2579,7 +2579,7 @@ int BKE_mesh_recalc_tessellation(
 	/* CD_ORIGINDEX will contain an array of indices from tessfaces to the polygons
 	 * they are directly tessellated from */
 	CustomData_add_layer(fdata, CD_ORIGINDEX, CD_ASSIGN, mface_to_poly_map, totface);
-	CustomData_from_bmeshpoly(fdata, pdata, ldata, totface);
+	CustomData_from_bmeshpoly(fdata, ldata, totface);
 
 	if (do_face_nor_copy) {
 		/* If polys have a normals layer, copying that to faces can help
@@ -2600,7 +2600,7 @@ int BKE_mesh_recalc_tessellation(
 	 * So we pass NULL as MFace pointer, and BKE_mesh_loops_to_tessdata will use the fourth loop index as quad test.
 	 * ...
 	 */
-	BKE_mesh_loops_to_tessdata(fdata, ldata, pdata, NULL, mface_to_poly_map, lindices, totface);
+	BKE_mesh_loops_to_tessdata(fdata, ldata, NULL, mface_to_poly_map, lindices, totface);
 
 	/* NOTE: quad detection issue - fourth vertidx vs fourth loopidx:
 	 * ...However, most TFace code uses 'MFace->v4 == 0' test to check whether it is a tri or quad.
@@ -2779,7 +2779,7 @@ int BKE_mesh_mpoly_to_mface(struct CustomData *fdata, struct CustomData *ldata,
 	MPoly *mp, *mpoly;
 	MFace *mface, *mf;
 
-	const int numTex = CustomData_number_of_layers(pdata, CD_MTEXPOLY);
+	const int numUV = CustomData_number_of_layers(ldata, CD_MLOOPUV);
 	const int numCol = CustomData_number_of_layers(ldata, CD_MLOOPCOL);
 	const bool hasPCol = CustomData_has_layer(ldata, CD_PREVIEW_MLOOPCOL);
 	const bool hasOrigSpace = CustomData_has_layer(ldata, CD_ORIGSPACE_MLOOP);
@@ -2819,7 +2819,7 @@ int BKE_mesh_mpoly_to_mface(struct CustomData *fdata, struct CustomData *ldata,
 
 	CustomData_add_layer(fdata, CD_MFACE, CD_ASSIGN, mface, totface);
 
-	CustomData_from_bmeshpoly(fdata, pdata, ldata, totface);
+	CustomData_from_bmeshpoly(fdata, ldata, totface);
 
 	mp = mpoly;
 	k = 0;
@@ -2841,9 +2841,10 @@ int BKE_mesh_mpoly_to_mface(struct CustomData *fdata, struct CustomData *ldata,
 				mf->v2 = mloop[mf->v2].v;
 				mf->v3 = mloop[mf->v3].v;
 
-				BKE_mesh_loops_to_mface_corners(fdata, ldata, pdata,
-				                                lindex, k, i, 3,
-				                                numTex, numCol, hasPCol, hasOrigSpace, hasLNor);
+				BKE_mesh_loops_to_mface_corners(
+				        fdata, ldata, pdata,
+				        lindex, k, i, 3,
+				        numUV, numCol, hasPCol, hasOrigSpace, hasLNor);
 				test_index_face(mf, fdata, k, 3);
 			}
 			else {
@@ -2861,9 +2862,10 @@ int BKE_mesh_mpoly_to_mface(struct CustomData *fdata, struct CustomData *ldata,
 				mf->v3 = mloop[mf->v3].v;
 				mf->v4 = mloop[mf->v4].v;
 
-				BKE_mesh_loops_to_mface_corners(fdata, ldata, pdata,
-				                                lindex, k, i, 4,
-				                                numTex, numCol, hasPCol, hasOrigSpace, hasLNor);
+				BKE_mesh_loops_to_mface_corners(
+				        fdata, ldata, pdata,
+				        lindex, k, i, 4,
+				        numUV, numCol, hasPCol, hasOrigSpace, hasLNor);
 				test_index_face(mf, fdata, k, 4);
 			}
 
@@ -3000,7 +3002,7 @@ void BKE_mesh_do_versions_convert_mfaces_to_mpolys(Mesh *mesh)
 	                                     mesh->medge, mesh->mface,
 	                                     &mesh->totloop, &mesh->totpoly, &mesh->mloop, &mesh->mpoly);
 
-	CustomData_bmesh_do_versions_update_active_layers(&mesh->fdata, &mesh->pdata, &mesh->ldata);
+	CustomData_bmesh_do_versions_update_active_layers(&mesh->fdata, &mesh->ldata);
 
 	BKE_mesh_update_customdata_pointers(mesh, true);
 }
@@ -3043,7 +3045,7 @@ void BKE_mesh_convert_mfaces_to_mpolys_ex(ID *id, CustomData *fdata, CustomData
 
 	CustomData_add_layer(ldata, CD_MLOOP, CD_ASSIGN, mloop, totloop);
 
-	CustomData_to_bmeshpoly(fdata, pdata, ldata, totloop, totpoly);
+	CustomData_to_bmeshpoly(fdata, ldata, totloop);
 
 	if (id) {
 		/* ensure external data is transferred */
diff --git a/source/blender/blenkernel/intern/mesh_validate.c b/source/blender/blenkernel/intern/mesh_validate.c
index 18474946df0..215d2015d07 100644
--- a/source/blender/blenkernel/intern/mesh_validate.c
+++ b/source/blender/blenkernel/intern/mesh_validate.c
@@ -937,7 +937,7 @@ bool BKE_mesh_validate_all_customdata(CustomData *vdata, CustomData *edata,
 {
 	bool is_valid = true;
 	bool is_change_v, is_change_e, is_change_l, is_change_p;
-	int tot_texpoly, tot_uvloop, tot_vcolloop;
+	int tot_uvloop, tot_vcolloop;
 	CustomDataMask mask = check_meshmask ? CD_MASK_MESH : 0;
 
 	is_valid &= mesh_validate_customdata(vdata, mask, do_verbose, do_fixes, &is_change_v);
@@ -945,17 +945,8 @@ bool BKE_mesh_validate_all_customdata(CustomData *vdata, CustomData *edata,
 	is_valid &= mesh_validate_customdata(ldata, mask, do_verbose, do_fixes, &is_change_l);
 	is_valid &= mesh_validate_customdata(pdata, mask, do_verbose, do_fixes, &is_change_p);
 
-	tot_texpoly = CustomData_number_of_layers(pdata, CD_MTEXPOLY);
 	tot_uvloop = CustomData_number_of_layers(ldata, CD_MLOOPUV);
 	tot_vcolloop = CustomData_number_of_layers(ldata, CD_MLOOPCOL);
-	if (tot_texpoly != tot_uvloop) {
-		PRINT_ERR("\tCustomDataLayer mismatch, tot_texpoly(%d), tot_uvloop(%d)\n",
-		          tot_texpoly, tot_uvloop);
-	}
-	if (tot_texpoly > MAX_MTFACE) {
-		PRINT_ERR("\tMore UV layers than %d allowed, %d last ones won't be available for render, shaders, etc.\n",
-		          MAX_MTFACE, tot_texpoly - MAX_MTFACE);
-	}
 	if (tot_uvloop > MAX_MTFACE) {
 		PRINT_ERR("\tMore UV layers than %d allowed, %d last ones won't be available for render, shaders, etc.\n",
 		          MAX_MTFACE, tot_uvloop - MAX_MTFACE);
@@ -966,18 +957,10 @@ bool BKE_mesh_validate_all_customdata(CustomData *vdata, CustomData *edata,
 	}
 
 	/* check indices of clone/stencil */
-	if (do_fixes && CustomData_get_clone_layer(pdata, CD_MTEXPOLY) >= tot_texpoly) {
-		CustomData_set_layer_clone(pdata, CD_MTEXPOLY, 0);
-		is_change_p = true;
-	}
 	if (do_fixes && CustomData_get_clone_layer(ldata, CD_MLOOPUV) >= tot_uvloop) {
 		CustomData_set_layer_clone(ldata, CD_MLOOPUV, 0);
 		is_change_l = true;
 	}
-	if (do_fixes && CustomData_get_stencil_layer(pdata, CD_MTEXPOLY) >= tot_texpoly) {
-		CustomData_set_layer_stencil(pdata, CD_MTEXPOLY, 0);
-		is_change_p = true;
-	}
 	if (do_fixes && CustomData_get_stencil_layer(ldata, CD_MLOOPUV) >= tot_uvloop) {
 		CustomData_set_layer_stencil(ldata, CD_MLOOPUV, 0);
 		is_change_l = true;
@@ -1029,64 +1012,6 @@ int BKE_mesh_validate(Mesh *me, const int do_verbose, const int cddata_check_mas
 }
 
 /**
- * Duplicate of BM_mesh_cd_validate() for Mesh data.
- */
-void BKE_mesh_cd_validate(Mesh *me)
-{
-	int totlayer_mtex = CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY);
-	int totlayer_uv = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
-	int totlayer_mcol = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
-	int mtex_index = CustomData_get_layer_index(&me->pdata, CD_MTEXPOLY);
-	int uv_index = CustomData_get_layer_index(&me->ldata, CD_MLOOPUV);
-	int i;
-
-	/* XXX For now, do not delete those, just warn they are not really usable. */
-	if (UNLIKELY(totlayer_mtex > MAX_MTFACE)) {
-		printf("WARNING! More UV layers than %d allowed, %d last ones won't be available for render, shaders, etc.\n",
-		       MAX_MTFACE, totlayer_mtex - MAX_MTFACE);
-	}
-	if (UNLIKELY(totlayer_uv > MAX_MTFACE)) {
-		printf("WARNING! More UV layers than %d allowed, %d last ones won't be available for render, shaders, etc.\n",
-		       MAX_MTFACE, totlayer_uv - MAX_MTFACE);
-	}
-	if (UNLIKELY(totlayer_mcol > MAX_MCOL)) {
-		printf("WARNING! More VCol layers than %d allowed, %d last ones won't be available for render, shaders, etc.\n",
-		       MAX_MCOL, totlayer_mcol - MAX_MCOL);
-	}
-
-	if (LIKELY(totlayer_mtex == totlayer_uv)) {
-		/* pass */
-	}
-	else if (totlayer_mtex < totlayer_uv) {
-		do {
-			const char *from_name =  me->ldata.layers[uv_index + totlayer_mtex].name;
-			CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DEFAULT, NULL, me->totpoly, from_name);
-			CustomData_set_layer_unique_name(&me->pdata, totlayer_mtex);
-		} while (totlayer_uv != ++totlayer_mtex);
-		mtex_index = CustomData_get_layer_index(&me->pdata, CD_MTEXPOLY);
-	}
-	else if (totlayer_uv < totlayer_mtex) {
-		do {
-			const char *from_name = me->pdata.layers[mtex_index + totlayer_uv].name;
-			CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DEFAULT, NULL, me->totloop, from_name);
-			CustomData_set_layer_unique_name(&me->ldata, totlayer_uv);
-		} while (totlayer_mtex != ++totlayer_uv);
-		uv_index = CustomData_get_layer_index(&me->ldata, CD_MLOOPUV);
-	}
-
-	BLI_assert(totlayer_mtex == totlayer_uv);
-
-	/* Check uv/tex names match as well!!! */
-	for (i = 0; i < totlayer_mtex; i++, mtex_index++, uv_index++) {
-		const char *name_src = me->pdata.layers[mtex_index].name;
-		const char *name_dst = me->ldata.layers[uv_index].name;
-		if (!STREQ(name_src, name_dst)) {
-			BKE_mesh_uv_cdlayer_rename_index(me, mtex_index, uv_index, -1, name_src, false);
-		}
-	}
-}
-
-/**
  * Check all material indices of polygons are valid, invalid ones are set to 0.
  * \returns is_valid.
  */