Merged changes in the trunk up to revision 53729.

Conflicts resolved:
release/datafiles/startup.blend
source/blender/blenloader/intern/readfile.c

25 files changed, 470 insertions, 313 deletions

diff --git a/source/blender/blenkernel/BKE_DerivedMesh.h b/source/blender/blenkernel/BKE_DerivedMesh.h
index ed90c63d949..f06547fe2e3 100644
--- a/source/blender/blenkernel/BKE_DerivedMesh.h
+++ b/source/blender/blenkernel/BKE_DerivedMesh.h
@@ -173,6 +173,9 @@ struct DerivedMesh {
 	float auto_bump_scale;
 	DMDirtyFlag dirty;
 
+	/* use for converting to BMesh which doesn't store bevel weight and edge crease by default */
+	char cd_flag;
+
 	/** Calculate vert and face normals */
 	void (*calcNormals)(DerivedMesh *dm);
 
diff --git a/source/blender/blenkernel/BKE_blender.h b/source/blender/blenkernel/BKE_blender.h
index 10528f1b270..9c6d26c08bc 100644
--- a/source/blender/blenkernel/BKE_blender.h
+++ b/source/blender/blenkernel/BKE_blender.h
@@ -42,7 +42,7 @@ extern "C" {
  * and keep comment above the defines.
  * Use STRINGIFY() rather than defining with quotes */
 #define BLENDER_VERSION         265
-#define BLENDER_SUBVERSION      5
+#define BLENDER_SUBVERSION      8
 
 /* 262 was the last editmesh release but it has compatibility code for bmesh data */
 #define BLENDER_MINVERSION      262
diff --git a/source/blender/blenkernel/BKE_cdderivedmesh.h b/source/blender/blenkernel/BKE_cdderivedmesh.h
index 2b2497f3f50..af5e925987d 100644
--- a/source/blender/blenkernel/BKE_cdderivedmesh.h
+++ b/source/blender/blenkernel/BKE_cdderivedmesh.h
@@ -63,14 +63,12 @@ DerivedMesh *CDDM_from_editbmesh(struct BMEditMesh *em, int use_mdisps, int use_
 /* merge verts  */
 DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap);
 
-DerivedMesh *CDDM_from_curve_orco(struct Scene *scene, struct Object *ob);
-
 /* creates a CDDerivedMesh from the given curve object */
 struct DerivedMesh *CDDM_from_curve(struct Object *ob);
 
 /* creates a CDDerivedMesh from the given curve object and specified dispbase */
 /* useful for OrcoDM creation for curves with constructive modifiers */
-DerivedMesh *CDDM_from_curve_displist(struct Object *ob, struct ListBase *dispbase, int **orco_index_ptr);
+DerivedMesh *CDDM_from_curve_displist(struct Object *ob, struct ListBase *dispbase);
 
 /* Copies the given DerivedMesh with verts, faces & edges stored as
  * custom element data.
diff --git a/source/blender/blenkernel/BKE_customdata.h b/source/blender/blenkernel/BKE_customdata.h
index 4736e7b7312..36733d1ced0 100644
--- a/source/blender/blenkernel/BKE_customdata.h
+++ b/source/blender/blenkernel/BKE_customdata.h
@@ -39,6 +39,7 @@ extern "C" {
 #endif
 
 #include "../blenloader/BLO_sys_types.h" /* XXX, should have a more generic include for this */
+#include "BLI_utildefines.h"
 
 struct BMesh;
 struct ID;
@@ -215,6 +216,8 @@ void CustomData_free_elem(struct CustomData *data, int index, int count);
 void CustomData_interp(const struct CustomData *source, struct CustomData *dest,
                        int *src_indices, float *weights, float *sub_weights,
                        int count, int dest_index);
+void CustomData_bmesh_interp_n(struct CustomData *data, void **src_blocks, const float *weights,
+                               const float *sub_weights, int count, void *dest_block, int n);
 void CustomData_bmesh_interp(struct CustomData *data, void **src_blocks,
                              const float *weights, const float *sub_weights, int count,
                              void *dest_block);
@@ -246,6 +249,8 @@ void *CustomData_get_layer(const struct CustomData *data, int type);
 void *CustomData_get_layer_n(const struct CustomData *data, int type, int n);
 void *CustomData_get_layer_named(const struct CustomData *data, int type,
                                  const char *name);
+int CustomData_get_offset(const struct CustomData *data, int type);
+int CustomData_get_n_offset(const struct CustomData *data, int type, int n);
 
 int CustomData_get_layer_index(const struct CustomData *data, int type);
 int CustomData_get_layer_index_n(const struct CustomData *data, int type, int n);
@@ -304,7 +309,7 @@ void CustomData_bmesh_free_block(struct CustomData *data, void **block);
 /* copy custom data to/from layers as in mesh/derivedmesh, to editmesh
  * blocks of data. the CustomData's must not be compatible */
 void CustomData_to_bmesh_block(const struct CustomData *source, 
-                               struct CustomData *dest, int src_index, void **dest_block);
+                               struct CustomData *dest, int src_index, void **dest_block, bool use_default_init);
 void CustomData_from_bmesh_block(const struct CustomData *source, 
                                  struct CustomData *dest, void *src_block, int dest_index);
 
diff --git a/source/blender/blenkernel/BKE_main.h b/source/blender/blenkernel/BKE_main.h
index ec465502ca0..be42ee524de 100644
--- a/source/blender/blenkernel/BKE_main.h
+++ b/source/blender/blenkernel/BKE_main.h
@@ -96,7 +96,7 @@ typedef struct Main {
 } Main;
 
 #define MAIN_VERSION_ATLEAST(main, ver, subver) \
-	((main)->versionfile >= (ver) || (main->versionfile == (ver) && (main)->subversionfile >= (subver)))
+	((main)->versionfile > (ver) || (main->versionfile == (ver) && (main)->subversionfile >= (subver)))
 
 #ifdef __cplusplus
 }
diff --git a/source/blender/blenkernel/BKE_mesh.h b/source/blender/blenkernel/BKE_mesh.h
index db9f1228f76..3466a914bce 100644
--- a/source/blender/blenkernel/BKE_mesh.h
+++ b/source/blender/blenkernel/BKE_mesh.h
@@ -154,13 +154,9 @@ int  BKE_mesh_nurbs_to_mdata(struct Object *ob, struct MVert **allvert, int *tot
                              int *totloop, int *totpoly);
 int BKE_mesh_nurbs_displist_to_mdata(struct Object *ob, struct ListBase *dispbase, struct MVert **allvert, int *_totvert,
                                      struct MEdge **alledge, int *_totedge, struct MLoop **allloop, struct MPoly **allpoly,
-                                     int *_totloop, int *_totpoly, int **orco_index_ptr);
-void BKE_mesh_nurbs_to_mdata_orco(struct MPoly *mpoly, int totpoly,
-                                  struct MLoop *mloops, struct MLoopUV *mloopuvs,
-                                  float (*orco)[3], int (*orco_index)[4]);
+                                     struct MLoopUV **alluv, int *_totloop, int *_totpoly);
+void BKE_mesh_from_nurbs_displist(struct Object *ob, struct ListBase *dispbase, int use_orco_uv);
 void BKE_mesh_from_nurbs(struct Object *ob);
-void BKE_mesh_from_nurbs_displist(struct Object *ob, struct ListBase *dispbase,
-                                  int **orco_index_ptr);
 void BKE_mesh_from_curve(struct Scene *scene, struct Object *ob);
 void BKE_mesh_delete_material_index(struct Mesh *me, short index);
 void BKE_mesh_smooth_flag_set(struct Object *meshOb, int enableSmooth);
@@ -334,6 +330,8 @@ void BKE_mesh_loops_to_mface_corners(struct CustomData *fdata, struct CustomData
 void BKE_mesh_poly_calc_angles(struct MVert *mvert, struct MLoop *mloop,
                                struct MPoly *mp, float angles[]);
 
+void BKE_mesh_do_versions_cd_flag_init(struct Mesh *mesh);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/blenkernel/BKE_report.h b/source/blender/blenkernel/BKE_report.h
index 4d69a013101..e659954a3ac 100644
--- a/source/blender/blenkernel/BKE_report.h
+++ b/source/blender/blenkernel/BKE_report.h
@@ -35,6 +35,7 @@ extern "C" {
 #endif
 
 #include "DNA_windowmanager_types.h"
+#include "BLI_utildefines.h"
 
 /* Reporting Information and Errors
  *
@@ -72,7 +73,10 @@ void BKE_reports_print(ReportList *reports, ReportType level);
 Report *BKE_reports_last_displayable(ReportList *reports);
 
 int BKE_reports_contain(ReportList *reports, ReportType level);
-	
+
+bool BKE_report_write_file_fp(FILE *fp, ReportList *reports, const char *header);
+bool BKE_report_write_file(const char *filepath, ReportList *reports, const char *header);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index ec8d37e1ae3..dde1d5870ca 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -313,6 +313,8 @@ void DM_from_template(DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type
 	CustomData_copy(&source->polyData, &dm->polyData, CD_MASK_DERIVEDMESH,
 	                CD_CALLOC, numPolys);
 
+	dm->cd_flag = source->cd_flag;
+
 	dm->type = type;
 	dm->numVertData = numVerts;
 	dm->numEdgeData = numEdges;
@@ -483,11 +485,13 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob)
 	totedge = tmp.totedge = dm->getNumEdges(dm);
 	totloop = tmp.totloop = dm->getNumLoops(dm);
 	totpoly = tmp.totpoly = dm->getNumPolys(dm);
+	tmp.totface = 0;
 
 	CustomData_copy(&dm->vertData, &tmp.vdata, CD_MASK_MESH, CD_DUPLICATE, totvert);
 	CustomData_copy(&dm->edgeData, &tmp.edata, CD_MASK_MESH, CD_DUPLICATE, totedge);
 	CustomData_copy(&dm->loopData, &tmp.ldata, CD_MASK_MESH, CD_DUPLICATE, totloop);
 	CustomData_copy(&dm->polyData, &tmp.pdata, CD_MASK_MESH, CD_DUPLICATE, totpoly);
+	me->cd_flag = dm->cd_flag;
 
 	if (CustomData_has_layer(&dm->vertData, CD_SHAPEKEY)) {
 		KeyBlock *kb;
@@ -538,9 +542,10 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob)
 	}
 
 	/* yes, must be before _and_ after tessellate */
-	mesh_update_customdata_pointers(&tmp, TRUE);
+	mesh_update_customdata_pointers(&tmp, false);
 
-	BKE_mesh_tessface_calc(&tmp);
+	/* since 2.65 caller must do! */
+	// BKE_mesh_tessface_calc(&tmp);
 
 	CustomData_free(&me->vdata, me->totvert);
 	CustomData_free(&me->edata, me->totedge);
diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c
index 51890851ebc..85dd4c67fdf 100644
--- a/source/blender/blenkernel/intern/cdderivedmesh.c
+++ b/source/blender/blenkernel/intern/cdderivedmesh.c
@@ -647,6 +647,23 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm,
 		index_mp_to_orig = NULL;
 	}
 
+	/* TODO: not entirely correct, but currently dynamic topology will
+	 *       destroy UVs anyway, so textured display wouldn't work anyway
+	 *
+	 *       this will do more like solid view with lights set up for
+	 *       textured view, but object itself will be displayed gray
+	 *       (the same as it'll display without UV maps in textured view)
+	 */
+	if (cddm->pbvh && cddm->pbvh_draw && BKE_pbvh_type(cddm->pbvh) == PBVH_BMESH) {
+		if (dm->numTessFaceData) {
+			glDisable(GL_TEXTURE_2D);
+			BKE_pbvh_draw(cddm->pbvh, NULL, NULL, NULL, FALSE);
+			glEnable(GL_TEXTURE_2D);
+		}
+
+		return;
+	}
+
 	colType = CD_TEXTURE_MCOL;
 	mcol = dm->getTessFaceDataArray(dm, colType);
 	if (!mcol) {
@@ -1726,6 +1743,7 @@ DerivedMesh *CDDM_from_mesh(Mesh *mesh, Object *UNUSED(ob))
 	        mesh->totloop, mesh->totpoly);
 
 	dm->deformedOnly = 1;
+	dm->cd_flag = mesh->cd_flag;
 
 	alloctype = CD_REFERENCE;
 
@@ -1757,49 +1775,10 @@ DerivedMesh *CDDM_from_mesh(Mesh *mesh, Object *UNUSED(ob))
 
 DerivedMesh *CDDM_from_curve(Object *ob)
 {
-	return CDDM_from_curve_displist(ob, &ob->disp, NULL);
+	return CDDM_from_curve_displist(ob, &ob->disp);
 }
 
-DerivedMesh *CDDM_from_curve_orco(struct Scene *scene, Object *ob)
-{
-	int *orco_index_ptr = NULL;
-	int (*orco_index)[4] = NULL;
-	float (*orco)[3] = NULL;
-	DerivedMesh *dm = CDDM_from_curve_displist(ob, &ob->disp, &orco_index_ptr);
-
-	if (orco_index_ptr) {
-		orco = (float (*)[3])BKE_curve_make_orco(scene, ob);
-	}
-
-	if (orco && orco_index_ptr) {
-		const char *uvname = "Orco";
-
-		int totpoly = dm->getNumPolys(dm);
-
-		MPoly *mpolys = dm->getPolyArray(dm);
-		MLoop *mloops = dm->getLoopArray(dm);
-
-		MLoopUV *mloopuvs;
-
-		CustomData_add_layer_named(&dm->polyData, CD_MTEXPOLY, CD_DEFAULT, NULL, dm->numPolyData, uvname);
-		mloopuvs = CustomData_add_layer_named(&dm->loopData, CD_MLOOPUV,  CD_DEFAULT, NULL, dm->numLoopData, uvname);
-
-		BKE_mesh_nurbs_to_mdata_orco(mpolys, totpoly,
-		                             mloops, mloopuvs,
-		                             orco, orco_index);
-	}
-
-	if (orco_index) {
-		MEM_freeN(orco_index);
-	}
-	if (orco) {
-		MEM_freeN(orco);
-	}
-
-	return dm;
-}
-
-DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase, int **orco_index_ptr)
+DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase)
 {
 	DerivedMesh *dm;
 	CDDerivedMesh *cddm;
@@ -1810,7 +1789,8 @@ DerivedMesh *CDDM_from_curve_displist(Object *ob, ListBase *dispbase, int **orco
 	int totvert, totedge, totloop, totpoly;
 
 	if (BKE_mesh_nurbs_displist_to_mdata(ob, dispbase, &allvert, &totvert, &alledge,
-	                                     &totedge, &allloop, &allpoly, &totloop, &totpoly, orco_index_ptr) != 0)
+	                                     &totedge, &allloop, &allpoly, NULL,
+	                                     &totloop, &totpoly) != 0)
 	{
 		/* Error initializing mdata. This often happens when curve is empty */
 		return CDDM_new(0, 0, 0, 0, 0);
@@ -1909,13 +1889,12 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm, int use_mdisps,
 	int numCol = CustomData_number_of_layers(&bm->ldata, CD_MLOOPCOL);
 	int numTex = CustomData_number_of_layers(&bm->pdata, CD_MTEXPOLY);
 	int *index, add_orig;
-	int has_crease, has_edge_bweight, has_vert_bweight;
 	CustomDataMask mask;
 	unsigned int i, j;
 	
-	has_edge_bweight = CustomData_has_layer(&bm->edata, CD_BWEIGHT);
-	has_vert_bweight = CustomData_has_layer(&bm->vdata, CD_BWEIGHT);
-	has_crease = CustomData_has_layer(&bm->edata, CD_CREASE);
+	const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
+	const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
+	const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
 	
 	dm->deformedOnly = 1;
 	
@@ -1955,8 +1934,7 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm, int use_mdisps,
 
 		mv->flag = BM_vert_flag_to_mflag(eve);
 
-		if (has_vert_bweight)
-			mv->bweight = (unsigned char)(BM_elem_float_data_get(&bm->vdata, eve, CD_BWEIGHT) * 255.0f);
+		if (cd_vert_bweight_offset != -1) mv->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
 
 		if (add_orig) *index = i;
 
@@ -1974,11 +1952,6 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm, int use_mdisps,
 		med->v1 = BM_elem_index_get(eed->v1);
 		med->v2 = BM_elem_index_get(eed->v2);
 
-		if (has_crease)
-			med->crease = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_CREASE) * 255.0f);
-		if (has_edge_bweight)
-			med->bweight = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_BWEIGHT) * 255.0f);
-		
 		med->flag = BM_edge_flag_to_mflag(eed);
 
 		/* handle this differently to editmode switching,
@@ -1989,6 +1962,9 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm, int use_mdisps,
 			}
 		}
 
+		if (cd_edge_crease_offset  != -1) med->crease  = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_crease_offset);
+		if (cd_edge_bweight_offset != -1) med->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_bweight_offset);
+
 		CustomData_from_bmesh_block(&bm->edata, &dm->edgeData, eed->head.data, i);
 		if (add_orig) *index = i;
 	}
@@ -2051,6 +2027,8 @@ static DerivedMesh *cddm_from_bmesh_ex(struct BMesh *bm, int use_mdisps,
 	}
 	bm->elem_index_dirty &= ~BM_FACE;
 
+	dm->cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
+
 	return dm;
 }
 
@@ -2088,6 +2066,7 @@ static DerivedMesh *cddm_copy_ex(DerivedMesh *source, int faces_from_tessfaces)
 	DM_from_template(dm, source, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces,
 	                 numLoops, numPolys);
 	dm->deformedOnly = source->deformedOnly;
+	dm->cd_flag = source->cd_flag;
 	dm->dirty = source->dirty;
 
 	CustomData_copy_data(&source->vertData, &dm->vertData, 0, 0, numVerts);
diff --git a/source/blender/blenkernel/intern/curve.c b/source/blender/blenkernel/intern/curve.c
index 1d199cdf1e2..fe8bd0cc5a4 100644
--- a/source/blender/blenkernel/intern/curve.c
+++ b/source/blender/blenkernel/intern/curve.c
@@ -875,7 +875,7 @@ static void basisNurb(float t, short order, short pnts, float *knots, float *bas
 
 
 void BKE_nurb_makeFaces(Nurb *nu, float *coord_array, int rowstride, int resolu, int resolv)
-/* coord_array  has to be 3*4*resolu*resolv in size, and zero-ed */
+/* coord_array  has to be (3 * 4 * resolu * resolv) in size, and zero-ed */
 {
 	BPoint *bp;
 	float *basisu, *basis, *basisv, *sum, *fp, *in;
diff --git a/source/blender/blenkernel/intern/customdata.c b/source/blender/blenkernel/intern/customdata.c
index 0f352dede23..f3548f776f5 100644
--- a/source/blender/blenkernel/intern/customdata.c
+++ b/source/blender/blenkernel/intern/customdata.c
@@ -2095,6 +2095,23 @@ void *CustomData_get_layer_named(const struct CustomData *data, int type,
 	return data->layers[layer_index].data;
 }
 
+int CustomData_get_offset(const CustomData *data, int type)
+{
+	/* get the layer index of the active layer of type */
+	int layer_index = CustomData_get_active_layer_index(data, type);
+	if (layer_index < 0) return -1;
+
+	return data->layers[layer_index].offset;
+}
+
+int CustomData_get_n_offset(const CustomData *data, int type, int n)
+{
+	/* get the layer index of the active layer of type */
+	int layer_index = CustomData_get_layer_index_n(data, type, n);
+	if (layer_index < 0) return -1;
+
+	return data->layers[layer_index].offset;
+}
 
 int CustomData_set_layer_name(const CustomData *data, int type, int n, const char *name)
 {
@@ -2298,34 +2315,46 @@ void CustomData_bmesh_merge(CustomData *source, CustomData *dest,
 	BMIter iter;
 	CustomData destold;
 	void *tmp;
-	int t;
+	int iter_type;
+	int totelem;
 
 	/* copy old layer description so that old data can be copied into
 	 * the new allocation */
 	destold = *dest;
-	if (destold.layers) destold.layers = MEM_dupallocN(destold.layers);
-	
-	CustomData_merge(source, dest, mask, alloctype, 0);
-	dest->pool = NULL;
-	CustomData_bmesh_init_pool(dest, 512, htype);
+	if (destold.layers) {
+		destold.layers = MEM_dupallocN(destold.layers);
+	}
 
 	switch (htype) {
 		case BM_VERT:
-			t = BM_VERTS_OF_MESH; break;
+			iter_type = BM_VERTS_OF_MESH;
+			totelem = bm->totvert;
+			break;
 		case BM_EDGE:
-			t = BM_EDGES_OF_MESH; break;
+			iter_type = BM_EDGES_OF_MESH;
+			totelem = bm->totedge;
+			break;
 		case BM_LOOP:
-			t = BM_LOOPS_OF_FACE; break;
+			iter_type = BM_LOOPS_OF_FACE;
+			totelem = bm->totloop;
+			break;
 		case BM_FACE:
-			t = BM_FACES_OF_MESH; break;
+			iter_type = BM_FACES_OF_MESH;
+			totelem = bm->totface;
+			break;
 		default: /* should never happen */
 			BLI_assert(!"invalid type given");
-			t = BM_VERTS_OF_MESH;
+			iter_type = BM_VERTS_OF_MESH;
+			totelem = bm->totvert;
 	}
 
-	if (t != BM_LOOPS_OF_FACE) {
+	CustomData_merge(source, dest, mask, alloctype, 0);
+	dest->pool = NULL;
+	CustomData_bmesh_init_pool(dest, totelem, htype);
+
+	if (iter_type != BM_LOOPS_OF_FACE) {
 		/*ensure all current elements follow new customdata layout*/
-		BM_ITER_MESH (h, &iter, bm, t) {
+		BM_ITER_MESH (h, &iter, bm, iter_type) {
 			tmp = NULL;
 			CustomData_bmesh_copy_data(&destold, dest, h->data, &tmp);
 			CustomData_bmesh_free_block(&destold, &h->data);
@@ -2618,6 +2647,19 @@ void CustomData_bmesh_set_layer_n(CustomData *data, void *block, int n, void *so
 		memcpy(dest, source, typeInfo->size);
 }
 
+/**
+ * \param src_blocks must be pointers to the data, offset by layer->offset already.
+ */
+void CustomData_bmesh_interp_n(CustomData *data, void **src_blocks, const float *weights,
+                               const float *sub_weights, int count, void *dest_block, int n)
+{
+	CustomDataLayer *layer = &data->layers[n];
+	const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
+
+	typeInfo->interp(src_blocks, weights, sub_weights, count,
+	                 (char *)dest_block + layer->offset);
+}
+
 void CustomData_bmesh_interp(CustomData *data, void **src_blocks, const float *weights,
                              const float *sub_weights, int count, void *dest_block)
 {
@@ -2640,36 +2682,47 @@ void CustomData_bmesh_interp(CustomData *data, void **src_blocks, const float *w
 			for (j = 0; j < count; ++j) {
 				sources[j] = (char *)src_blocks[j] + layer->offset;
 			}
-
-			typeInfo->interp(sources, weights, sub_weights, count,
-			                 (char *)dest_block + layer->offset);
+			CustomData_bmesh_interp_n(data, sources, weights, sub_weights, count, dest_block, i);
 		}
 	}
 
 	if (count > SOURCE_BUF_SIZE) MEM_freeN(sources);
 }
 
-void CustomData_bmesh_set_default(CustomData *data, void **block)
+static void CustomData_bmesh_set_default_n(CustomData *data, void **block, int n)
 {
 	const LayerTypeInfo *typeInfo;
+	int offset = data->layers[n].offset;
+
+	typeInfo = layerType_getInfo(data->layers[n].type);
+
+	if (typeInfo->set_default) {
+		typeInfo->set_default((char *)*block + offset, 1);
+	}
+	else {
+		memset((char *)*block + offset, 0, typeInfo->size);
+	}
+}
+
+void CustomData_bmesh_set_default(CustomData *data, void **block)
+{
 	int i;
 
 	if (*block == NULL)
 		CustomData_bmesh_alloc_block(data, block);
 
 	for (i = 0; i < data->totlayer; ++i) {
-		int offset = data->layers[i].offset;
-
-		typeInfo = layerType_getInfo(data->layers[i].type);
-
-		if (typeInfo->set_default)
-			typeInfo->set_default((char *)*block + offset, 1);
-		else memset((char *)*block + offset, 0, typeInfo->size);
+		CustomData_bmesh_set_default_n(data, block, i);
 	}
 }
 
+/**
+ * \param use_default_init initializes data which can't be copied,
+ * typically you'll want to use this if the BM_xxx create function
+ * is called with BM_CREATE_SKIP_CD flag
+ */
 void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
-                               int src_index, void **dest_block)
+                               int src_index, void **dest_block, bool use_default_init)
 {
 	const LayerTypeInfo *typeInfo;
 	int dest_i, src_i, src_offset;
@@ -2685,11 +2738,14 @@ void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
 		 * (this should work because layers are ordered by type)
 		 */
 		while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
+			if (use_default_init) {
+				CustomData_bmesh_set_default_n(dest, dest_block, dest_i);
+			}
 			dest_i++;
 		}
 
 		/* if there are no more dest layers, we're done */
-		if (dest_i >= dest->totlayer) return;
+		if (dest_i >= dest->totlayer) break;
 
 		/* if we found a matching layer, copy the data */
 		if (dest->layers[dest_i].type == source->layers[src_i].type) {
@@ -2712,6 +2768,13 @@ void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
 			dest_i++;
 		}
 	}
+
+	if (use_default_init) {
+		while (dest_i < dest->totlayer) {
+			CustomData_bmesh_set_default_n(dest, dest_block, dest_i);
+			dest_i++;
+		}
+	}
 }
 
 void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
diff --git a/source/blender/blenkernel/intern/displist.c b/source/blender/blenkernel/intern/displist.c
index 71e9daaee6b..643c7b1d972 100644
--- a/source/blender/blenkernel/intern/displist.c
+++ b/source/blender/blenkernel/intern/displist.c
@@ -975,7 +975,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba
 					curve_to_filledpoly(cu, nurb, dispbase);
 				}
 
-				dm = CDDM_from_curve_displist(ob, dispbase, NULL);
+				dm = CDDM_from_curve_displist(ob, dispbase);
 
 				CDDM_calc_normals_mapping(dm);
 			}
@@ -1065,7 +1065,7 @@ static DerivedMesh *create_orco_dm(Scene *scene, Object *ob)
 
 	/* OrcoDM should be created from underformed disp lists */
 	BKE_displist_make_curveTypes_forOrco(scene, ob, &disp);
-	dm = CDDM_from_curve_displist(ob, &disp, NULL);
+	dm = CDDM_from_curve_displist(ob, &disp);
 
 	BKE_displist_free(&disp);
 
@@ -1485,8 +1485,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 								float *cur_data = data;
 
 								if (cu->taperobj == NULL) {
-									if ( (cu->bevobj != NULL) || !((cu->flag & CU_FRONT) || (cu->flag & CU_BACK)) )
-										fac = bevp->radius;
+									fac = bevp->radius;
 								}
 								else {
 									float len, taper_fac;
diff --git a/source/blender/blenkernel/intern/editderivedmesh.c b/source/blender/blenkernel/intern/editderivedmesh.c
index 1c43b418a1c..91577320a9c 100644
--- a/source/blender/blenkernel/intern/editderivedmesh.c
+++ b/source/blender/blenkernel/intern/editderivedmesh.c
@@ -782,22 +782,18 @@ static void emDM_drawMappedFaces(DerivedMesh *dm,
 	if (poly_prev != GL_ZERO) glEnd();
 }
 
-static void bmdm_get_tri_tex(BMesh *bm, BMLoop **ls, MLoopUV *luv[3], MLoopCol *lcol[3],
-                             int has_uv, int has_col)
+static void bmdm_get_tri_uv(BMLoop *ls[3], MLoopUV *luv[3], const int cd_loop_uv_offset)
 {
-	if (has_uv) {
-		luv[0] = CustomData_bmesh_get(&bm->ldata, ls[0]->head.data, CD_MLOOPUV);
-		luv[1] = CustomData_bmesh_get(&bm->ldata, ls[1]->head.data, CD_MLOOPUV);
-		luv[2] = CustomData_bmesh_get(&bm->ldata, ls[2]->head.data, CD_MLOOPUV);
-	}
-
-	if (has_col) {
-		lcol[0] = CustomData_bmesh_get(&bm->ldata, ls[0]->head.data, CD_MLOOPCOL);
-		lcol[1] = CustomData_bmesh_get(&bm->ldata, ls[1]->head.data, CD_MLOOPCOL);
-		lcol[2] = CustomData_bmesh_get(&bm->ldata, ls[2]->head.data, CD_MLOOPCOL);
-	}
-
+	luv[0] = BM_ELEM_CD_GET_VOID_P(ls[0], cd_loop_uv_offset);
+	luv[1] = BM_ELEM_CD_GET_VOID_P(ls[1], cd_loop_uv_offset);
+	luv[2] = BM_ELEM_CD_GET_VOID_P(ls[2], cd_loop_uv_offset);
+}
 
+static void bmdm_get_tri_col(BMLoop *ls[3], MLoopCol *lcol[3], const int cd_loop_color_offset)
+{
+	lcol[0] = BM_ELEM_CD_GET_VOID_P(ls[0], cd_loop_color_offset);
+	lcol[1] = BM_ELEM_CD_GET_VOID_P(ls[1], cd_loop_color_offset);
+	lcol[2] = BM_ELEM_CD_GET_VOID_P(ls[2], cd_loop_color_offset);
 }
 
 static void emDM_drawFacesTex_common(DerivedMesh *dm,
@@ -813,15 +809,19 @@ static void emDM_drawFacesTex_common(DerivedMesh *dm,
 	float (*vertexNos)[3] = bmdm->vertexNos;
 	BMFace *efa;
 	MLoopUV *luv[3], dummyluv = {{0}};
-	MLoopCol *lcol[3] = {NULL}, dummylcol = {0};
-	int i, has_vcol = CustomData_has_layer(&bm->ldata, CD_MLOOPCOL);
-	int has_uv = CustomData_has_layer(&bm->pdata, CD_MTEXPOLY);
+	MLoopCol *lcol[3] = {NULL} /* , dummylcol = {0} */;
+	const int cd_loop_uv_offset    = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
+	const int cd_loop_color_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPCOL);
+	const int cd_poly_tex_offset   = CustomData_get_offset(&bm->pdata, CD_MTEXPOLY);
+	bool has_uv   = (cd_loop_uv_offset    != -1);
+	bool has_vcol = (cd_loop_color_offset != -1);
+	int i;
 
 	(void) compareDrawOptions;
 
 	luv[0] = luv[1] = luv[2] = &dummyluv;
 
-	dummylcol.r = dummylcol.g = dummylcol.b = dummylcol.a = 255;
+	// dummylcol.r = dummylcol.g = dummylcol.b = dummylcol.a = 255;  /* UNUSED */
 
 	/* always use smooth shading even for flat faces, else vertex colors wont interpolate */
 	glShadeModel(GL_SMOOTH);
@@ -833,7 +833,7 @@ static void emDM_drawFacesTex_common(DerivedMesh *dm,
 
 		for (i = 0; i < em->tottri; i++) {
 			BMLoop **ls = em->looptris[i];
-			MTexPoly *tp = has_uv ? CustomData_bmesh_get(&bm->pdata, ls[0]->f->head.data, CD_MTEXPOLY) : NULL;
+			MTexPoly *tp = (cd_poly_tex_offset != -1) ? BM_ELEM_CD_GET_VOID_P(ls[0]->f, cd_poly_tex_offset) : NULL;
 			MTFace mtf = {{{0}}};
 			/*unsigned char *cp = NULL;*/ /*UNUSED*/
 			int drawSmooth = BM_elem_flag_test(ls[0]->f, BM_ELEM_SMOOTH);
@@ -841,7 +841,7 @@ static void emDM_drawFacesTex_common(DerivedMesh *dm,
 
 			efa = ls[0]->f;
 
-			if (has_uv) {
+			if (cd_poly_tex_offset != -1) {
 				ME_MTEXFACE_CPY(&mtf, tp);
 			}
 
@@ -858,25 +858,27 @@ static void emDM_drawFacesTex_common(DerivedMesh *dm,
 				if (!drawSmooth) {
 					glNormal3fv(bmdm->polyNos[BM_elem_index_get(efa)]);
 
-					bmdm_get_tri_tex(bm, ls, luv, lcol, has_uv, has_vcol);
+					if (has_uv)   bmdm_get_tri_uv(ls,  luv,  cd_loop_uv_offset);
+					if (has_vcol) bmdm_get_tri_col(ls, lcol, cd_loop_color_offset);
 
 					glTexCoord2fv(luv[0]->uv);
-					if (lcol[0])
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[0]->r));
 					glVertex3fv(vertexCos[BM_elem_index_get(ls[0]->v)]);
 
 					glTexCoord2fv(luv[1]->uv);
-					if (lcol[1])
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[1]->r));
 					glVertex3fv(vertexCos[BM_elem_index_get(ls[1]->v)]);
 
 					glTexCoord2fv(luv[2]->uv);
-					if (lcol[2])
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[2]->r));
 					glVertex3fv(vertexCos[BM_elem_index_get(ls[2]->v)]);
 				}
 				else {
-					bmdm_get_tri_tex(bm, ls, luv, lcol, has_uv, has_vcol);
+					if (has_uv)   bmdm_get_tri_uv(ls,  luv,  cd_loop_uv_offset);
+					if (has_vcol) bmdm_get_tri_col(ls, lcol, cd_loop_color_offset);
 
 					glTexCoord2fv(luv[0]->uv);
 					if (lcol[0])
@@ -905,7 +907,7 @@ static void emDM_drawFacesTex_common(DerivedMesh *dm,
 
 		for (i = 0; i < em->tottri; i++) {
 			BMLoop **ls = em->looptris[i];
-			MTexPoly *tp = has_uv ? CustomData_bmesh_get(&bm->pdata, ls[0]->f->head.data, CD_MTEXPOLY) : NULL;
+			MTexPoly *tp = (cd_poly_tex_offset != -1) ? BM_ELEM_CD_GET_VOID_P(ls[0]->f, cd_poly_tex_offset) : NULL;
 			MTFace mtf = {{{0}}};
 			/*unsigned char *cp = NULL;*/ /*UNUSED*/
 			int drawSmooth = BM_elem_flag_test(ls[0]->f, BM_ELEM_SMOOTH);
@@ -913,12 +915,12 @@ static void emDM_drawFacesTex_common(DerivedMesh *dm,
 
 			efa = ls[0]->f;
 
-			if (has_uv) {
+			if (cd_poly_tex_offset != -1) {
 				ME_MTEXFACE_CPY(&mtf, tp);
 			}
 
 			if (drawParams)
-				draw_option = drawParams(&mtf, has_vcol, efa->mat_nr);
+				draw_option = drawParams(&mtf, (has_vcol), efa->mat_nr);
 			else if (drawParamsMapped)
 				draw_option = drawParamsMapped(userData, BM_elem_index_get(efa));
 			else
@@ -930,46 +932,42 @@ static void emDM_drawFacesTex_common(DerivedMesh *dm,
 				if (!drawSmooth) {
 					glNormal3fv(efa->no);
 
-					bmdm_get_tri_tex(bm, ls, luv, lcol, has_uv, has_vcol);
+					if (has_uv)   bmdm_get_tri_uv(ls,  luv,  cd_loop_uv_offset);
+					if (has_vcol) bmdm_get_tri_col(ls, lcol, cd_loop_color_offset);
 
-					if (luv[0])
-						glTexCoord2fv(luv[0]->uv);
-					if (lcol[0])
+					glTexCoord2fv(luv[0]->uv);
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[0]->r));
 					glVertex3fv(ls[0]->v->co);
 
-					if (luv[1])
-						glTexCoord2fv(luv[1]->uv);
-					if (lcol[1])
+					glTexCoord2fv(luv[1]->uv);
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[1]->r));
 					glVertex3fv(ls[1]->v->co);
 
-					if (luv[2])
-						glTexCoord2fv(luv[2]->uv);
-					if (lcol[2])
+					glTexCoord2fv(luv[2]->uv);
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[2]->r));
 					glVertex3fv(ls[2]->v->co);
 				}
 				else {
-					bmdm_get_tri_tex(bm, ls, luv, lcol, has_uv, has_vcol);
+					if (has_uv)   bmdm_get_tri_uv(ls,  luv,  cd_loop_uv_offset);
+					if (has_vcol) bmdm_get_tri_col(ls, lcol, cd_loop_color_offset);
 
-					if (luv[0])
-						glTexCoord2fv(luv[0]->uv);
-					if (lcol[0])
+					glTexCoord2fv(luv[0]->uv);
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[0]->r));
 					glNormal3fv(ls[0]->v->no);
 					glVertex3fv(ls[0]->v->co);
 
-					if (luv[1])
-						glTexCoord2fv(luv[1]->uv);
-					if (lcol[1])
+					glTexCoord2fv(luv[1]->uv);
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[1]->r));
 					glNormal3fv(ls[1]->v->no);
 					glVertex3fv(ls[1]->v->co);
 
-					if (luv[2])
-						glTexCoord2fv(luv[2]->uv);
-					if (lcol[2])
+					glTexCoord2fv(luv[2]->uv);
+					if (has_vcol)
 						glColor3ubv((const GLubyte *)&(lcol[2]->r));
 					glNormal3fv(ls[2]->v->no);
 					glVertex3fv(ls[2]->v->co);
@@ -1309,14 +1307,16 @@ static int emDM_getNumPolys(DerivedMesh *dm)
 
 static int bmvert_to_mvert(BMesh *bm, BMVert *ev, MVert *vert_r)
 {
+	float *f;
+
 	copy_v3_v3(vert_r->co, ev->co);
 
 	normal_float_to_short_v3(vert_r->no, ev->no);
 
 	vert_r->flag = BM_vert_flag_to_mflag(ev);
 
-	if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {
-		vert_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->vdata, ev, CD_BWEIGHT) * 255.0f);
+	if ((f = CustomData_bmesh_get(&bm->vdata, ev->head.data, CD_BWEIGHT))) {
+		vert_r->bweight = (unsigned char)((*f) * 255.0f);
 	}
 
 	return 1;
@@ -1332,8 +1332,8 @@ static void emDM_getVert(DerivedMesh *dm, int index, MVert *vert_r)
 		return;
 	}
 
-	// ev = EDBM_vert_at_index(bmdm->tc, index);
-	ev = BM_vert_at_index(bmdm->tc->bm, index); /* warning, does list loop, _not_ ideal */
+	ev = bmdm->tc->vert_index[index];  /* should be EDBM_vert_at_index() */
+	// ev = BM_vert_at_index(bmdm->tc->bm, index); /* warning, does list loop, _not_ ideal */
 
 	bmvert_to_mvert(bmdm->tc->bm, ev, vert_r);
 	if (bmdm->vertexCos)
@@ -1345,27 +1345,27 @@ static void emDM_getEdge(DerivedMesh *dm, int index, MEdge *edge_r)
 	EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
 	BMesh *bm = bmdm->tc->bm;
 	BMEdge *e;
+	float *f;
 
 	if (index < 0 || index >= bmdm->te) {
 		printf("error in emDM_getEdge.\n");
 		return;
 	}
 
-	// e = EDBM_edge_at_index(bmdm->tc, index);
-	e = BM_edge_at_index(bmdm->tc->bm, index); /* warning, does list loop, _not_ ideal */
-
-	if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {
-		edge_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->edata, e, CD_BWEIGHT) * 255.0f);
-	}
-
-	if (CustomData_has_layer(&bm->edata, CD_CREASE)) {
-		edge_r->crease = (unsigned char) (BM_elem_float_data_get(&bm->edata, e, CD_CREASE) * 255.0f);
-	}
+	e = bmdm->tc->edge_index[index];  /* should be EDBM_edge_at_index() */
+	// e = BM_edge_at_index(bmdm->tc->bm, index); /* warning, does list loop, _not_ ideal */
 
 	edge_r->flag = BM_edge_flag_to_mflag(e);
 
 	edge_r->v1 = BM_elem_index_get(e->v1);
 	edge_r->v2 = BM_elem_index_get(e->v2);
+
+	if ((f = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT))) {
+		edge_r->bweight = (unsigned char)((*f) * 255.0f);
+	}
+	if ((f = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE))) {
+		edge_r->crease = (unsigned char)((*f) * 255.0f);
+	}
 }
 
 static void emDM_getTessFace(DerivedMesh *dm, int index, MFace *face_r)
@@ -1400,7 +1400,7 @@ static void emDM_copyVertArray(DerivedMesh *dm, MVert *vert_r)
 	BMesh *bm = bmdm->tc->bm;
 	BMVert *eve;
 	BMIter iter;
-	const int has_bweight = CustomData_has_layer(&bm->vdata, CD_BWEIGHT);
+	const int cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
 
 	if (bmdm->vertexCos) {
 		int i;
@@ -1410,9 +1410,8 @@ static void emDM_copyVertArray(DerivedMesh *dm, MVert *vert_r)
 			normal_float_to_short_v3(vert_r->no, eve->no);
 			vert_r->flag = BM_vert_flag_to_mflag(eve);
 
-			if (has_bweight) {
-				vert_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->vdata, eve, CD_BWEIGHT) * 255.0f);
-			}
+			if (cd_vert_bweight_offset != -1) vert_r->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
+
 			vert_r++;
 		}
 	}
@@ -1422,9 +1421,8 @@ static void emDM_copyVertArray(DerivedMesh *dm, MVert *vert_r)
 			normal_float_to_short_v3(vert_r->no, eve->no);
 			vert_r->flag = BM_vert_flag_to_mflag(eve);
 
-			if (has_bweight) {
-				vert_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->vdata, eve, CD_BWEIGHT) * 255.0f);
-			}
+			if (cd_vert_bweight_offset != -1) vert_r->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eve, cd_vert_bweight_offset);
+
 			vert_r++;
 		}
 	}
@@ -1435,24 +1433,20 @@ static void emDM_copyEdgeArray(DerivedMesh *dm, MEdge *edge_r)
 	BMesh *bm = ((EditDerivedBMesh *)dm)->tc->bm;
 	BMEdge *eed;
 	BMIter iter;
-	const int has_bweight = CustomData_has_layer(&bm->edata, CD_BWEIGHT);
-	const int has_crease = CustomData_has_layer(&bm->edata, CD_CREASE);
+
+	const int cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
+	const int cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
 
 	BM_mesh_elem_index_ensure(bm, BM_VERT);
 
 	BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
-		if (has_bweight) {
-			edge_r->bweight = (unsigned char) (BM_elem_float_data_get(&bm->edata, eed, CD_BWEIGHT) * 255.0f);
-		}
-
-		if (has_crease) {
-			edge_r->crease = (unsigned char) (BM_elem_float_data_get(&bm->edata, eed, CD_CREASE) * 255.0f);
-		}
+		edge_r->v1 = BM_elem_index_get(eed->v1);
+		edge_r->v2 = BM_elem_index_get(eed->v2);
 
 		edge_r->flag = BM_edge_flag_to_mflag(eed);
 
-		edge_r->v1 = BM_elem_index_get(eed->v1);
-		edge_r->v2 = BM_elem_index_get(eed->v2);
+		if (cd_edge_crease_offset  != -1) edge_r->crease  = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_crease_offset);
+		if (cd_edge_bweight_offset != -1) edge_r->bweight = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_bweight_offset);
 
 		edge_r++;
 	}
@@ -1660,6 +1654,9 @@ DerivedMesh *getEditDerivedBMesh(BMEditMesh *em,
 	DM_init((DerivedMesh *)bmdm, DM_TYPE_EDITBMESH, em->bm->totvert,
 	        em->bm->totedge, em->tottri, em->bm->totloop, em->bm->totface);
 
+	/* could also get from the objects mesh directly */
+	bmdm->dm.cd_flag = BM_mesh_cd_flag_from_bmesh(bm);
+
 	bmdm->dm.getVertCos = emDM_getVertCos;
 	bmdm->dm.getMinMax = emDM_getMinMax;
 
diff --git a/source/blender/blenkernel/intern/fmodifier.c b/source/blender/blenkernel/intern/fmodifier.c
index 2b393b4d90b..7b007af86d6 100644
--- a/source/blender/blenkernel/intern/fmodifier.c
+++ b/source/blender/blenkernel/intern/fmodifier.c
@@ -141,55 +141,34 @@ static void fcm_generator_verify(FModifier *fcm)
 	switch (data->mode) {
 		case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
 		{
+			const int arraysize_new = data->poly_order + 1;
 			/* arraysize needs to be order+1, so resize if not */
-			if (data->arraysize != (data->poly_order + 1)) {
-				float *nc;
-				
-				/* make new coefficients array, and copy over as much data as can fit */
-				nc = MEM_callocN(sizeof(float) * (data->poly_order + 1), "FMod_Generator_Coefs");
-				
+			if (data->arraysize != arraysize_new) {
 				if (data->coefficients) {
-					if ((int)data->arraysize > (data->poly_order + 1))
-						memcpy(nc, data->coefficients, sizeof(float) * (data->poly_order + 1));
-					else
-						memcpy(nc, data->coefficients, sizeof(float) * data->arraysize);
-						
-					/* free the old data */
-					MEM_freeN(data->coefficients);
+					data->coefficients = MEM_recallocN(data->coefficients, sizeof(float) * arraysize_new);
 				}
-				
-				/* set the new data */
-				data->coefficients = nc;
-				data->arraysize = data->poly_order + 1;
+				else {
+					data->coefficients = MEM_callocN(sizeof(float) * arraysize_new, "FMod_Generator_Coefs");
+				}
+				data->arraysize = arraysize_new;
 			}
+			break;
 		}
-		break;
-		
 		case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* expanded polynomial expression */
 		{
-			/* arraysize needs to be 2*order, so resize if not */
-			if (data->arraysize != (data->poly_order * 2)) {
-				float *nc;
-				
-				/* make new coefficients array, and copy over as much data as can fit */
-				nc = MEM_callocN(sizeof(float) * (data->poly_order * 2), "FMod_Generator_Coefs");
-				
+			const int arraysize_new = data->poly_order * 2;
+			/* arraysize needs to be (2 * order), so resize if not */
+			if (data->arraysize != arraysize_new) {
 				if (data->coefficients) {
-					if (data->arraysize > (unsigned int)(data->poly_order * 2))
-						memcpy(nc, data->coefficients, sizeof(float) * (data->poly_order * 2));
-					else
-						memcpy(nc, data->coefficients, sizeof(float) * data->arraysize);
-						
-					/* free the old data */
-					MEM_freeN(data->coefficients);
+					data->coefficients = MEM_recallocN(data->coefficients, sizeof(float) * arraysize_new);
 				}
-				
-				/* set the new data */
-				data->coefficients = nc;
-				data->arraysize = data->poly_order * 2;
+				else {
+					data->coefficients = MEM_callocN(sizeof(float) * arraysize_new, "FMod_Generator_Coefs");
+				}
+				data->arraysize = arraysize_new;
 			}
+			break;
 		}
-		break;
 	}
 }
 
diff --git a/source/blender/blenkernel/intern/image.c b/source/blender/blenkernel/intern/image.c
index dbc423f98b3..21417386d65 100644
--- a/source/blender/blenkernel/intern/image.c
+++ b/source/blender/blenkernel/intern/image.c
@@ -904,7 +904,7 @@ void BKE_image_free_all_textures(void)
 				image_free_buffers(ima);
 		}
 	}
-	/* printf("freed total %d MB\n", totsize/(1024*1024)); */
+	/* printf("freed total %d MB\n", totsize / (1024 * 1024)); */
 }
 
 /* except_frame is weak, only works for seqs without offset... */
diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c
index 30e7cb3bb36..dec7556392f 100644
--- a/source/blender/blenkernel/intern/mesh.c
+++ b/source/blender/blenkernel/intern/mesh.c
@@ -1204,8 +1204,8 @@ int BKE_mesh_nurbs_to_mdata(Object *ob, MVert **allvert, int *totvert,
 	return BKE_mesh_nurbs_displist_to_mdata(ob, &ob->disp,
 	                                        allvert, totvert,
 	                                        alledge, totedge,
-	                                        allloop, allpoly,
-	                                        totloop, totpoly, NULL);
+	                                        allloop, allpoly, NULL,
+	                                        totloop, totpoly);
 }
 
 /* BMESH: this doesn't calculate all edges from polygons,
@@ -1213,25 +1213,24 @@ int BKE_mesh_nurbs_to_mdata(Object *ob, MVert **allvert, int *totvert,
 
 /* Initialize mverts, medges and, faces for converting nurbs to mesh and derived mesh */
 /* use specified dispbase */
-/* TODO: orco values for non DL_SURF types */
 int BKE_mesh_nurbs_displist_to_mdata(Object *ob, ListBase *dispbase,
                                      MVert **allvert, int *_totvert,
                                      MEdge **alledge, int *_totedge,
                                      MLoop **allloop, MPoly **allpoly,
-                                     int *_totloop, int *_totpoly,
-                                     int **orco_index_ptr)
+                                     MLoopUV **alluv,
+                                     int *_totloop, int *_totpoly)
 {
 	DispList *dl;
 	Curve *cu;
 	MVert *mvert;
 	MPoly *mpoly;
 	MLoop *mloop;
+	MLoopUV *mloopuv = NULL;
 	MEdge *medge;
 	float *data;
 	int a, b, ofs, vertcount, startvert, totvert = 0, totedge = 0, totloop = 0, totvlak = 0;
 	int p1, p2, p3, p4, *index;
 	int conv_polys = 0;
-	int (*orco_index)[4] = NULL;
 
 	cu = ob->data;
 
@@ -1278,15 +1277,13 @@ int BKE_mesh_nurbs_displist_to_mdata(Object *ob, ListBase *dispbase,
 	*alledge = medge = MEM_callocN(sizeof(MEdge) * totedge, "nurbs_init medge");
 	*allloop = mloop = MEM_callocN(sizeof(MLoop) * totvlak * 4, "nurbs_init mloop"); // totloop
 	*allpoly = mpoly = MEM_callocN(sizeof(MPoly) * totvlak, "nurbs_init mloop");
+
+	if (alluv)
+		*alluv = mloopuv = MEM_callocN(sizeof(MLoopUV) * totvlak * 4, "nurbs_init mloopuv");
 	
 	/* verts and faces */
 	vertcount = 0;
 
-	if (orco_index_ptr) {
-		*orco_index_ptr = MEM_callocN(sizeof(int) * totvlak * 4, "nurbs_init orco");
-		orco_index = (int (*)[4]) *orco_index_ptr;
-	}
-
 	dl = dispbase->first;
 	while (dl) {
 		int smooth = dl->rt & CU_SMOOTH ? 1 : 0;
@@ -1359,6 +1356,15 @@ int BKE_mesh_nurbs_displist_to_mdata(Object *ob, ListBase *dispbase,
 				mpoly->totloop = 3;
 				mpoly->mat_nr = dl->col;
 
+				if (mloopuv) {
+					int i;
+
+					for (i = 0; i < 3; i++, mloopuv++) {
+						mloopuv->uv[0] = (mloop[i].v - startvert)/(float)(dl->nr - 1);
+						mloopuv->uv[1] = 0.0f;
+					}
+				}
+
 				if (smooth) mpoly->flag |= ME_SMOOTH;
 				mpoly++;
 				mloop += 3;
@@ -1408,13 +1414,29 @@ int BKE_mesh_nurbs_displist_to_mdata(Object *ob, ListBase *dispbase,
 					mpoly->totloop = 4;
 					mpoly->mat_nr = dl->col;
 
-					if (orco_index) {
-						const int poly_index = mpoly - *allpoly;
-						const int p_orco_base = startvert + ((dl->nr + 1) * a) + b;
-						orco_index[poly_index][0] = p_orco_base + 1;
-						orco_index[poly_index][1] = p_orco_base + dl->nr + 2;
-						orco_index[poly_index][2] = p_orco_base + dl->nr + 1;
-						orco_index[poly_index][3] = p_orco_base;
+					if (mloopuv) {
+						int orco_sizeu = dl->nr - 1;
+						int orco_sizev = dl->parts - 1;
+						int i;
+
+						/* exception as handled in convertblender.c too */
+						if (dl->flag & DL_CYCL_U) {
+							orco_sizeu++;
+							if (dl->flag & DL_CYCL_V)
+								orco_sizev++;
+						}
+
+						for (i = 0; i < 4; i++, mloopuv++) {
+							/* find uv based on vertex index into grid array */
+							int v = mloop[i].v - startvert;
+
+							mloopuv->uv[0] = (v / dl->nr)/(float)orco_sizev;
+							mloopuv->uv[1] = (v % dl->nr)/(float)orco_sizeu;
+
+							/* cyclic correction */
+							if ((i == 0 || i == 1) && mloopuv->uv[1] == 0.0f)
+								mloopuv->uv[1] = 1.0f;
+						}
 					}
 
 					if (smooth) mpoly->flag |= ME_SMOOTH;
@@ -1427,7 +1449,6 @@ int BKE_mesh_nurbs_displist_to_mdata(Object *ob, ListBase *dispbase,
 					p1++;
 				}
 			}
-
 		}
 
 		dl = dl->next;
@@ -1448,33 +1469,8 @@ int BKE_mesh_nurbs_displist_to_mdata(Object *ob, ListBase *dispbase,
 }
 
 
-MINLINE void copy_uv_orco_v2_v2(float r[2], const float a[2])
-{
-	r[0] = 0.5f + a[0] * 0.5f;
-	r[1] = 0.5f + a[1] * 0.5f;
-}
-
-/**
- * orco is normally from #BKE_curve_make_orco
- */
-void BKE_mesh_nurbs_to_mdata_orco(MPoly *mpoly, int totpoly,
-                                  MLoop *mloops, MLoopUV *mloopuvs,
-                                  float (*orco)[3], int (*orco_index)[4])
-{
-	MPoly *mp;
-
-	int i, j;
-	for (i = 0, mp = mpoly; i < totpoly; i++, mp++) {
-		MLoop *ml = mloops + mp->loopstart;
-		MLoopUV *mluv = mloopuvs + mp->loopstart;
-		for (j = 0; j < mp->totloop; j++, ml++, mluv++) {
-			copy_uv_orco_v2_v2(mluv->uv, orco[orco_index[i][j]]);
-		}
-	}
-}
-
 /* this may fail replacing ob->data, be sure to check ob->type */
-void BKE_mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, int **orco_index_ptr)
+void BKE_mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, int use_orco_uv)
 {
 	Main *bmain = G.main;
 	Object *ob1;
@@ -1484,6 +1480,7 @@ void BKE_mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, int **orco_ind
 	MVert *allvert = NULL;
 	MEdge *alledge = NULL;
 	MLoop *allloop = NULL;
+	MLoopUV *alluv = NULL;
 	MPoly *allpoly = NULL;
 	int totvert, totedge, totloop, totpoly;
 
@@ -1492,7 +1489,8 @@ void BKE_mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, int **orco_ind
 	if (dm == NULL) {
 		if (BKE_mesh_nurbs_displist_to_mdata(ob, dispbase, &allvert, &totvert,
 		                                     &alledge, &totedge, &allloop,
-		                                     &allpoly, &totloop, &totpoly, orco_index_ptr) != 0)
+		                                     &allpoly, (use_orco_uv)? &alluv: NULL,
+		                                     &totloop, &totpoly) != 0)
 		{
 			/* Error initializing */
 			return;
@@ -1510,6 +1508,12 @@ void BKE_mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, int **orco_ind
 		me->mloop = CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, allloop, me->totloop);
 		me->mpoly = CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, allpoly, me->totpoly);
 
+		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);
+		}
+
 		BKE_mesh_calc_normals(me->mvert, me->totvert, me->mloop, me->mpoly, me->totloop, me->totpoly, NULL);
 
 		BKE_mesh_calc_edges(me, TRUE);
@@ -1548,7 +1552,7 @@ void BKE_mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, int **orco_ind
 
 void BKE_mesh_from_nurbs(Object *ob)
 {
-	BKE_mesh_from_nurbs_displist(ob, &ob->disp, NULL);
+	BKE_mesh_from_nurbs_displist(ob, &ob->disp, false);
 }
 
 typedef struct EdgeLink {
@@ -3337,3 +3341,39 @@ void BKE_mesh_poly_calc_angles(MVert *mvert, MLoop *mloop,
 	}
 }
 #endif
+
+
+void BKE_mesh_do_versions_cd_flag_init(Mesh *mesh)
+{
+	if (UNLIKELY(mesh->cd_flag)) {
+		return;
+	}
+	else {
+		MVert *mv;
+		MEdge *med;
+		int i;
+
+		for (mv = mesh->mvert, i = 0; i < mesh->totvert; mv++, i++) {
+			if (mv->bweight != 0) {
+				mesh->cd_flag |= ME_CDFLAG_VERT_BWEIGHT;
+				break;
+			}
+		}
+
+		for (med = mesh->medge, i = 0; i < mesh->totedge; med++, i++) {
+			if (med->bweight != 0) {
+				mesh->cd_flag |= ME_CDFLAG_EDGE_BWEIGHT;
+				if (mesh->cd_flag & ME_CDFLAG_EDGE_CREASE) {
+					break;
+				}
+			}
+			if (med->crease != 0) {
+				mesh->cd_flag |= ME_CDFLAG_EDGE_CREASE;
+				if (mesh->cd_flag & ME_CDFLAG_EDGE_BWEIGHT) {
+					break;
+				}
+			}
+		}
+
+	}
+}
diff --git a/source/blender/blenkernel/intern/modifiers_bmesh.c b/source/blender/blenkernel/intern/modifiers_bmesh.c
index 7df7561a1a1..a6c2325c740 100644
--- a/source/blender/blenkernel/intern/modifiers_bmesh.c
+++ b/source/blender/blenkernel/intern/modifiers_bmesh.c
@@ -59,9 +59,14 @@ void DM_to_bmesh_ex(DerivedMesh *dm, BMesh *bm)
 	BLI_array_declare(verts);
 	BLI_array_declare(edges);
 	int i, j, k, totvert, totedge /* , totface */ /* UNUSED */ ;
-	int is_init = (bm->totvert == 0) && (bm->totedge == 0) && (bm->totface == 0);
+	bool is_init = (bm->totvert == 0) && (bm->totedge == 0) && (bm->totface == 0);
+	bool is_cddm = (dm->type == DM_TYPE_CDDM);  /* duplicate the arrays for non cddm */
 	char has_orig_hflag = 0;
 
+	int cd_vert_bweight_offset;
+	int cd_edge_bweight_offset;
+	int cd_edge_crease_offset;
+
 	if (is_init == FALSE) {
 		/* check if we have an origflag */
 		has_orig_hflag |= CustomData_has_layer(&bm->vdata, CD_ORIGINDEX) ? BM_VERT : 0;
@@ -75,43 +80,45 @@ void DM_to_bmesh_ex(DerivedMesh *dm, BMesh *bm)
 	CustomData_bmesh_merge(&dm->loopData, &bm->ldata, CD_MASK_DERIVEDMESH, CD_CALLOC, bm, BM_LOOP);
 	CustomData_bmesh_merge(&dm->polyData, &bm->pdata, CD_MASK_DERIVEDMESH, CD_CALLOC, bm, BM_FACE);
 
+	if (is_init) {
+		BM_mesh_cd_flag_apply(bm, dm->cd_flag);
+	}
+
+	cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT);
+	cd_edge_bweight_offset = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
+	cd_edge_crease_offset  = CustomData_get_offset(&bm->edata, CD_CREASE);
+
 	totvert = dm->getNumVerts(dm);
 	totedge = dm->getNumEdges(dm);
 	/* totface = dm->getNumPolys(dm); */ /* UNUSED */
 
-	/* add crease layer */
-	BM_data_layer_add(bm, &bm->edata, CD_CREASE);
-	/* add bevel weight layers */
-	BM_data_layer_add(bm, &bm->edata, CD_BWEIGHT);
-	BM_data_layer_add(bm, &bm->vdata, CD_BWEIGHT);
-
 	vtable = MEM_callocN(sizeof(void **) * totvert, __func__);
 	etable = MEM_callocN(sizeof(void **) * totedge, __func__);
 
 	/*do verts*/
-	mv = mvert = dm->dupVertArray(dm);
+	mv = mvert = is_cddm ? dm->getVertArray(dm) : dm->dupVertArray(dm);
 	for (i = 0; i < totvert; i++, mv++) {
 		v = BM_vert_create(bm, mv->co, NULL, BM_CREATE_SKIP_CD);
 		normal_short_to_float_v3(v->no, mv->no);
 		v->head.hflag = BM_vert_flag_from_mflag(mv->flag);
 		BM_elem_index_set(v, i); /* set_inline */
 
-		CustomData_to_bmesh_block(&dm->vertData, &bm->vdata, i, &v->head.data);
+		CustomData_to_bmesh_block(&dm->vertData, &bm->vdata, i, &v->head.data, true);
 		vtable[i] = v;
 
 		/* add bevel weight */
-		BM_elem_float_data_set(&bm->vdata, v, CD_BWEIGHT, (float)mv->bweight / 255.0f);
+		if (cd_vert_bweight_offset != -1) BM_ELEM_CD_SET_FLOAT(v, cd_vert_bweight_offset, (float)mv->bweight / 255.0f);
 
 		if (UNLIKELY(has_orig_hflag & BM_VERT)) {
 			int *orig_index = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_ORIGINDEX);
 			*orig_index = ORIGINDEX_NONE;
 		}
 	}
-	MEM_freeN(mvert);
+	if (!is_cddm) MEM_freeN(mvert);
 	if (is_init) bm->elem_index_dirty &= ~BM_VERT;
 
 	/*do edges*/
-	me = medge = dm->dupEdgeArray(dm);
+	me = medge = is_cddm ? dm->getEdgeArray(dm) : dm->dupEdgeArray(dm);
 	for (i = 0; i < totedge; i++, me++) {
 		//BLI_assert(BM_edge_exists(vtable[me->v1], vtable[me->v2]) == NULL);
 		e = BM_edge_create(bm, vtable[me->v1], vtable[me->v2], NULL, BM_CREATE_SKIP_CD);
@@ -119,20 +126,18 @@ void DM_to_bmesh_ex(DerivedMesh *dm, BMesh *bm)
 		e->head.hflag = BM_edge_flag_from_mflag(me->flag);
 		BM_elem_index_set(e, i); /* set_inline */
 
-		CustomData_to_bmesh_block(&dm->edgeData, &bm->edata, i, &e->head.data);
+		CustomData_to_bmesh_block(&dm->edgeData, &bm->edata, i, &e->head.data, true);
 		etable[i] = e;
 
-		/* add crease */
-		BM_elem_float_data_set(&bm->edata, e, CD_CREASE, (float)me->crease / 255.0f);
-		/* add bevel weight */
-		BM_elem_float_data_set(&bm->edata, e, CD_BWEIGHT, (float)me->bweight / 255.0f);
+		if (cd_edge_bweight_offset != -1) BM_ELEM_CD_SET_FLOAT(e, cd_edge_bweight_offset, (float)me->bweight / 255.0f);
+		if (cd_edge_crease_offset  != -1) BM_ELEM_CD_SET_FLOAT(e, cd_edge_crease_offset,  (float)me->crease  / 255.0f);
 
 		if (UNLIKELY(has_orig_hflag & BM_EDGE)) {
 			int *orig_index = CustomData_bmesh_get(&bm->edata, e->head.data, CD_ORIGINDEX);
 			*orig_index = ORIGINDEX_NONE;
 		}
 	}
-	MEM_freeN(medge);
+	if (!is_cddm) MEM_freeN(medge);
 	if (is_init) bm->elem_index_dirty &= ~BM_EDGE;
 
 	/* do faces */
@@ -156,7 +161,7 @@ void DM_to_bmesh_ex(DerivedMesh *dm, BMesh *bm)
 			edges[j] = etable[ml->e];
 		}
 
-		f = BM_face_create_ngon(bm, verts[0], verts[1], edges, mp->totloop, BM_CREATE_SKIP_CD);
+		f = BM_face_create(bm, verts, edges, mp->totloop, BM_CREATE_SKIP_CD);
 
 		if (UNLIKELY(f == NULL)) {
 			continue;
@@ -169,10 +174,10 @@ void DM_to_bmesh_ex(DerivedMesh *dm, BMesh *bm)
 		l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, f);
 
 		for (k = mp->loopstart; l; l = BM_iter_step(&liter), k++) {
-			CustomData_to_bmesh_block(&dm->loopData, &bm->ldata, k, &l->head.data);
+			CustomData_to_bmesh_block(&dm->loopData, &bm->ldata, k, &l->head.data, true);
 		}
 
-		CustomData_to_bmesh_block(&dm->polyData, &bm->pdata, i, &f->head.data);
+		CustomData_to_bmesh_block(&dm->polyData, &bm->pdata, i, &f->head.data, true);
 
 		if (face_normals) {
 			copy_v3_v3(f->no, face_normals[i]);
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index 3b897e94241..5eac86a7e77 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -2396,6 +2396,7 @@ typedef struct SPHRangeData {
 	ParticleData *pa;
 
 	float h;
+	float mass;
 	float massfac;
 	int use_size;
 } SPHRangeData;
@@ -2408,7 +2409,7 @@ static void sph_evaluate_func(BVHTree *tree, ParticleSystem **psys, float co[3],
 
 	for (i=0; i < 10 && psys[i]; i++) {
 		pfr->npsys    = psys[i];
-		pfr->massfac  = psys[i]->part->mass;
+		pfr->massfac  = psys[i]->part->mass / pfr->mass;
 		pfr->use_size = psys[i]->part->flag & PART_SIZEMASS;
 
 		if (tree) {
@@ -2491,7 +2492,6 @@ static void sph_force_cb(void *sphdata_v, ParticleKey *state, float *force, floa
 	ParticleSpring *spring = NULL;
 	SPHRangeData pfr;
 	SPHNeighbor *pfn;
-	float mass = sphdata->mass;
 	float *gravity = sphdata->gravity;
 	EdgeHash *springhash = sphdata->eh;
 
@@ -2501,7 +2501,7 @@ static void sph_force_cb(void *sphdata_v, ParticleKey *state, float *force, floa
 	float visc = fluid->viscosity_omega;
 	float stiff_visc = fluid->viscosity_beta * (fluid->flag & SPH_FAC_VISCOSITY ? fluid->viscosity_omega : 1.f);
 
-	float inv_mass = 1.0f/mass;
+	float inv_mass = 1.0f / sphdata->mass;
 	float spring_constant = fluid->spring_k;
 
 	/* 4.0 seems to be a pretty good value */
@@ -2526,6 +2526,7 @@ static void sph_force_cb(void *sphdata_v, ParticleKey *state, float *force, floa
 	pfr.data = data;
 	pfr.h = h;
 	pfr.pa = pa;
+	pfr.mass = sphdata->mass;
 
 	sph_evaluate_func( NULL, psys, state->co, &pfr, interaction_radius, sph_density_accum_cb);
 
@@ -2644,7 +2645,7 @@ static void sphclassical_density_accum_cb(void *userdata, int index, float UNUSE
 	 *     q1(x) = (2.0 - x)**4 * ( 1.0 + 2.0 * x)
 	 *     plot [0:2] q1(x) */
 	q  = qfac / pow3(pfr->h) * pow4(2.0f - rij_h) * ( 1.0f + 2.0f * rij_h);
-	q *= pfr->massfac;
+	q *= pfr->npsys->part->mass;
 
 	if (pfr->use_size)
 		q *= pfr->pa->size;
@@ -2696,7 +2697,8 @@ static void sphclassical_force_cb(void *sphdata_v, ParticleKey *state, float *fo
 	/* 4.77 is an experimentally determined density factor */
 	float rest_density = fluid->rest_density * (fluid->flag & SPH_FAC_DENSITY ? 4.77f : 1.0f);
 
-	float stiffness = fluid->stiffness_k;
+	// Use speed of sound squared
+	float stiffness = pow2(fluid->stiffness_k);
 
 	ParticleData *npa;
 	float vec[3];
@@ -2792,6 +2794,7 @@ static void sphclassical_calc_dens(ParticleData *pa, float UNUSED(dfra), SPHData
 	pfr.data = data;
 	pfr.h = interaction_radius * sphdata->hfac;
 	pfr.pa = pa;
+	pfr.mass = sphdata->mass;
 
 	sph_evaluate_func( NULL, psys, pa->state.co, &pfr, interaction_radius, sphclassical_density_accum_cb);
 	pa->sphdensity = MIN2(MAX2(data[0], fluid->rest_density * 0.9f), fluid->rest_density * 1.1f);
@@ -2851,7 +2854,8 @@ void psys_sph_density(BVHTree *tree, SPHData *sphdata, float co[3], float vars[2
 
 	density[0] = density[1] = 0.0f;
 	pfr.data = density;
-	pfr.h = interaction_radius*sphdata->hfac;
+	pfr.h = interaction_radius * sphdata->hfac;
+	pfr.mass = sphdata->mass;
 
 	sph_evaluate_func(tree, psys, co, &pfr, interaction_radius, sphdata->density_cb);
 
@@ -4220,7 +4224,7 @@ static void dynamics_step(ParticleSimulationData *sim, float cfra)
 			ParticleSettings *part = sim->psys->part;
 			psys_sph_init(sim, &sphdata);
 
-			if (part->fluid->flag & SPH_SOLVER_DDR) {
+			if (part->fluid->solver == SPH_SOLVER_DDR) {
 				/* Apply SPH forces using double-density relaxation algorithm
 				 * (Clavat et. al.) */
 				#pragma omp parallel for firstprivate (sphdata) private (pa) schedule(dynamic,5)
diff --git a/source/blender/blenkernel/intern/pointcache.c b/source/blender/blenkernel/intern/pointcache.c
index 9c3c1b0e508..97948683e22 100644
--- a/source/blender/blenkernel/intern/pointcache.c
+++ b/source/blender/blenkernel/intern/pointcache.c
@@ -272,7 +272,7 @@ static void ptcache_particle_read(int index, void *psys_v, void **data, float cf
 	ParticleSystem *psys= psys_v;
 	ParticleData *pa;
 	BoidParticle *boid;
-	float timestep = 0.04f*psys->part->timetweak;
+	float timestep = 0.04f * psys->part->timetweak;
 
 	if (index >= psys->totpart)
 		return;
@@ -333,7 +333,7 @@ static void ptcache_particle_interpolate(int index, void *psys_v, void **data, f
 	ParticleSystem *psys= psys_v;
 	ParticleData *pa;
 	ParticleKey keys[4];
-	float dfra, timestep = 0.04f*psys->part->timetweak;
+	float dfra, timestep = 0.04f * psys->part->timetweak;
 
 	if (index >= psys->totpart)
 		return;
@@ -559,7 +559,7 @@ static int  ptcache_smoke_write(PTCacheFile *pf, void *smoke_v)
 		float dt, dx, *dens, *react, *fuel, *flame, *heat, *heatold, *vx, *vy, *vz, *r, *g, *b;
 		unsigned char *obstacles;
 		unsigned int in_len = sizeof(float)*(unsigned int)res;
-		unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len)*4, "pointcache_lzo_buffer");
+		unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len) * 4, "pointcache_lzo_buffer");
 		//int mode = res >= 1000000 ? 2 : 1;
 		int mode=1;		// light
 		if (sds->cache_comp == SM_CACHE_HEAVY) mode=2;	// heavy
@@ -792,7 +792,7 @@ static int  ptcache_dynamicpaint_write(PTCacheFile *pf, void *dp_v)
 	int cache_compress = 1;
 
 	/* version header */
-	ptcache_file_write(pf, DPAINT_CACHE_VERSION, 1, sizeof(char)*4);
+	ptcache_file_write(pf, DPAINT_CACHE_VERSION, 1, sizeof(char) * 4);
 
 	if (surface->format != MOD_DPAINT_SURFACE_F_IMAGESEQ && surface->data) {
 		int total_points=surface->data->total_points;
@@ -831,7 +831,7 @@ static int ptcache_dynamicpaint_read(PTCacheFile *pf, void *dp_v)
 	char version[4];
 	
 	/* version header */
-	ptcache_file_read(pf, version, 1, sizeof(char)*4);
+	ptcache_file_read(pf, version, 1, sizeof(char) * 4);
 	if (strncmp(version, DPAINT_CACHE_VERSION, 4)) {printf("Dynamic Paint: Invalid cache version: %s!\n", version); return 0;}
 
 	if (surface->format != MOD_DPAINT_SURFACE_F_IMAGESEQ && surface->data) {
@@ -1163,7 +1163,7 @@ void BKE_ptcache_ids_from_object(ListBase *lb, Object *ob, Scene *scene, int dup
  */
 
 #define MAX_PTCACHE_PATH FILE_MAX
-#define MAX_PTCACHE_FILE ((FILE_MAX)*2)
+#define MAX_PTCACHE_FILE (FILE_MAX * 2)
 
 static int ptcache_path(PTCacheID *pid, char *filename)
 {
@@ -1258,7 +1258,7 @@ static PTCacheFile *ptcache_file_open(PTCacheID *pid, int mode, int cfra)
 {
 	PTCacheFile *pf;
 	FILE *fp = NULL;
-	char filename[(FILE_MAX)*2];
+	char filename[FILE_MAX * 2];
 
 #ifndef DURIAN_POINTCACHE_LIB_OK
 	/* don't allow writing for linked objects */
@@ -1311,7 +1311,7 @@ static int ptcache_file_compressed_read(PTCacheFile *pf, unsigned char *result,
 	size_t out_len = len;
 #endif
 	unsigned char *in;
-	unsigned char *props = MEM_callocN(16*sizeof(char), "tmp");
+	unsigned char *props = MEM_callocN(16 * sizeof(char), "tmp");
 
 	ptcache_file_read(pf, &compressed, 1, sizeof(unsigned char));
 	if (compressed) {
@@ -1354,7 +1354,7 @@ static int ptcache_file_compressed_write(PTCacheFile *pf, unsigned char *in, uns
 	int r = 0;
 	unsigned char compressed = 0;
 	size_t out_len= 0;
-	unsigned char *props = MEM_callocN(16*sizeof(char), "tmp");
+	unsigned char *props = MEM_callocN(16 * sizeof(char), "tmp");
 	size_t sizeOfIt = 5;
 
 	(void)mode; /* unused when building w/o compression */
@@ -1787,7 +1787,7 @@ static int ptcache_mem_frame_to_disk(PTCacheID *pid, PTCacheMem *pm)
 			for (i=0; i<BPHYS_TOT_DATA; i++) {
 				if (pm->data[i]) {
 					unsigned int in_len = pm->totpoint*ptcache_data_size[i];
-					unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len)*4, "pointcache_lzo_buffer");
+					unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len) * 4, "pointcache_lzo_buffer");
 					ptcache_file_compressed_write(pf, (unsigned char *)(pm->data[i]), in_len, out, pid->cache->compression);
 					MEM_freeN(out);
 				}
@@ -1820,7 +1820,7 @@ static int ptcache_mem_frame_to_disk(PTCacheID *pid, PTCacheMem *pm)
 
 			if (pid->cache->compression) {
 				unsigned int in_len = extra->totdata * ptcache_extra_datasize[extra->type];
-				unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len)*4, "pointcache_lzo_buffer");
+				unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len) * 4, "pointcache_lzo_buffer");
 				ptcache_file_compressed_write(pf, (unsigned char *)(extra->data), in_len, out, pid->cache->compression);
 				MEM_freeN(out);
 			}
diff --git a/source/blender/blenkernel/intern/report.c b/source/blender/blenkernel/intern/report.c
index 185aeac5452..1fd7dc14c23 100644
--- a/source/blender/blenkernel/intern/report.c
+++ b/source/blender/blenkernel/intern/report.c
@@ -27,6 +27,10 @@
  *  \ingroup bke
  */
 
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
 
 #include "MEM_guardedalloc.h"
 
@@ -39,10 +43,6 @@
 #include "BKE_report.h"
 #include "BKE_global.h" /* G.background only */
 
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-
 static const char *report_type_str(int type)
 {
 	switch (type) {
@@ -302,3 +302,36 @@ int BKE_reports_contain(ReportList *reports, ReportType level)
 	return FALSE;
 }
 
+bool BKE_report_write_file_fp(FILE *fp, ReportList *reports, const char *header)
+{
+	Report *report;
+
+	if (header) {
+		fputs(header, fp);
+	}
+
+	for (report = reports->list.first; report; report = report->next) {
+		fprintf((FILE *)fp, "%s  # %s\n", report->message, report->typestr);
+	}
+
+	return true;
+}
+
+bool BKE_report_write_file(const char *filepath, ReportList *reports, const char *header)
+{
+	FILE *fp;
+
+	errno = 0;
+	fp = BLI_fopen(filepath, "wb");
+	if (fp == NULL) {
+		fprintf(stderr, "Unable to save '%s': %s\n",
+		        filepath, errno ? strerror(errno) : "Unknown error opening file");
+		return false;
+	}
+
+	BKE_report_write_file_fp(fp, reports, header);
+
+	fclose(fp);
+
+	return true;
+}
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index 04e612d1a33..eb56f34b99b 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -1045,6 +1045,47 @@ static void scene_update_drivers(Main *UNUSED(bmain), Scene *scene)
 	}
 }
 
+/* deps hack - do extra recalcs at end */
+static void scene_depsgraph_hack(Scene *scene, Scene *scene_parent)
+{
+	Base *base;
+		
+	scene->customdata_mask = scene_parent->customdata_mask;
+	
+	/* sets first, we allow per definition current scene to have
+	 * dependencies on sets, but not the other way around. */
+	if (scene->set)
+		scene_depsgraph_hack(scene->set, scene_parent);
+	
+	for (base = scene->base.first; base; base = base->next) {
+		Object *ob = base->object;
+		
+		if (ob->depsflag) {
+			int recalc = 0;
+			// printf("depshack %s\n", ob->id.name+2);
+			
+			if (ob->depsflag & OB_DEPS_EXTRA_OB_RECALC)
+				recalc |= OB_RECALC_OB;
+			if (ob->depsflag & OB_DEPS_EXTRA_DATA_RECALC)
+				recalc |= OB_RECALC_DATA;
+			
+			ob->recalc |= recalc;
+			BKE_object_handle_update(scene_parent, ob);
+			
+			if (ob->dup_group && (ob->transflag & OB_DUPLIGROUP)) {
+				GroupObject *go;
+				
+				for (go = ob->dup_group->gobject.first; go; go = go->next) {
+					if (go->ob)
+						go->ob->recalc |= recalc;
+				}
+				group_handle_recalc_and_update(scene_parent, ob, ob->dup_group);
+			}
+		}
+	}
+
+}
+
 static void scene_update_tagged_recursive(Main *bmain, Scene *scene, Scene *scene_parent)
 {
 	Base *base;
@@ -1080,6 +1121,7 @@ static void scene_update_tagged_recursive(Main *bmain, Scene *scene, Scene *scen
 
 	/* update masking curves */
 	BKE_mask_update_scene(bmain, scene, FALSE);
+	
 }
 
 /* this is called in main loop, doing tagged updates before redraw */
@@ -1172,6 +1214,8 @@ void BKE_scene_update_for_newframe(Main *bmain, Scene *sce, unsigned int lay)
 	/* BKE_object_handle_update() on all objects, groups and sets */
 	scene_update_tagged_recursive(bmain, sce, sce);
 
+	scene_depsgraph_hack(sce, sce);
+
 	/* notify editors and python about recalc */
 	BLI_callback_exec(bmain, &sce->id, BLI_CB_EVT_SCENE_UPDATE_POST);
 	BLI_callback_exec(bmain, &sce->id, BLI_CB_EVT_FRAME_CHANGE_POST);
diff --git a/source/blender/blenkernel/intern/screen.c b/source/blender/blenkernel/intern/screen.c
index 81bcdc4b06e..95b72d0185c 100644
--- a/source/blender/blenkernel/intern/screen.c
+++ b/source/blender/blenkernel/intern/screen.c
@@ -167,6 +167,7 @@ ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
 	newar->prev = newar->next = NULL;
 	newar->handlers.first = newar->handlers.last = NULL;
 	newar->uiblocks.first = newar->uiblocks.last = NULL;
+	newar->ui_lists.first = newar->ui_lists.last = NULL;
 	newar->swinid = 0;
 	
 	/* use optional regiondata callback */
diff --git a/source/blender/blenkernel/intern/seqeffects.c b/source/blender/blenkernel/intern/seqeffects.c
index 3ca04f235b8..c64609c8e70 100644
--- a/source/blender/blenkernel/intern/seqeffects.c
+++ b/source/blender/blenkernel/intern/seqeffects.c
@@ -1150,7 +1150,7 @@ static void do_mul_effect_byte(float facf0, float facf1, int x, int y, unsigned
 	fac3 = (int)(256.0f * facf1);
 
 	/* formula:
-	 *		fac * (a * b) + (1-fac)*a  => fac * a * (b - 1) + axaux = c * px + py * s; //+centx
+	 *		fac * (a * b) + (1 - fac) * a  => fac * a * (b - 1) + axaux = c * px + py * s; //+centx
 	 *		yaux = -s * px + c * py; //+centy
 	 */
 
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index 8d010de408a..2c1fd092fbb 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -2391,7 +2391,7 @@ static ImBuf *seq_render_scene_strip(SeqRenderData context, Sequence *seq, float
 		BKE_scene_update_for_newframe(context.bmain, scene, scene->lay);
 		ibuf = sequencer_view3d_cb(scene, camera, context.rectx, context.recty, IB_rect,
 		                           context.scene->r.seq_prev_type, context.scene->r.seq_flag & R_SEQ_SOLID_TEX,
-		                           TRUE, FALSE, err_out);
+		                           TRUE, scene->r.alphamode, err_out);
 		if (ibuf == NULL) {
 			fprintf(stderr, "seq_render_scene_strip failed to get opengl buffer: %s\n", err_out);
 		}
diff --git a/source/blender/blenkernel/intern/subsurf_ccg.c b/source/blender/blenkernel/intern/subsurf_ccg.c
index b1917c6091d..01409a0f7e4 100644
--- a/source/blender/blenkernel/intern/subsurf_ccg.c
+++ b/source/blender/blenkernel/intern/subsurf_ccg.c
@@ -1322,8 +1322,8 @@ static void ccgDM_copyFinalLoopArray(DerivedMesh *dm, MLoop *mloop)
 	for (index = 0; index < totface; index++) {
 		CCGFace *f = ccgdm->faceMap[index].face;
 		int x, y, S, numVerts = ccgSubSurf_getFaceNumVerts(f);
-		/* int flag = (faceFlags)? faceFlags[index*2]: ME_SMOOTH; */ /* UNUSED */
-		/* int mat_nr = (faceFlags)? faceFlags[index*2+1]: 0; */ /* UNUSED */
+		/* int flag = (faceFlags) ? faceFlags[index * 2]: ME_SMOOTH; */ /* UNUSED */
+		/* int mat_nr = (faceFlags) ? faceFlags[index * 2 + 1]: 0; */ /* UNUSED */
 
 		for (S = 0; S < numVerts; S++) {
 			for (y = 0; y < gridSize - 1; y++) {
@@ -3328,7 +3328,7 @@ static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
 		
 
 		/*I think this is for interpolating the center vert?*/
-		w2 = w; // + numVerts*(g2_wid-1)*(g2_wid-1); //numVerts*((g2_wid-1)*g2_wid+g2_wid-1);
+		w2 = w; // + numVerts*(g2_wid-1) * (g2_wid-1); //numVerts*((g2_wid-1) * g2_wid+g2_wid-1);
 		DM_interp_vert_data(dm, &ccgdm->dm, vertidx, w2,
 		                    numVerts, vertNum);
 		if (vertOrigIndex) {