merge with/from trunk at r35190

42 files changed, 1653 insertions, 1062 deletions

diff --git a/source/blender/modifiers/intern/MOD_armature.c b/source/blender/modifiers/intern/MOD_armature.c
index d0e36f90ff5..fa39c197c7b 100644
--- a/source/blender/modifiers/intern/MOD_armature.c
+++ b/source/blender/modifiers/intern/MOD_armature.c
@@ -30,10 +30,19 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_armature.c
+ *  \ingroup modifiers
+ */
+
+
 #include <string.h>
 
 #include "DNA_armature_types.h"
 #include "DNA_object_types.h"
+#include "DNA_mesh_types.h"
+
+#include "BLI_utildefines.h"
+
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_lattice.h"
@@ -60,20 +69,21 @@ static void copyData(ModifierData *md, ModifierData *target)
 
 	tamd->object = amd->object;
 	tamd->deformflag = amd->deformflag;
+	tamd->multi = amd->multi;
 	strncpy(tamd->defgrp_name, amd->defgrp_name, 32);
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
 {
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups */
-	dataMask |= (1 << CD_MDEFORMVERT);
+	dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
 
-static int isDisabled(ModifierData *md, int useRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
 {
 	ArmatureModifierData *amd = (ArmatureModifierData*) md;
 
@@ -90,9 +100,10 @@ static void foreachObjectLink(
 	walk(userData, ob, &amd->object);
 }
 
-static void updateDepgraph(
-						ModifierData *md, DagForest *forest, struct Scene *scene, Object *ob,
-	 DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	ArmatureModifierData *amd = (ArmatureModifierData*) md;
 
@@ -104,9 +115,12 @@ static void updateDepgraph(
 	}
 }
 
-static void deformVerts(
-					 ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	  float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	ArmatureModifierData *amd = (ArmatureModifierData*) md;
 
@@ -153,6 +167,19 @@ static void deformMatricesEM(
 	if(!derivedData) dm->release(dm);
 }
 
+static void deformMatrices(ModifierData *md, Object *ob, DerivedMesh *derivedData,
+						   float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
+{
+	ArmatureModifierData *amd = (ArmatureModifierData*) md;
+	DerivedMesh *dm = derivedData;
+
+	if(!derivedData) dm = CDDM_from_mesh((Mesh*)ob->data, ob);
+
+	armature_deform_verts(amd->object, ob, dm, vertexCos, defMats, numVerts,
+				  amd->deformflag, NULL, amd->defgrp_name);
+
+	if(!derivedData) dm->release(dm);
+}
 
 ModifierTypeInfo modifierType_Armature = {
 	/* name */              "Armature",
@@ -164,6 +191,7 @@ ModifierTypeInfo modifierType_Armature = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    deformMatrices,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  deformMatricesEM,
 	/* applyModifier */     0,
@@ -174,6 +202,7 @@ ModifierTypeInfo modifierType_Armature = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_array.c b/source/blender/modifiers/intern/MOD_array.c
index 98295ae0d8e..f5a276aeadc 100644
--- a/source/blender/modifiers/intern/MOD_array.c
+++ b/source/blender/modifiers/intern/MOD_array.c
@@ -37,6 +37,7 @@
 #include "BLI_math.h"
 #include "BLI_ghash.h"
 #include "BLI_edgehash.h"
+#include "BLI_utildefines.h"
 
 #include "DNA_curve_types.h"
 #include "DNA_meshdata_types.h"
@@ -51,6 +52,10 @@
 
 #include "depsgraph_private.h"
 
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
 static void initData(ModifierData *md)
 {
 	ArrayModifierData *amd = (ArrayModifierData*) md;
@@ -544,6 +549,7 @@ ModifierTypeInfo modifierType_Array = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */  0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
diff --git a/source/blender/modifiers/intern/MOD_bevel.c b/source/blender/modifiers/intern/MOD_bevel.c
index e37bf18a293..8d34fdcb10e 100644
--- a/source/blender/modifiers/intern/MOD_bevel.c
+++ b/source/blender/modifiers/intern/MOD_bevel.c
@@ -29,13 +29,22 @@
 * ***** END GPL LICENSE BLOCK *****
 *
 */
+
+/** \file blender/modifiers/intern/MOD_bevel.c
+ *  \ingroup modifiers
+ */
+
 #include "MEM_guardedalloc.h"
 
+#include "BLI_utildefines.h"
+
 #include "BKE_bmesh.h"
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
 #include "BKE_particle.h"
 
+#include "MOD_util.h"
+
 
 static void initData(ModifierData *md)
 {
@@ -66,20 +75,21 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strncpy(tbmd->defgrp_name, bmd->defgrp_name, 32);
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	BevelModifierData *bmd = (BevelModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(bmd->defgrp_name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(bmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
 
-static DerivedMesh *applyModifier(
-		ModifierData *md, Object *ob, DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 #if 0
 	DerivedMesh *result;
@@ -109,9 +119,9 @@ static DerivedMesh *applyModifier(
 	return CDDM_copy(derivedData, 0);
 }
 
-static DerivedMesh *applyModifierEM(
-		ModifierData *md, Object *ob, EditMesh *editData,
-  DerivedMesh *derivedData)
+static DerivedMesh *applyModifierEM(ModifierData *md, Object *ob,
+						EditMesh *UNUSED(editData),
+						DerivedMesh *derivedData)
 {
 	return applyModifier(md, ob, derivedData, 0, 1);
 }
@@ -128,6 +138,7 @@ ModifierTypeInfo modifierType_Bevel = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -138,6 +149,7 @@ ModifierTypeInfo modifierType_Bevel = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_boolean.c b/source/blender/modifiers/intern/MOD_boolean.c
index 4e8e3117b7e..d4be9d3d03a 100644
--- a/source/blender/modifiers/intern/MOD_boolean.c
+++ b/source/blender/modifiers/intern/MOD_boolean.c
@@ -30,14 +30,23 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_boolean.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_object_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
 
 #include "depsgraph_private.h"
 
 #include "MOD_boolean_util.h"
+#include "MOD_util.h"
 
 
 static void copyData(ModifierData *md, ModifierData *target)
@@ -49,7 +58,7 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tbmd->operation = bmd->operation;
 }
 
-static int isDisabled(ModifierData *md, int useRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
 {
 	BooleanModifierData *bmd = (BooleanModifierData*) md;
 
@@ -66,9 +75,10 @@ static void foreachObjectLink(
 	walk(userData, ob, &bmd->object);
 }
 
-static void updateDepgraph(
-					   ModifierData *md, DagForest *forest, struct Scene *scene, Object *ob,
-	DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	BooleanModifierData *bmd = (BooleanModifierData*) md;
 
@@ -80,10 +90,11 @@ static void updateDepgraph(
 	}
 }
 
-
-static DerivedMesh *applyModifier(
-		ModifierData *md, Object *ob, DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+#ifdef WITH_MOD_BOOLEAN
+static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	BooleanModifierData *bmd = (BooleanModifierData*) md;
 	DerivedMesh *dm = bmd->object->derivedFinal;
@@ -104,12 +115,21 @@ static DerivedMesh *applyModifier(
 	
 	return derivedData;
 }
+#else // WITH_MOD_BOOLEAN
+static DerivedMesh *applyModifier(ModifierData *UNUSED(md), Object *UNUSED(ob),
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
+{
+	return derivedData;
+}
+#endif // WITH_MOD_BOOLEAN
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
 {
-	CustomDataMask dataMask = (1 << CD_MTFACE) + (1 << CD_MEDGE);
+	CustomDataMask dataMask = CD_MASK_MTFACE | CD_MASK_MEDGE;
 
-	dataMask |= (1 << CD_MDEFORMVERT);
+	dataMask |= CD_MASK_MDEFORMVERT;
 	
 	return dataMask;
 }
@@ -125,6 +145,7 @@ ModifierTypeInfo modifierType_Boolean = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -135,6 +156,7 @@ ModifierTypeInfo modifierType_Boolean = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_boolean_util.c b/source/blender/modifiers/intern/MOD_boolean_util.c
index a0532f9db5c..cefad37ea26 100644
--- a/source/blender/modifiers/intern/MOD_boolean_util.c
+++ b/source/blender/modifiers/intern/MOD_boolean_util.c
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -28,6 +28,11 @@
  * CSG operations. 
  */
 
+/** \file blender/modifiers/intern/MOD_boolean_util.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_material_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
@@ -37,6 +42,7 @@
 #include "MEM_guardedalloc.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
 #include "BLI_ghash.h"
 
 #include "BKE_cdderivedmesh.h"
@@ -47,6 +53,8 @@
 
 #include "CSG_BooleanOps.h"
 
+#include "MOD_boolean_util.h"
+
 /**
  * Here's the vertex iterator structure used to walk through
  * the blender vertex structure.
@@ -454,7 +462,7 @@ static void FreeMeshDescriptors(
 	FaceIt_Destruct(face_it);
 }
 
-DerivedMesh *NewBooleanDerivedMesh_intern(
+static DerivedMesh *NewBooleanDerivedMesh_intern(
 	DerivedMesh *dm, struct Object *ob, DerivedMesh *dm_select, struct Object *ob_select,
 	int int_op_type, Material **mat, int *totmat)
 {
@@ -581,7 +589,7 @@ int NewBooleanMesh(Scene *scene, Base *base, Base *base_select, int int_op_type)
 	MEM_freeN(mat);
 
 	/* update dag */
-	DAG_id_flush_update(&ob_new->id, OB_RECALC_DATA);
+	DAG_id_tag_update(&ob_new->id, OB_RECALC_DATA);
 
 	return 1;
 }
diff --git a/source/blender/modifiers/intern/MOD_boolean_util.h b/source/blender/modifiers/intern/MOD_boolean_util.h
index e415b368a85..2a4191de407 100644
--- a/source/blender/modifiers/intern/MOD_boolean_util.h
+++ b/source/blender/modifiers/intern/MOD_boolean_util.h
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -27,6 +27,11 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/modifiers/intern/MOD_boolean_util.h
+ *  \ingroup modifiers
+ */
+
+
 #ifndef MOD_BOOLEAN_UTILS_H
 #define MOD_BOOLEAN_UTILS_H
 
diff --git a/source/blender/modifiers/intern/MOD_build.c b/source/blender/modifiers/intern/MOD_build.c
index e027cc1fccc..e2a54648623 100644
--- a/source/blender/modifiers/intern/MOD_build.c
+++ b/source/blender/modifiers/intern/MOD_build.c
@@ -30,8 +30,14 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_build.c
+ *  \ingroup modifiers
+ */
+
+
 #include "MEM_guardedalloc.h"
 
+#include "BLI_utildefines.h"
 #include "BLI_rand.h"
 #include "BLI_ghash.h"
 
@@ -45,6 +51,7 @@
 #include "BKE_particle.h"
 #include "BKE_scene.h"
 
+#include "MOD_util.h"
 
 static void initData(ModifierData *md)
 {
@@ -65,21 +72,21 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tbmd->seed = bmd->seed;
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 1;
 }
 
 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
-		DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm = derivedData;
 	DerivedMesh *result;
 	BuildModifierData *bmd = (BuildModifierData*) md;
 	int i;
 	int numFaces, numEdges;
-	int maxVerts, maxEdges, maxFaces;
 	int *vertMap, *edgeMap, *faceMap;
 	float frac;
 	GHashIterator *hashIter;
@@ -90,19 +97,15 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	GHash *edgeHash = BLI_ghash_new(BLI_ghashutil_inthash,
 					BLI_ghashutil_intcmp, "build ed apply gh");
 
-	maxVerts = dm->getNumVerts(dm);
-	vertMap = MEM_callocN(sizeof(*vertMap) * maxVerts,
-				  "build modifier vertMap");
-	for(i = 0; i < maxVerts; ++i) vertMap[i] = i;
+	const int maxVerts= dm->getNumVerts(dm);
+	const int maxEdges= dm->getNumEdges(dm);
+	const int maxFaces= dm->getNumTessFaces(dm);
 
-	maxEdges = dm->getNumEdges(dm);
-	edgeMap = MEM_callocN(sizeof(*edgeMap) * maxEdges,
-				  "build modifier edgeMap");
+	vertMap = MEM_callocN(sizeof(*vertMap) * maxVerts, "build modifier vertMap");
+	for(i = 0; i < maxVerts; ++i) vertMap[i] = i;
+	edgeMap = MEM_callocN(sizeof(*edgeMap) * maxEdges, "build modifier edgeMap");
 	for(i = 0; i < maxEdges; ++i) edgeMap[i] = i;
-
-	maxFaces = dm->getNumTessFaces(dm);
-	faceMap = MEM_callocN(sizeof(*faceMap) * maxFaces,
-				  "build modifier faceMap");
+	faceMap = MEM_callocN(sizeof(*faceMap) * maxFaces, "build modifier faceMap");
 	for(i = 0; i < maxFaces; ++i) faceMap[i] = i;
 
 	if (ob) {
@@ -118,8 +121,6 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 	/* if there's at least one face, build based on faces */
 	if(numFaces) {
-		int maxEdges;
-
 		if(bmd->randomize)
 			BLI_array_randomize(faceMap, sizeof(*faceMap),
 						maxFaces, bmd->seed);
@@ -148,7 +149,6 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		/* get the set of edges that will be in the new mesh (i.e. all edges
 		* that have both verts in the new mesh)
 		*/
-		maxEdges = dm->getNumEdges(dm);
 		for(i = 0; i < maxEdges; ++i) {
 			MEdge me;
 			dm->getEdge(dm, i, &me);
@@ -208,75 +208,72 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 					BLI_ghash_size(edgeHash), numFaces, 0, 0);
 
 	/* copy the vertices across */
-	for(hashIter = BLI_ghashIterator_new(vertHash);
-		   !BLI_ghashIterator_isDone(hashIter);
-		   BLI_ghashIterator_step(hashIter)) {
-			   MVert source;
-			   MVert *dest;
-			   int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
-			   int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
-
-			   dm->getVert(dm, oldIndex, &source);
-			   dest = CDDM_get_vert(result, newIndex);
-
-			   DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
-			   *dest = source;
-		   }
-		   BLI_ghashIterator_free(hashIter);
-
-		   /* copy the edges across, remapping indices */
-		   for(i = 0; i < BLI_ghash_size(edgeHash); ++i) {
-			   MEdge source;
-			   MEdge *dest;
-			   int oldIndex = GET_INT_FROM_POINTER(BLI_ghash_lookup(edgeHash, SET_INT_IN_POINTER(i)));
-
-			   dm->getEdge(dm, oldIndex, &source);
-			   dest = CDDM_get_edge(result, i);
-
-			   source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
-			   source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
-
-			   DM_copy_edge_data(dm, result, oldIndex, i, 1);
-			   *dest = source;
-		   }
-
-		   /* copy the faces across, remapping indices */
-		   for(i = 0; i < numFaces; ++i) {
-			   MFace source;
-			   MFace *dest;
-			   int orig_v4;
-
-			   dm->getTessFace(dm, faceMap[i], &source);
-			   dest = CDDM_get_tessface(result, i);
-
-			   orig_v4 = source.v4;
-
-			   source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
-			   source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
-			   source.v3 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v3)));
-			   if(source.v4)
-				   source.v4 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v4)));
-
-			   DM_copy_face_data(dm, result, faceMap[i], i, 1);
-			   *dest = source;
-
-			   test_index_face(dest, &result->faceData, i, (orig_v4 ? 4 : 3));
-		   }
-
-		   CDDM_calc_normals(result);
-
-		   BLI_ghash_free(vertHash, NULL, NULL);
-		   BLI_ghash_free(edgeHash, NULL, NULL);
-
-		   MEM_freeN(vertMap);
-		   MEM_freeN(edgeMap);
-		   MEM_freeN(faceMap);
+	for(	hashIter = BLI_ghashIterator_new(vertHash);
+			!BLI_ghashIterator_isDone(hashIter);
+			BLI_ghashIterator_step(hashIter)
+	) {
+	   MVert source;
+	   MVert *dest;
+	   int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
+	   int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
+
+	   dm->getVert(dm, oldIndex, &source);
+	   dest = CDDM_get_vert(result, newIndex);
+
+	   DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
+	   *dest = source;
+   }
+	BLI_ghashIterator_free(hashIter);
+	
+	/* copy the edges across, remapping indices */
+	for(i = 0; i < BLI_ghash_size(edgeHash); ++i) {
+		MEdge source;
+		MEdge *dest;
+		int oldIndex = GET_INT_FROM_POINTER(BLI_ghash_lookup(edgeHash, SET_INT_IN_POINTER(i)));
+		
+		dm->getEdge(dm, oldIndex, &source);
+		dest = CDDM_get_edge(result, i);
+		
+		source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
+		source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
+		
+		DM_copy_edge_data(dm, result, oldIndex, i, 1);
+		*dest = source;
+	}
 
-		   dm = CDDM_copy(result, 1); /*builds ngon faces from tess (mface) faces*/
-		   result->needsFree = 1;
-		   result->release(result);
+	/* copy the faces across, remapping indices */
+	for(i = 0; i < numFaces; ++i) {
+		MFace source;
+		MFace *dest;
+		int orig_v4;
+		
+		dm->getTessFace(dm, faceMap[i], &source);
+		dest = CDDM_get_tessface(result, i);
+		
+		orig_v4 = source.v4;
+		
+		source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
+		source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
+		source.v3 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v3)));
+		if(source.v4)
+			source.v4 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v4)));
+		
+		DM_copy_face_data(dm, result, faceMap[i], i, 1);
+		*dest = source;
+		
+		test_index_face(dest, &result->faceData, i, (orig_v4 ? 4 : 3));
+	}
 
-		   return dm;
+	CDDM_calc_normals(result);
+	
+	BLI_ghash_free(vertHash, NULL, NULL);
+	BLI_ghash_free(edgeHash, NULL, NULL);
+	
+	MEM_freeN(vertMap);
+	MEM_freeN(edgeMap);
+	MEM_freeN(faceMap);
+	
+	return result;
 }
 
 
@@ -288,17 +285,19 @@ ModifierTypeInfo modifierType_Build = {
 	/* flags */             eModifierTypeFlag_AcceptsMesh
 							| eModifierTypeFlag_AcceptsCVs,
 	/* copyData */          copyData,
-	/* deformVerts */       0,
-	/* deformVertsEM */     0,
-	/* deformMatricesEM */  0,
+	/* deformVerts */       NULL,
+	/* deformMatrices */    NULL,
+	/* deformVertsEM */     NULL,
+	/* deformMatricesEM */  NULL,
 	/* applyModifier */     applyModifier,
-	/* applyModifierEM */   0,
+	/* applyModifierEM */   NULL,
 	/* initData */          initData,
-	/* requiredDataMask */  0,
-	/* freeData */          0,
-	/* isDisabled */        0,
-	/* updateDepgraph */    0,
+	/* requiredDataMask */  NULL,
+	/* freeData */          NULL,
+	/* isDisabled */        NULL,
+	/* updateDepgraph */    NULL,
 	/* dependsOnTime */     dependsOnTime,
-	/* foreachObjectLink */ 0,
-	/* foreachIDLink */     0,
+	/* dependsOnNormals */	NULL,
+	/* foreachObjectLink */ NULL,
+	/* foreachIDLink */     NULL
 };
diff --git a/source/blender/modifiers/intern/MOD_cast.c b/source/blender/modifiers/intern/MOD_cast.c
index 10843cf9677..68e9e173ee6 100644
--- a/source/blender/modifiers/intern/MOD_cast.c
+++ b/source/blender/modifiers/intern/MOD_cast.c
@@ -30,15 +30,22 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_cast.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
+
 
 #include "BKE_deform.h"
 #include "BKE_DerivedMesh.h"
 #include "BKE_modifier.h"
-#include "BKE_utildefines.h"
+
 
 #include "depsgraph_private.h"
 
@@ -73,7 +80,7 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strncpy(tcmd->defgrp_name, cmd->defgrp_name, 32);
 }
 
-static int isDisabled(ModifierData *md, int useRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
 {
 	CastModifierData *cmd = (CastModifierData*) md;
 	short flag;
@@ -85,13 +92,13 @@ static int isDisabled(ModifierData *md, int useRenderParams)
 	return 0;
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	CastModifierData *cmd = (CastModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(cmd->defgrp_name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(cmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
@@ -106,9 +113,10 @@ static void foreachObjectLink(
 	walk (userData, ob, &cmd->object);
 }
 
-static void updateDepgraph(
-					ModifierData *md, DagForest *forest, struct Scene *scene, Object *ob,
-	 DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	CastModifierData *cmd = (CastModifierData*) md;
 
@@ -566,14 +574,17 @@ static void cuboid_do(
 	}
 }
 
-static void deformVerts(
-					 ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	 float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm = NULL;
 	CastModifierData *cmd = (CastModifierData *)md;
 
-	dm = get_dm(md->scene, ob, NULL, derivedData, NULL, 0);
+	dm = get_dm(ob, NULL, derivedData, NULL, 0);
 
 	if (cmd->type == MOD_CAST_TYPE_CUBOID) {
 		cuboid_do(cmd, ob, dm, vertexCos, numVerts);
@@ -589,7 +600,7 @@ static void deformVertsEM(
 					   ModifierData *md, Object *ob, struct EditMesh *editData,
 	   DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
 {
-	DerivedMesh *dm = get_dm(md->scene, ob, editData, derivedData, NULL, 0);
+	DerivedMesh *dm = get_dm(ob, editData, derivedData, NULL, 0);
 	CastModifierData *cmd = (CastModifierData *)md;
 
 	if (cmd->type == MOD_CAST_TYPE_CUBOID) {
@@ -613,6 +624,7 @@ ModifierTypeInfo modifierType_Cast = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -623,6 +635,7 @@ ModifierTypeInfo modifierType_Cast = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_cloth.c b/source/blender/modifiers/intern/MOD_cloth.c
index bfb5f6ee028..999349dca7f 100644
--- a/source/blender/modifiers/intern/MOD_cloth.c
+++ b/source/blender/modifiers/intern/MOD_cloth.c
@@ -30,12 +30,20 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_cloth.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_cloth_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_object_types.h"
 
 #include "MEM_guardedalloc.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cloth.h"
 #include "BKE_cdderivedmesh.h"
 #include "BKE_global.h"
@@ -44,6 +52,7 @@
 
 #include "depsgraph_private.h"
 
+#include "MOD_util.h"
 
 static void initData(ModifierData *md) 
 {
@@ -61,7 +70,9 @@ static void initData(ModifierData *md)
 }
 
 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
-		DerivedMesh *derivedData, int useRenderParams, int isFinalCalc)
+						DerivedMesh *dm,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	ClothModifierData *clmd = (ClothModifierData*) md;
 	DerivedMesh *result=NULL;
@@ -72,17 +83,17 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		initData(md);
 		
 		if(!clmd->sim_parms || !clmd->coll_parms)
-			return derivedData;
+			return dm;
 	}
 
-	result = clothModifier_do(clmd, md->scene, ob, derivedData, useRenderParams, isFinalCalc);
+	result = clothModifier_do(clmd, md->scene, ob, dm);
 
 	if(result)
 	{
 		CDDM_calc_normals(result);
 		return result;
 	}
-	return derivedData;
+	return dm;
 }
 
 static void updateDepgraph(
@@ -111,16 +122,16 @@ static void updateDepgraph(
 	}
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	CustomDataMask dataMask = 0;
 	ClothModifierData *clmd = (ClothModifierData*)md;
 
 	if(cloth_uses_vgroup(clmd))
-		dataMask |= (1 << CD_MDEFORMVERT);
+		dataMask |= CD_MASK_MDEFORMVERT;
 
 	if(clmd->sim_parms->shapekey_rest != 0)
-		dataMask |= (1 << CD_CLOTH_ORCO);
+		dataMask |= CD_MASK_CLOTH_ORCO;
 
 	return dataMask;
 }
@@ -150,7 +161,7 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tclmd->clothObject = NULL;
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 1;
 }
@@ -191,6 +202,7 @@ ModifierTypeInfo modifierType_Cloth = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -201,6 +213,7 @@ ModifierTypeInfo modifierType_Cloth = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_collision.c b/source/blender/modifiers/intern/MOD_collision.c
index fd43e057144..07b35cdf334 100644
--- a/source/blender/modifiers/intern/MOD_collision.c
+++ b/source/blender/modifiers/intern/MOD_collision.c
@@ -30,6 +30,11 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_collision.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_scene_types.h"
 #include "DNA_object_types.h"
 #include "DNA_meshdata_types.h"
@@ -37,6 +42,8 @@
 #include "MEM_guardedalloc.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
+
 
 #include "BKE_collision.h"
 #include "BKE_cdderivedmesh.h"
@@ -46,6 +53,7 @@
 #include "BKE_pointcache.h"
 #include "BKE_scene.h"
 
+#include "MOD_util.h"
 
 static void initData(ModifierData *md) 
 {
@@ -94,19 +102,20 @@ static void freeData(ModifierData *md)
 	}
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 1;
 }
 
-static void deformVerts(
-					  ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	   float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int UNUSED(numVerts),
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	CollisionModifierData *collmd = (CollisionModifierData*) md;
 	DerivedMesh *dm = NULL;
-	float current_time = 0;
-	unsigned int numverts = 0, i = 0;
 	MVert *tempVert = NULL;
 	
 	/* if possible use/create DerivedMesh */
@@ -121,6 +130,9 @@ static void deformVerts(
 	
 	if(dm)
 	{
+		float current_time = 0;
+		unsigned int numverts = 0;
+
 		CDDM_apply_vert_coords(dm, vertexCos);
 		CDDM_calc_normals(dm);
 		
@@ -132,7 +144,9 @@ static void deformVerts(
 		numverts = dm->getNumVerts ( dm );
 		
 		if((current_time > collmd->time)|| (BKE_ptcache_get_continue_physics()))
-		{	
+		{
+			unsigned int i;
+
 			// check if mesh has changed
 			if(collmd->x && (numverts != collmd->numverts))
 				freeData((ModifierData *)collmd);
@@ -238,6 +252,7 @@ ModifierTypeInfo modifierType_Collision = {
 
 	/* copyData */          0,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -248,6 +263,7 @@ ModifierTypeInfo modifierType_Collision = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_curve.c b/source/blender/modifiers/intern/MOD_curve.c
index 97c7a4b01d6..84fee7b5102 100644
--- a/source/blender/modifiers/intern/MOD_curve.c
+++ b/source/blender/modifiers/intern/MOD_curve.c
@@ -30,17 +30,26 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_curve.c
+ *  \ingroup modifiers
+ */
+
+
 #include <string.h>
 
 #include "DNA_scene_types.h"
 #include "DNA_object_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_lattice.h"
 #include "BKE_modifier.h"
 
 #include "depsgraph_private.h"
 
+#include "MOD_util.h"
 
 static void initData(ModifierData *md)
 {
@@ -59,18 +68,18 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strncpy(tcmd->name, cmd->name, 32);
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	CurveModifierData *cmd = (CurveModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(cmd->name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(cmd->name[0]) dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
 
-static int isDisabled(ModifierData *md, int userRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(userRenderParams))
 {
 	CurveModifierData *cmd = (CurveModifierData*) md;
 
@@ -87,9 +96,10 @@ static void foreachObjectLink(
 	walk(userData, ob, &cmd->object);
 }
 
-static void updateDepgraph(
-					 ModifierData *md, DagForest *forest, Scene *scene,
-	  Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	CurveModifierData *cmd = (CurveModifierData*) md;
 
@@ -101,9 +111,12 @@ static void updateDepgraph(
 	}
 }
 
-static void deformVerts(
-					  ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	  float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	CurveModifierData *cmd = (CurveModifierData*) md;
 
@@ -135,6 +148,7 @@ ModifierTypeInfo modifierType_Curve = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -145,6 +159,7 @@ ModifierTypeInfo modifierType_Curve = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_decimate.c b/source/blender/modifiers/intern/MOD_decimate.c
index f75fc0dd1f4..4eae988f92f 100644
--- a/source/blender/modifiers/intern/MOD_decimate.c
+++ b/source/blender/modifiers/intern/MOD_decimate.c
@@ -30,9 +30,16 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_decimate.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_meshdata_types.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
+
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_mesh.h"
@@ -41,8 +48,11 @@
 
 #include "MEM_guardedalloc.h"
 
+#ifdef WITH_MOD_DECIMATE
 #include "LOD_decimation.h"
+#endif
 
+#include "MOD_util.h"
 
 static void initData(ModifierData *md)
 {
@@ -59,9 +69,11 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tdmd->percent = dmd->percent;
 }
 
-static DerivedMesh *applyModifier(
-		ModifierData *md, Object *ob, DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+#ifdef WITH_MOD_DECIMATE
+static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DecimateModifierData *dmd = (DecimateModifierData*) md;
 	DerivedMesh *dm = derivedData, *result = NULL;
@@ -179,7 +191,15 @@ exit:
 
 	return dm;
 }
-
+#else // WITH_MOD_DECIMATE
+static DerivedMesh *applyModifier(ModifierData *UNUSED(md), Object *UNUSED(ob),
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
+{
+	return derivedData;
+}
+#endif // WITH_MOD_DECIMATE
 
 ModifierTypeInfo modifierType_Decimate = {
 	/* name */              "Decimate",
@@ -189,6 +209,7 @@ ModifierTypeInfo modifierType_Decimate = {
 	/* flags */             eModifierTypeFlag_AcceptsMesh,
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -199,6 +220,7 @@ ModifierTypeInfo modifierType_Decimate = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_displace.c b/source/blender/modifiers/intern/MOD_displace.c
index 6dbe3d3622c..6ae5c14d5ef 100644
--- a/source/blender/modifiers/intern/MOD_displace.c
+++ b/source/blender/modifiers/intern/MOD_displace.c
@@ -30,10 +30,17 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_displace.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
+
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
@@ -75,16 +82,16 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strncpy(tdmd->uvlayer_name, dmd->uvlayer_name, 32);
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	DisplaceModifierData *dmd = (DisplaceModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(dmd->defgrp_name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(dmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
 
 	/* ask for UV coordinates if we need them */
-	if(dmd->texmapping == MOD_DISP_MAP_UV) dataMask |= (1 << CD_MTFACE);
+	if(dmd->texmapping == MOD_DISP_MAP_UV) dataMask |= CD_MASK_MTFACE;
 
 	return dataMask;
 }
@@ -103,6 +110,12 @@ static int dependsOnTime(ModifierData *md)
 	}
 }
 
+static int dependsOnNormals(ModifierData *md)
+{
+	DisplaceModifierData *dmd = (DisplaceModifierData *)md;
+	return (dmd->direction == MOD_DISP_DIR_NOR);
+}
+
 static void foreachObjectLink(ModifierData *md, Object *ob,
 						   ObjectWalkFunc walk, void *userData)
 {
@@ -121,25 +134,32 @@ static void foreachIDLink(ModifierData *md, Object *ob,
 	foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
 
-static int isDisabled(ModifierData *md, int useRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
 {
 	DisplaceModifierData *dmd = (DisplaceModifierData*) md;
 
 	return (!dmd->texture || dmd->strength == 0.0f);
 }
 
-static void updateDepgraph(
-						ModifierData *md, DagForest *forest, struct Scene *scene,
-	 Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	DisplaceModifierData *dmd = (DisplaceModifierData*) md;
 
-	if(dmd->map_object) {
+	if(dmd->map_object && dmd->texmapping == MOD_DISP_MAP_OBJECT) {
 		DagNode *curNode = dag_get_node(forest, dmd->map_object);
 
 		dag_add_relation(forest, curNode, obNode,
 				 DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Displace Modifier");
 	}
+	
+
+	if(dmd->texmapping == MOD_DISP_MAP_GLOBAL)
+		dag_add_relation(forest, obNode, obNode,
+						 DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Displace Modifier");
+	
 }
 
 static void get_texture_coords(DisplaceModifierData *dmd, Object *ob,
@@ -302,11 +322,14 @@ static void displaceModifier_do(
 	MEM_freeN(tex_co);
 }
 
-static void deformVerts(
-					 ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	  float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
-	DerivedMesh *dm= get_cddm(md->scene, ob, NULL, derivedData, vertexCos);
+	DerivedMesh *dm= get_cddm(ob, NULL, derivedData, vertexCos);
 
 	displaceModifier_do((DisplaceModifierData *)md, ob, dm,
 				 vertexCos, numVerts);
@@ -319,7 +342,7 @@ static void deformVertsEM(
 					   ModifierData *md, Object *ob, struct EditMesh *editData,
 	DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
 {
-	DerivedMesh *dm= get_cddm(md->scene, ob, editData, derivedData, vertexCos);
+	DerivedMesh *dm= get_cddm(ob, editData, derivedData, vertexCos);
 
 	displaceModifier_do((DisplaceModifierData *)md, ob, dm,
 				 vertexCos, numVerts);
@@ -339,6 +362,7 @@ ModifierTypeInfo modifierType_Displace = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -349,6 +373,7 @@ ModifierTypeInfo modifierType_Displace = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	dependsOnNormals,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     foreachIDLink,
 };
diff --git a/source/blender/modifiers/intern/MOD_edgesplit.c b/source/blender/modifiers/intern/MOD_edgesplit.c
index 9d622669c78..4549448f45e 100644
--- a/source/blender/modifiers/intern/MOD_edgesplit.c
+++ b/source/blender/modifiers/intern/MOD_edgesplit.c
@@ -36,11 +36,13 @@
 #include "BLI_edgehash.h"
 #include "BLI_math.h"
 #include "BLI_array.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
 #include "BKE_particle.h"
 #include "BKE_tessmesh.h"
+#include "BKE_mesh.h"
 
 #include "MEM_guardedalloc.h"
 
@@ -446,6 +448,7 @@ ModifierTypeInfo modifierType_EdgeSplit = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */  0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
diff --git a/source/blender/modifiers/intern/MOD_explode.c b/source/blender/modifiers/intern/MOD_explode.c
index ec4137c2654..04687958efd 100644
--- a/source/blender/modifiers/intern/MOD_explode.c
+++ b/source/blender/modifiers/intern/MOD_explode.c
@@ -30,6 +30,11 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_explode.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_meshdata_types.h"
 #include "DNA_scene_types.h"
 
@@ -37,6 +42,7 @@
 #include "BLI_rand.h"
 #include "BLI_math.h"
 #include "BLI_edgehash.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_deform.h"
@@ -46,10 +52,11 @@
 #include "BKE_object.h"
 #include "BKE_particle.h"
 #include "BKE_scene.h"
-#include "BKE_utildefines.h"
+
 
 #include "MEM_guardedalloc.h"
 
+#include "MOD_util.h"
 
 static void initData(ModifierData *md)
 {
@@ -74,24 +81,24 @@ static void copyData(ModifierData *md, ModifierData *target)
 	temd->protect = emd->protect;
 	temd->vgroup = emd->vgroup;
 }
-static int dependsOnTime(ModifierData *md) 
+static int dependsOnTime(ModifierData *UNUSED(md)) 
 {
 	return 1;
 }
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	ExplodeModifierData *emd= (ExplodeModifierData*) md;
 	CustomDataMask dataMask = 0;
 
 	if(emd->vgroup)
-		dataMask |= (1 << CD_MDEFORMVERT);
+		dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
 
 static void createFacepa(ExplodeModifierData *emd,
-					 ParticleSystemModifierData *psmd,
-	  Object *ob, DerivedMesh *dm)
+						ParticleSystemModifierData *psmd,
+						DerivedMesh *dm)
 {
 	ParticleSystem *psys=psmd->psys;
 	MFace *fa=0, *mface=0;
@@ -127,11 +134,10 @@ static void createFacepa(ExplodeModifierData *emd,
 	/* set protected verts */
 	if(emd->vgroup){
 		MDeformVert *dvert = dm->getVertDataArray(dm, CD_MDEFORMVERT);
-		float val;
 		if(dvert){
-			int defgrp_index= emd->vgroup-1;
+			const int defgrp_index= emd->vgroup-1;
 			for(i=0; i<totvert; i++, dvert++){
-				val = BLI_frand();
+				float val = BLI_frand();
 				val = (1.0f-emd->protect)*val + emd->protect*0.5f;
 				if(val < defvert_find_weight(dvert, defgrp_index))
 					vertpa[i] = -1;
@@ -179,15 +185,369 @@ static void createFacepa(ExplodeModifierData *emd,
 	BLI_kdtree_free(tree);
 }
 
-static int edgesplit_get(EdgeHash *edgehash, int v1, int v2)
+static int edgecut_get(EdgeHash *edgehash, int v1, int v2)
 {
 	return GET_INT_FROM_POINTER(BLI_edgehash_lookup(edgehash, v1, v2));
 }
 
-static DerivedMesh * splitEdges(ExplodeModifierData *emd, DerivedMesh *dm){
+ 
+const short add_faces[24] = {
+	0,
+	0, 0, 2, 0, 1, 2, 2, 0, 2, 1,
+	2, 2, 2, 2, 3, 0, 0, 0, 1, 0,
+	1, 1, 2
+ };
+
+MFace *get_dface(DerivedMesh *dm, DerivedMesh *split, int cur, int i, MFace *mf)
+{
+	MFace *df = CDDM_get_tessface(split, cur);
+	DM_copy_face_data(dm, split, i, cur, 1);
+	*df = *mf;
+	return df;
+}
+
+#define SET_VERTS(a, b, c, d) \
+			v[0]=mf->v##a; uv[0]=a-1; \
+			v[1]=mf->v##b; uv[1]=b-1; \
+			v[2]=mf->v##c; uv[2]=c-1; \
+			v[3]=mf->v##d; uv[3]=d-1;
+
+#define GET_ES(v1, v2) edgecut_get(eh, v1, v2);
+#define INT_UV(uvf, c0, c1) interp_v2_v2v2(uvf, mf->uv[c0], mf->uv[c1], 0.5f);
+
+static void remap_faces_3_6_9_12(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3, int v4)
+{
+	MFace *df1 = get_dface(dm, split, cur, i, mf);
+	MFace *df2 = get_dface(dm, split, cur+1, i, mf);
+	MFace *df3 = get_dface(dm, split, cur+2, i, mf);
+
+	facepa[cur] = vertpa[v1];
+	df1->v1 = v1;
+	df1->v2 = GET_ES(v1, v2)
+	df1->v3 = GET_ES(v2, v3)
+	df1->v4 = v3;
+	df1->flag |= ME_FACE_SEL;
+
+	facepa[cur+1] = vertpa[v2];
+	df2->v1 = GET_ES(v1, v2)
+	df2->v2 = v2;
+	df2->v3 = GET_ES(v2, v3)
+	df2->v4 = 0;
+	df2->flag &= ~ME_FACE_SEL;
+
+	facepa[cur+2] = vertpa[v1];
+	df3->v1 = v1;
+	df3->v2 = v3;
+	df3->v3 = v4;
+	df3->v4 = 0;
+	df3->flag &= ~ME_FACE_SEL;
+}
+
+static void remap_uvs_3_6_9_12(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2, int c3)
+{
+	MTFace *mf, *df1, *df2, *df3;
+	int l;
+
+	for(l=0; l<numlayer; l++) {
+		mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
+		df1 = mf+cur;
+		df2 = df1 + 1;
+		df3 = df1 + 2;
+		mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
+		mf += i;
+
+		copy_v2_v2(df1->uv[0], mf->uv[c0]);
+		INT_UV(df1->uv[1], c0, c1)
+		INT_UV(df1->uv[2], c1, c2)
+		copy_v2_v2(df1->uv[3], mf->uv[c2]);
+
+		INT_UV(df2->uv[0], c0, c1)
+		copy_v2_v2(df2->uv[1], mf->uv[c1]);
+		INT_UV(df2->uv[2], c1, c2)
+
+		copy_v2_v2(df3->uv[0], mf->uv[c0]);
+		copy_v2_v2(df3->uv[1], mf->uv[c2]);
+		copy_v2_v2(df3->uv[2], mf->uv[c3]);
+	}
+}
+
+static void remap_faces_5_10(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3, int v4)
+{
+	MFace *df1 = get_dface(dm, split, cur, i, mf);
+	MFace *df2 = get_dface(dm, split, cur+1, i, mf);
+
+	facepa[cur] = vertpa[v1];
+	df1->v1 = v1;
+	df1->v2 = v2;
+	df1->v3 = GET_ES(v2, v3)
+	df1->v4 = GET_ES(v1, v4)
+	df1->flag |= ME_FACE_SEL;
+
+	facepa[cur+1] = vertpa[v3];
+	df2->v1 = GET_ES(v1, v4)
+	df2->v2 = GET_ES(v2, v3)
+	df2->v3 = v3;
+	df2->v4 = v4;
+	df2->flag |= ME_FACE_SEL;
+}
+
+static void remap_uvs_5_10(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2, int c3)
+{
+	MTFace *mf, *df1, *df2;
+	int l;
+
+	for(l=0; l<numlayer; l++) {
+		mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
+		df1 = mf+cur;
+		df2 = df1 + 1;
+		mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
+		mf += i;
+
+		copy_v2_v2(df1->uv[0], mf->uv[c0]);
+		copy_v2_v2(df1->uv[1], mf->uv[c1]);
+		INT_UV(df1->uv[2], c1, c2)
+		INT_UV(df1->uv[3], c0, c3)
+
+		INT_UV(df2->uv[0], c0, c3)
+		INT_UV(df2->uv[1], c1, c2)
+		copy_v2_v2(df2->uv[2], mf->uv[c2]);
+		copy_v2_v2(df2->uv[3], mf->uv[c3]);
+
+	}
+}
+
+static void remap_faces_15(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3, int v4)
+{
+	MFace *df1 = get_dface(dm, split, cur, i, mf);
+	MFace *df2 = get_dface(dm, split, cur+1, i, mf);
+	MFace *df3 = get_dface(dm, split, cur+2, i, mf);
+	MFace *df4 = get_dface(dm, split, cur+3, i, mf);
+
+	facepa[cur] = vertpa[v1];
+	df1->v1 = v1;
+	df1->v2 = GET_ES(v1, v2)
+	df1->v3 = GET_ES(v1, v3)
+	df1->v4 = GET_ES(v1, v4)
+	df1->flag |= ME_FACE_SEL;
+
+	facepa[cur+1] = vertpa[v2];
+	df2->v1 = GET_ES(v1, v2)
+	df2->v2 = v2;
+	df2->v3 = GET_ES(v2, v3)
+	df2->v4 = GET_ES(v1, v3)
+	df2->flag |= ME_FACE_SEL;
+
+	facepa[cur+2] = vertpa[v3];
+	df3->v1 = GET_ES(v1, v3)
+	df3->v2 = GET_ES(v2, v3)
+	df3->v3 = v3;
+	df3->v4 = GET_ES(v3, v4)
+	df3->flag |= ME_FACE_SEL;
+
+	facepa[cur+3] = vertpa[v4];
+	df4->v1 = GET_ES(v1, v4)
+	df4->v2 = GET_ES(v1, v3)
+	df4->v3 = GET_ES(v3, v4)
+	df4->v4 = v4;
+	df4->flag |= ME_FACE_SEL;
+}
+
+static void remap_uvs_15(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2, int c3)
+{
+	MTFace *mf, *df1, *df2, *df3, *df4;
+	int l;
+
+	for(l=0; l<numlayer; l++) {
+		mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
+		df1 = mf+cur;
+		df2 = df1 + 1;
+		df3 = df1 + 2;
+		df4 = df1 + 3;
+		mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
+		mf += i;
+
+		copy_v2_v2(df1->uv[0], mf->uv[c0]);
+		INT_UV(df1->uv[1], c0, c1)
+		INT_UV(df1->uv[2], c0, c2)
+		INT_UV(df1->uv[3], c0, c3)
+
+		INT_UV(df2->uv[0], c0, c1)
+		copy_v2_v2(df2->uv[1], mf->uv[c1]);
+		INT_UV(df2->uv[2], c1, c2)
+		INT_UV(df2->uv[3], c0, c2)
+
+		INT_UV(df3->uv[0], c0, c2)
+		INT_UV(df3->uv[1], c1, c2)
+		copy_v2_v2(df3->uv[2], mf->uv[c2]);
+		INT_UV(df3->uv[3], c2, c3)
+
+		INT_UV(df4->uv[0], c0, c3)
+		INT_UV(df4->uv[1], c0, c2)
+		INT_UV(df4->uv[2], c2, c3)
+		copy_v2_v2(df4->uv[3], mf->uv[c3]);
+	}
+}
+
+static void remap_faces_7_11_13_14(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3, int v4)
+{
+	MFace *df1 = get_dface(dm, split, cur, i, mf);
+	MFace *df2 = get_dface(dm, split, cur+1, i, mf);
+	MFace *df3 = get_dface(dm, split, cur+2, i, mf);
+
+	facepa[cur] = vertpa[v1];
+	df1->v1 = v1;
+	df1->v2 = GET_ES(v1, v2)
+	df1->v3 = GET_ES(v2, v3)
+	df1->v4 = GET_ES(v1, v4)
+	df1->flag |= ME_FACE_SEL;
+
+	facepa[cur+1] = vertpa[v2];
+	df2->v1 = GET_ES(v1, v2)
+	df2->v2 = v2;
+	df2->v3 = GET_ES(v2, v3)
+	df2->v4 = 0;
+	df2->flag &= ~ME_FACE_SEL;
+
+	facepa[cur+2] = vertpa[v4];
+	df3->v1 = GET_ES(v1, v4)
+	df3->v2 = GET_ES(v2, v3)
+	df3->v3 = v3;
+	df3->v4 = v4;
+	df3->flag |= ME_FACE_SEL;
+}
+
+static void remap_uvs_7_11_13_14(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2, int c3)
+{
+	MTFace *mf, *df1, *df2, *df3;
+	int l;
+
+	for(l=0; l<numlayer; l++) {
+		mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
+		df1 = mf+cur;
+		df2 = df1 + 1;
+		df3 = df1 + 2;
+		mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
+		mf += i;
+
+		copy_v2_v2(df1->uv[0], mf->uv[c0]);
+		INT_UV(df1->uv[1], c0, c1)
+		INT_UV(df1->uv[2], c1, c2)
+		INT_UV(df1->uv[3], c0, c3)
+
+		INT_UV(df2->uv[0], c0, c1)
+		copy_v2_v2(df2->uv[1], mf->uv[c1]);
+		INT_UV(df2->uv[2], c1, c2)
+
+		INT_UV(df3->uv[0], c0, c3)
+		INT_UV(df3->uv[1], c1, c2)
+		copy_v2_v2(df3->uv[2], mf->uv[c2]);
+		copy_v2_v2(df3->uv[3], mf->uv[c3]);
+	}
+}
+
+static void remap_faces_19_21_22(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3)
+{
+	MFace *df1 = get_dface(dm, split, cur, i, mf);
+	MFace *df2 = get_dface(dm, split, cur+1, i, mf);
+
+	facepa[cur] = vertpa[v1];
+	df1->v1 = v1;
+	df1->v2 = GET_ES(v1, v2)
+	df1->v3 = GET_ES(v1, v3)
+	df1->v4 = 0;
+	df1->flag &= ~ME_FACE_SEL;
+
+	facepa[cur+1] = vertpa[v2];
+	df2->v1 = GET_ES(v1, v2)
+	df2->v2 = v2;
+	df2->v3 = v3;
+	df2->v4 = GET_ES(v1, v3)
+	df2->flag |= ME_FACE_SEL;
+}
+
+static void remap_uvs_19_21_22(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2)
+{
+	MTFace *mf, *df1, *df2;
+	int l;
+
+	for(l=0; l<numlayer; l++) {
+		mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
+		df1 = mf+cur;
+		df2 = df1 + 1;
+		mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
+		mf += i;
+
+		copy_v2_v2(df1->uv[0], mf->uv[c0]);
+		INT_UV(df1->uv[1], c0, c1)
+		INT_UV(df1->uv[2], c0, c2)
+
+		INT_UV(df2->uv[0], c0, c1)
+		copy_v2_v2(df2->uv[1], mf->uv[c1]);
+		copy_v2_v2(df2->uv[2], mf->uv[c2]);
+		INT_UV(df2->uv[3], c0, c2)
+	}
+}
+
+static void remap_faces_23(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3)
+{
+	MFace *df1 = get_dface(dm, split, cur, i, mf);
+	MFace *df2 = get_dface(dm, split, cur+1, i, mf);
+	MFace *df3 = get_dface(dm, split, cur+2, i, mf);
+
+	facepa[cur] = vertpa[v1];
+	df1->v1 = v1;
+	df1->v2 = GET_ES(v1, v2)
+	df1->v3 = GET_ES(v2, v3)
+	df1->v4 = GET_ES(v1, v3)
+	df1->flag |= ME_FACE_SEL;
+
+	facepa[cur+1] = vertpa[v2];
+	df2->v1 = GET_ES(v1, v2)
+	df2->v2 = v2;
+	df2->v3 = GET_ES(v2, v3)
+	df2->v4 = 0;
+	df2->flag &= ~ME_FACE_SEL;
+
+	facepa[cur+2] = vertpa[v3];
+	df3->v1 = GET_ES(v1, v3)
+	df3->v2 = GET_ES(v2, v3)
+	df3->v3 = v3;
+	df3->v4 = 0;
+	df3->flag &= ~ME_FACE_SEL;
+}
+
+static void remap_uvs_23(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2)
+{
+	MTFace *mf, *df1, *df2, *df3;
+	int l;
+
+	for(l=0; l<numlayer; l++) {
+		mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
+		df1 = mf+cur;
+		df2 = df1 + 1;
+		df3 = df1 + 2;
+		mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
+		mf += i;
+
+		copy_v2_v2(df1->uv[0], mf->uv[c0]);
+		INT_UV(df1->uv[1], c0, c1)
+		INT_UV(df1->uv[2], c1, c2)
+		INT_UV(df1->uv[3], c0, c2)
+
+		INT_UV(df2->uv[0], c0, c1)
+		copy_v2_v2(df2->uv[1], mf->uv[c1]);
+		INT_UV(df2->uv[2], c1, c2)
+
+		INT_UV(df2->uv[0], c0, c2)
+		INT_UV(df2->uv[1], c1, c2)
+		copy_v2_v2(df2->uv[2], mf->uv[c2]);
+	}
+}
+
+static DerivedMesh * cutEdges(ExplodeModifierData *emd, DerivedMesh *dm){
 	DerivedMesh *splitdm;
-	MFace *mf=0,*df1=0,*df2=0,*df3=0;
-	MFace *mface=CDDM_get_tessfaces(dm);
+	MFace *mf=NULL,*df1=NULL;
+	MFace *mface=dm->getTessFaceArray(dm);
 	MVert *dupve, *mv;
 	EdgeHash *edgehash;
 	EdgeHashIterator *ehi;
@@ -197,8 +557,9 @@ static DerivedMesh * splitEdges(ExplodeModifierData *emd, DerivedMesh *dm){
 	int *facesplit = MEM_callocN(sizeof(int)*totface,"explode_facesplit");
 	int *vertpa = MEM_callocN(sizeof(int)*totvert,"explode_vertpa2");
 	int *facepa = emd->facepa;
-	int *fs, totesplit=0,totfsplit=0,totin=0,curdupvert=0,curdupface=0,curdupin=0;
-	int i,j,v1,v2,v3,v4,esplit;
+	int *fs, totesplit=0,totfsplit=0,curdupface=0;
+	int i,j,v1,v2,v3,v4,esplit, v[4], uv[4];
+	int numlayer;
 
 	edgehash= BLI_edgehash_new();
 
@@ -213,52 +574,48 @@ static DerivedMesh * splitEdges(ExplodeModifierData *emd, DerivedMesh *dm){
 
 	/* mark edges for splitting and how to split faces */
 	for (i=0,mf=mface,fs=facesplit; i<totface; i++,mf++,fs++) {
-		if(mf->v4){
-			v1=vertpa[mf->v1];
-			v2=vertpa[mf->v2];
-			v3=vertpa[mf->v3];
-			v4=vertpa[mf->v4];
+		v1=vertpa[mf->v1];
+		v2=vertpa[mf->v2];
+		v3=vertpa[mf->v3];
 
-			if(v1!=v2){
-				BLI_edgehash_insert(edgehash, mf->v1, mf->v2, NULL);
-				(*fs)++;
-			}
+		if(v1!=v2){
+			BLI_edgehash_insert(edgehash, mf->v1, mf->v2, NULL);
+			(*fs) |= 1;
+		}
 
-			if(v2!=v3){
-				BLI_edgehash_insert(edgehash, mf->v2, mf->v3, NULL);
-				(*fs)++;
-			}
+		if(v2!=v3){
+			BLI_edgehash_insert(edgehash, mf->v2, mf->v3, NULL);
+			(*fs) |= 2;
+		}
+
+		if(mf->v4){
+			v4=vertpa[mf->v4];
 
 			if(v3!=v4){
 				BLI_edgehash_insert(edgehash, mf->v3, mf->v4, NULL);
-				(*fs)++;
+				(*fs) |= 4;
 			}
 
 			if(v1!=v4){
 				BLI_edgehash_insert(edgehash, mf->v1, mf->v4, NULL);
-				(*fs)++;
+				(*fs) |= 8;
 			}
 
-			if(*fs==2){
-				if((v1==v2 && v3==v4) || (v1==v4 && v2==v3))
-					*fs=1;
-				else if(v1!=v2){
-					if(v1!=v4)
-						BLI_edgehash_insert(edgehash, mf->v2, mf->v3, NULL);
-					else
-						BLI_edgehash_insert(edgehash, mf->v3, mf->v4, NULL);
-				}
-				else{ 
-					if(v1!=v4)
-						BLI_edgehash_insert(edgehash, mf->v1, mf->v2, NULL);
-					else
-						BLI_edgehash_insert(edgehash, mf->v1, mf->v4, NULL);
-				}
+			/* mark center vertex as a fake edge split */
+			if(*fs == 15)
+				BLI_edgehash_insert(edgehash, mf->v1, mf->v3, NULL);
+		}
+		else {
+			(*fs) |= 16; /* mark face as tri */
+
+			if(v1!=v3){
+				BLI_edgehash_insert(edgehash, mf->v1, mf->v3, NULL);
+				(*fs) |= 4;
 			}
 		}
 	}
 
-	/* count splits & reindex */
+	/* count splits & create indexes for new verts */
 	ehi= BLI_edgehashIterator_new(edgehash);
 	totesplit=totvert;
 	for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
@@ -268,24 +625,11 @@ static DerivedMesh * splitEdges(ExplodeModifierData *emd, DerivedMesh *dm){
 	BLI_edgehashIterator_free(ehi);
 
 	/* count new faces due to splitting */
-	for(i=0,fs=facesplit; i<totface; i++,fs++){
-		if(*fs==1)
-			totfsplit+=1;
-		else if(*fs==2)
-			totfsplit+=2;
-		else if(*fs==3)
-			totfsplit+=3;
-		else if(*fs==4){
-			totfsplit+=3;
-
-			mf=dm->getTessFaceData(dm,i,CD_MFACE);//CDDM_get_tessface(dm,i);
-
-			if(vertpa[mf->v1]!=vertpa[mf->v2] && vertpa[mf->v2]!=vertpa[mf->v3])
-				totin++;
-		}
-	}
+	for(i=0,fs=facesplit; i<totface; i++,fs++)
+		totfsplit += add_faces[*fs];
 	
-	splitdm= CDDM_from_template(dm, totesplit+totin, dm->getNumEdges(dm),totface+totfsplit, 0, 0);
+	splitdm= CDDM_from_template(dm, totesplit, 0, totface+totfsplit, 0, 0);
+	numlayer = CustomData_number_of_layers(&splitdm->faceData, CD_MTFACE);
 
 	/* copy new faces & verts (is it really this painful with custom data??) */
 	for(i=0; i<totvert; i++){
@@ -297,23 +641,13 @@ static DerivedMesh * splitEdges(ExplodeModifierData *emd, DerivedMesh *dm){
 		DM_copy_vert_data(dm, splitdm, i, i, 1);
 		*dest = source;
 	}
-	for(i=0; i<totface; i++){
-		MFace source;
-		MFace *dest;
-		dm->getTessFace(dm, i, &source);
-		dest = CDDM_get_tessface(splitdm, i);
-
-		DM_copy_tessface_data(dm, splitdm, i, i, 1);
-		*dest = source;
-	}
 
 	/* override original facepa (original pointer is saved in caller function) */
 	facepa= MEM_callocN(sizeof(int)*(totface+totfsplit),"explode_facepa");
-	memcpy(facepa,emd->facepa,totface*sizeof(int));
+	//memcpy(facepa,emd->facepa,totface*sizeof(int));
 	emd->facepa=facepa;
 
 	/* create new verts */
-	curdupvert=totvert;
 	ehi= BLI_edgehashIterator_new(edgehash);
 	for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
 		BLI_edgehashIterator_getKey(ehi, &i, &j);
@@ -333,320 +667,101 @@ static DerivedMesh * splitEdges(ExplodeModifierData *emd, DerivedMesh *dm){
 	BLI_edgehashIterator_free(ehi);
 
 	/* create new faces */
-	curdupface=totface;
-	curdupin=totesplit;
+	curdupface=0;//=totface;
+	//curdupin=totesplit;
 	for(i=0,fs=facesplit; i<totface; i++,fs++){
-		if(*fs){
-			mf=CDDM_get_tessface(splitdm,i);
-
-			v1=vertpa[mf->v1];
-			v2=vertpa[mf->v2];
-			v3=vertpa[mf->v3];
-			v4=vertpa[mf->v4];
-			/* ouch! creating new faces & remapping them to new verts is no fun */
-			if(*fs==1){
-				df1=CDDM_get_tessface(splitdm,curdupface);
-				DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-				*df1=*mf;
-				curdupface++;
-				
-				if(v1==v2){
-					df1->v1=edgesplit_get(edgehash, mf->v1, mf->v4);
-					df1->v2=edgesplit_get(edgehash, mf->v2, mf->v3);
-					mf->v3=df1->v2;
-					mf->v4=df1->v1;
-				}
-				else{
-					df1->v1=edgesplit_get(edgehash, mf->v1, mf->v2);
-					df1->v4=edgesplit_get(edgehash, mf->v3, mf->v4);
-					mf->v2=df1->v1;
-					mf->v3=df1->v4;
-				}
-
-				facepa[i]=v1;
-				facepa[curdupface-1]=v3;
-
-				test_index_face(df1, &splitdm->faceData, curdupface, (df1->v4 ? 4 : 3));
-			}
-			if(*fs==2){
-				df1=CDDM_get_tessface(splitdm,curdupface);
-				DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-				*df1=*mf;
-				curdupface++;
-
-				df2=CDDM_get_tessface(splitdm,curdupface);
-				DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-				*df2=*mf;
-				curdupface++;
-
-				if(v1!=v2){
-					if(v1!=v4){
-						df1->v1=edgesplit_get(edgehash, mf->v1, mf->v4);
-						df1->v2=edgesplit_get(edgehash, mf->v1, mf->v2);
-						df2->v1=df1->v3=mf->v2;
-						df2->v3=df1->v4=mf->v4;
-						df2->v2=mf->v3;
-
-						mf->v2=df1->v2;
-						mf->v3=df1->v1;
-
-						df2->v4=mf->v4=0;
-
-						facepa[i]=v1;
-					}
-					else{
-						df1->v2=edgesplit_get(edgehash, mf->v1, mf->v2);
-						df1->v3=edgesplit_get(edgehash, mf->v2, mf->v3);
-						df1->v4=mf->v3;
-						df2->v2=mf->v3;
-						df2->v3=mf->v4;
-
-						mf->v1=df1->v2;
-						mf->v3=df1->v3;
-
-						df2->v4=mf->v4=0;
-
-						facepa[i]=v2;
-					}
-					facepa[curdupface-1]=facepa[curdupface-2]=v3;
-				}
-				else{
-					if(v1!=v4){
-						df1->v3=edgesplit_get(edgehash, mf->v3, mf->v4);
-						df1->v4=edgesplit_get(edgehash, mf->v1, mf->v4);
-						df1->v2=mf->v3;
-
-						mf->v1=df1->v4;
-						mf->v2=df1->v3;
-						mf->v3=mf->v4;
-
-						df2->v4=mf->v4=0;
-
-						facepa[i]=v4;
-					}
-					else{
-						df1->v3=edgesplit_get(edgehash, mf->v2, mf->v3);
-						df1->v4=edgesplit_get(edgehash, mf->v3, mf->v4);
-						df1->v1=mf->v4;
-						df1->v2=mf->v2;
-						df2->v3=mf->v4;
-
-						mf->v1=df1->v4;
-						mf->v2=df1->v3;
-
-						df2->v4=mf->v4=0;
-
-						facepa[i]=v3;
-					}
-
-					facepa[curdupface-1]=facepa[curdupface-2]=v1;
-				}
-
-				test_index_face(df1, &splitdm->faceData, curdupface-2, (df1->v4 ? 4 : 3));
-				test_index_face(df1, &splitdm->faceData, curdupface-1, (df1->v4 ? 4 : 3));
-			}
-			else if(*fs==3){
-				df1=CDDM_get_tessface(splitdm,curdupface);
-				DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-				*df1=*mf;
-				curdupface++;
-
-				df2=CDDM_get_tessface(splitdm,curdupface);
-				DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-				*df2=*mf;
-				curdupface++;
-
-				df3=CDDM_get_tessface(splitdm,curdupface);
-				DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-				*df3=*mf;
-				curdupface++;
-
-				if(v1==v2){
-					df2->v1=df1->v1=edgesplit_get(edgehash, mf->v1, mf->v4);
-					df3->v1=df1->v2=edgesplit_get(edgehash, mf->v2, mf->v3);
-					df3->v3=df2->v2=df1->v3=edgesplit_get(edgehash, mf->v3, mf->v4);
-					df3->v2=mf->v3;
-					df2->v3=mf->v4;
-					df1->v4=df2->v4=df3->v4=0;
-
-					mf->v3=df1->v2;
-					mf->v4=df1->v1;
-
-					facepa[i]=facepa[curdupface-3]=v1;
-					facepa[curdupface-1]=v3;
-					facepa[curdupface-2]=v4;
-				}
-				else if(v2==v3){
-					df3->v1=df2->v3=df1->v1=edgesplit_get(edgehash, mf->v1, mf->v4);
-					df2->v2=df1->v2=edgesplit_get(edgehash, mf->v1, mf->v2);
-					df3->v2=df1->v3=edgesplit_get(edgehash, mf->v3, mf->v4);
-
-					df3->v3=mf->v4;
-					df2->v1=mf->v1;
-					df1->v4=df2->v4=df3->v4=0;
-
-					mf->v1=df1->v2;
-					mf->v4=df1->v3;
-
-					facepa[i]=facepa[curdupface-3]=v2;
-					facepa[curdupface-1]=v4;
-					facepa[curdupface-2]=v1;
-				}
-				else if(v3==v4){
-					df3->v2=df2->v1=df1->v1=edgesplit_get(edgehash, mf->v1, mf->v2);
-					df2->v3=df1->v2=edgesplit_get(edgehash, mf->v2, mf->v3);
-					df3->v3=df1->v3=edgesplit_get(edgehash, mf->v1, mf->v4);
-
-					df3->v1=mf->v1;
-					df2->v2=mf->v2;
-					df1->v4=df2->v4=df3->v4=0;
-
-					mf->v1=df1->v3;
-					mf->v2=df1->v2;
-
-					facepa[i]=facepa[curdupface-3]=v3;
-					facepa[curdupface-1]=v1;
-					facepa[curdupface-2]=v2;
-				}
-				else{
-					df3->v1=df1->v1=edgesplit_get(edgehash, mf->v1, mf->v2);
-					df3->v3=df2->v1=df1->v2=edgesplit_get(edgehash, mf->v2, mf->v3);
-					df2->v3=df1->v3=edgesplit_get(edgehash, mf->v3, mf->v4);
-
-					df3->v2=mf->v2;
-					df2->v2=mf->v3;
-					df1->v4=df2->v4=df3->v4=0;
-
-					mf->v2=df1->v1;
-					mf->v3=df1->v3;
-
-					facepa[i]=facepa[curdupface-3]=v1;
-					facepa[curdupface-1]=v2;
-					facepa[curdupface-2]=v3;
-				}
-
-				test_index_face(df1, &splitdm->faceData, curdupface-3, (df1->v4 ? 4 : 3));
-				test_index_face(df1, &splitdm->faceData, curdupface-2, (df1->v4 ? 4 : 3));
-				test_index_face(df1, &splitdm->faceData, curdupface-1, (df1->v4 ? 4 : 3));
-			}
-			else if(*fs==4){
-				if(v1!=v2 && v2!=v3){
-
-					/* set new vert to face center */
-					mv=CDDM_get_vert(splitdm,mf->v1);
-					dupve=CDDM_get_vert(splitdm,curdupin);
-					DM_copy_vert_data(splitdm,splitdm,mf->v1,curdupin,1);
-					*dupve=*mv;
-
-					mv=CDDM_get_vert(splitdm,mf->v2);
-					VECADD(dupve->co,dupve->co,mv->co);
-					mv=CDDM_get_vert(splitdm,mf->v3);
-					VECADD(dupve->co,dupve->co,mv->co);
-					mv=CDDM_get_vert(splitdm,mf->v4);
-					VECADD(dupve->co,dupve->co,mv->co);
-					mul_v3_fl(dupve->co,0.25);
-
-
-					df1=CDDM_get_tessface(splitdm,curdupface);
-					DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-					*df1=*mf;
-					curdupface++;
-
-					df2=CDDM_get_tessface(splitdm,curdupface);
-					DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-					*df2=*mf;
-					curdupface++;
-
-					df3=CDDM_get_tessface(splitdm,curdupface);
-					DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-					*df3=*mf;
-					curdupface++;
-
-					df1->v1=edgesplit_get(edgehash, mf->v1, mf->v2);
-					df3->v2=df1->v3=edgesplit_get(edgehash, mf->v2, mf->v3);
-
-					df2->v1=edgesplit_get(edgehash, mf->v1, mf->v4);
-					df3->v4=df2->v3=edgesplit_get(edgehash, mf->v3, mf->v4);
-
-					df3->v1=df2->v2=df1->v4=curdupin;
-
-					mf->v2=df1->v1;
-					mf->v3=curdupin;
-					mf->v4=df2->v1;
-
-					curdupin++;
-
-					facepa[i]=v1;
-					facepa[curdupface-3]=v2;
-					facepa[curdupface-2]=v3;
-					facepa[curdupface-1]=v4;
-
-					test_index_face(df1, &splitdm->faceData, curdupface-3, (df1->v4 ? 4 : 3));
-
-					test_index_face(df1, &splitdm->faceData, curdupface-2, (df1->v4 ? 4 : 3));
-					test_index_face(df1, &splitdm->faceData, curdupface-1, (df1->v4 ? 4 : 3));
-				}
-				else{
-					df1=CDDM_get_tessface(splitdm,curdupface);
-					DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-					*df1=*mf;
-					curdupface++;
-
-					df2=CDDM_get_tessface(splitdm,curdupface);
-					DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-					*df2=*mf;
-					curdupface++;
-
-					df3=CDDM_get_tessface(splitdm,curdupface);
-					DM_copy_face_data(splitdm,splitdm,i,curdupface,1);
-					*df3=*mf;
-					curdupface++;
-
-					if(v2==v3){
-						df1->v1=edgesplit_get(edgehash, mf->v1, mf->v2);
-						df3->v1=df1->v2=df1->v3=edgesplit_get(edgehash, mf->v2, mf->v3);
-						df2->v1=df1->v4=edgesplit_get(edgehash, mf->v1, mf->v4);
-
-						df3->v3=df2->v3=edgesplit_get(edgehash, mf->v3, mf->v4);
-
-						df3->v2=mf->v3;
-						df3->v4=0;
-
-						mf->v2=df1->v1;
-						mf->v3=df1->v4;
-						mf->v4=0;
-
-						facepa[i]=v1;
-						facepa[curdupface-3]=facepa[curdupface-2]=v2;
-						facepa[curdupface-1]=v3;
-					}
-					else{
-						df3->v1=df2->v1=df1->v2=edgesplit_get(edgehash, mf->v1, mf->v2);
-						df2->v4=df1->v3=edgesplit_get(edgehash, mf->v3, mf->v4);
-						df1->v4=edgesplit_get(edgehash, mf->v1, mf->v4);
-
-						df3->v3=df2->v2=edgesplit_get(edgehash, mf->v2, mf->v3);
-
-						df3->v4=0;
-
-						mf->v1=df1->v4;
-						mf->v2=df1->v3;
-						mf->v3=mf->v4;
-						mf->v4=0;
-
-						facepa[i]=v4;
-						facepa[curdupface-3]=facepa[curdupface-2]=v1;
-						facepa[curdupface-1]=v2;
-					}
-
-					test_index_face(df1, &splitdm->faceData, curdupface-3, (df1->v4 ? 4 : 3));
-					test_index_face(df1, &splitdm->faceData, curdupface-2, (df1->v4 ? 4 : 3));
-					test_index_face(df1, &splitdm->faceData, curdupface-1, (df1->v4 ? 4 : 3));
-				}
-			}
+		mf = dm->getTessFaceData(dm, i, CD_MFACE);
+
+		switch(*fs) {
+		case 3:
+		case 10:
+		case 11:
+		case 15:
+			SET_VERTS(1, 2, 3, 4)
+			break;
+		case 5:
+		case 6:
+		case 7:
+			SET_VERTS(2, 3, 4, 1)
+			break;
+		case 9:
+		case 13:
+			SET_VERTS(4, 1, 2, 3)
+			break;
+		case 12:
+		case 14:
+			SET_VERTS(3, 4, 1, 2)
+			break;
+		case 21:
+		case 23:
+			SET_VERTS(1, 2, 3, 4)
+			break;
+		case 19:
+			SET_VERTS(2, 3, 1, 4)
+			break;
+		case 22:
+			SET_VERTS(3, 1, 2, 4)
+			break;
+		}
 
-			test_index_face(df1, &splitdm->faceData, i, (df1->v4 ? 4 : 3));
+		switch(*fs) {
+		case 3:
+		case 6:
+		case 9:
+		case 12:
+			remap_faces_3_6_9_12(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
+			if(numlayer)
+				remap_uvs_3_6_9_12(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
+			break;
+		case 5:
+		case 10:
+			remap_faces_5_10(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
+			if(numlayer)
+				remap_uvs_5_10(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
+			break;
+		case 15:
+			remap_faces_15(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
+			if(numlayer)
+				remap_uvs_15(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
+			break;
+		case 7:
+		case 11:
+		case 13:
+		case 14:
+			remap_faces_7_11_13_14(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
+			if(numlayer)
+				remap_uvs_7_11_13_14(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
+			break;
+		case 19:
+		case 21:
+		case 22:
+			remap_faces_19_21_22(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2]);
+			if(numlayer)
+				remap_uvs_19_21_22(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2]);
+			break;
+		case 23:
+			remap_faces_23(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2]);
+			if(numlayer)
+				remap_uvs_23(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2]);
+			break;
+		case 0:
+		case 16:
+			df1 = get_dface(dm, splitdm, curdupface, i, mf);
+			facepa[curdupface] = vertpa[mf->v1];
+
+			if(df1->v4)
+				df1->flag |= ME_FACE_SEL;
+			else
+				df1->flag &= ~ME_FACE_SEL;
+			break;
 		}
+
+		curdupface += add_faces[*fs]+1;
+	}
+
+	for(i=0; i<curdupface; i++) {
+		mf = CDDM_get_tessface(splitdm, i);
+		test_index_face(mf, &splitdm->faceData, i, (mf->flag & ME_FACE_SEL ? 4 : 3));
 	}
 
 	BLI_edgehash_free(edgehash, NULL);
@@ -666,24 +781,31 @@ static DerivedMesh * explodeMesh(ExplodeModifierData *emd,
 	DerivedMesh *explode, *dm=to_explode;
 	MFace *mf=0, *mface;
 	ParticleSettings *part=psmd->psys->part;
-	ParticleSimulationData sim = {scene, ob, psmd->psys, psmd};
+	ParticleSimulationData sim= {0};
 	ParticleData *pa=NULL, *pars=psmd->psys->particles;
 	ParticleKey state;
 	EdgeHash *vertpahash;
 	EdgeHashIterator *ehi;
 	float *vertco=0, imat[4][4];
 	float loc0[3], nor[3];
-	float timestep, cfra;
+	float cfra;
+	/* float timestep; */
 	int *facepa=emd->facepa;
 	int totdup=0,totvert=0,totface=0,totpart=0;
 	int i, j, v, mindex=0;
+	MTFace *mtface = NULL, *mtf;
 
 	totface= dm->getNumTessFaces(dm);
 	totvert= dm->getNumVerts(dm);
 	mface= dm->getTessFaceArray(dm);
 	totpart= psmd->psys->totpart;
 
-	timestep= psys_get_timestep(&sim);
+	sim.scene= scene;
+	sim.ob= ob;
+	sim.psys= psmd->psys;
+	sim.psmd= psmd;
+
+	/* timestep= psys_get_timestep(&sim); */
 
 	//if(part->flag & PART_GLOB_TIME)
 		cfra= BKE_curframe(scene);
@@ -721,6 +843,7 @@ static DerivedMesh * explodeMesh(ExplodeModifierData *emd,
 
 	/* the final duplicated vertices */
 	explode= CDDM_from_template(dm, totdup, 0,totface, 0, 0);
+	mtface = CustomData_get_layer_named(&explode->faceData, CD_MTFACE, emd->uvname);
 	/*dupvert= CDDM_get_verts(explode);*/
 
 	/* getting back to object space */
@@ -797,16 +920,28 @@ static DerivedMesh * explodeMesh(ExplodeModifierData *emd,
 		else 
 			mindex = totvert+facepa[i];
 
-		source.v1 = edgesplit_get(vertpahash, source.v1, mindex);
-		source.v2 = edgesplit_get(vertpahash, source.v2, mindex);
-		source.v3 = edgesplit_get(vertpahash, source.v3, mindex);
+		source.v1 = edgecut_get(vertpahash, source.v1, mindex);
+		source.v2 = edgecut_get(vertpahash, source.v2, mindex);
+		source.v3 = edgecut_get(vertpahash, source.v3, mindex);
 		if(source.v4)
-			source.v4 = edgesplit_get(vertpahash, source.v4, mindex);
+			source.v4 = edgecut_get(vertpahash, source.v4, mindex);
 
 		DM_copy_face_data(dm,explode,i,i,1);
 
 		*mf = source;
 
+		/* override uv channel for particle age */
+		if(mtface) {
+			float age = (cfra - pa->time)/pa->lifetime;
+			/* Clamp to this range to avoid flipping to the other side of the coordinates. */
+			CLAMP(age, 0.001f, 0.999f);
+
+			mtf = mtface + i;
+
+			mtf->uv[0][0] = mtf->uv[1][0] = mtf->uv[2][0] = mtf->uv[3][0] = age;
+			mtf->uv[0][1] = mtf->uv[1][1] = mtf->uv[2][1] = mtf->uv[3][1] = 0.5f;
+		}
+
 		test_index_face(mf, &explode->faceData, i, (orig_v4 ? 4 : 3));
 	}
 
@@ -840,9 +975,10 @@ static ParticleSystemModifierData * findPrecedingParticlesystem(Object *ob, Modi
 	}
 	return psmd;
 }
-static DerivedMesh * applyModifier(
-		ModifierData *md, Object *ob, DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+static DerivedMesh * applyModifier(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm = derivedData;
 	ExplodeModifierData *emd= (ExplodeModifierData*) md;
@@ -859,20 +995,20 @@ static DerivedMesh * applyModifier(
 		if(emd->facepa==0
 				 || psmd->flag&eParticleSystemFlag_Pars
 				 || emd->flag&eExplodeFlag_CalcFaces
-				 || MEM_allocN_len(emd->facepa)/sizeof(int) != dm->getNumTessFaces(dm)){
+				 || MEM_allocN_len(emd->facepa)/sizeof(int) != dm->getNumTessFaces(dm))
+		{
 			if(psmd->flag & eParticleSystemFlag_Pars)
 				psmd->flag &= ~eParticleSystemFlag_Pars;
 			
 			if(emd->flag & eExplodeFlag_CalcFaces)
 				emd->flag &= ~eExplodeFlag_CalcFaces;
 
-			createFacepa(emd,psmd,ob,derivedData);
-				 }
-
+			createFacepa(emd,psmd,derivedData);
+		}
 				 /* 2. create new mesh */
-				 if(emd->flag & eExplodeFlag_EdgeSplit){
+				 if(emd->flag & eExplodeFlag_EdgeCut){
 					 int *facepa = emd->facepa;
-					 DerivedMesh *splitdm=splitEdges(emd,dm);
+					 DerivedMesh *splitdm=cutEdges(emd,dm);
 					 DerivedMesh *explode=explodeMesh(emd, psmd, md->scene, ob, splitdm);
 
 					 MEM_freeN(emd->facepa);
@@ -895,6 +1031,7 @@ ModifierTypeInfo modifierType_Explode = {
 	/* flags */             eModifierTypeFlag_AcceptsMesh,
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -905,6 +1042,7 @@ ModifierTypeInfo modifierType_Explode = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_fluidsim.c b/source/blender/modifiers/intern/MOD_fluidsim.c
index c683bee0b35..1cce9863ccc 100644
--- a/source/blender/modifiers/intern/MOD_fluidsim.c
+++ b/source/blender/modifiers/intern/MOD_fluidsim.c
@@ -30,15 +30,24 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_fluidsim.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_scene_types.h"
 #include "DNA_object_fluidsim.h"
 #include "DNA_object_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
 
 #include "depsgraph_private.h"
 
+#include "MOD_util.h"
 #include "MOD_fluidsim_util.h"
 #include "MEM_guardedalloc.h"
 
@@ -69,9 +78,10 @@ static void copyData(ModifierData *md, ModifierData *target)
 
 
 
-static DerivedMesh * applyModifier(
-		ModifierData *md, Object *ob, DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
+						DerivedMesh *dm,
+						int useRenderParams,
+						int isFinalCalc)
 {
 	FluidsimModifierData *fluidmd= (FluidsimModifierData*) md;
 	DerivedMesh *result = NULL;
@@ -82,17 +92,12 @@ static DerivedMesh * applyModifier(
 		initData(md);
 		
 		if(!fluidmd->fss)
-			return derivedData;
+			return dm;
 	}
 
-	result = fluidsimModifier_do(fluidmd, md->scene, ob, derivedData, useRenderParams, isFinalCalc);
+	result= fluidsimModifier_do(fluidmd, md->scene, ob, dm, useRenderParams, isFinalCalc);
 
-	if(result) 
-	{ 
-		return result; 
-	}
-	
-	return derivedData;
+	return result ? result : dm;
 }
 
 static void updateDepgraph(
@@ -125,7 +130,7 @@ static void updateDepgraph(
 	}
 }
 
-static int dependsOnTime(ModifierData *md) 
+static int dependsOnTime(ModifierData *UNUSED(md)) 
 {
 	return 1;
 }
@@ -143,6 +148,7 @@ ModifierTypeInfo modifierType_Fluidsim = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -153,6 +159,7 @@ ModifierTypeInfo modifierType_Fluidsim = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_fluidsim_util.c b/source/blender/modifiers/intern/MOD_fluidsim_util.c
index 17ce46129bc..7db1f003146 100644
--- a/source/blender/modifiers/intern/MOD_fluidsim_util.c
+++ b/source/blender/modifiers/intern/MOD_fluidsim_util.c
@@ -30,6 +30,11 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_fluidsim_util.c
+ *  \ingroup modifiers
+ */
+
+
 #include <stddef.h>
 #include <zlib.h>
 
@@ -42,12 +47,16 @@
 
 #include "BLI_blenlib.h"
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
 
+#include "BKE_main.h"
+#include "BKE_fluidsim.h" /* ensure definitions here match */
 #include "BKE_cdderivedmesh.h"
 #include "BKE_mesh.h"
 #include "BKE_utildefines.h"
-#include "BKE_global.h" /* G.sce only */
+#include "BKE_global.h" /* G.main->name only */
 
+#include "MOD_fluidsim_util.h"
 #include "MOD_modifiertypes.h"
 
 #include "MEM_guardedalloc.h"
@@ -138,6 +147,8 @@ void fluidsim_init(FluidsimModifierData *fluidmd)
 		fss->flag |= OB_FLUIDSIM_ACTIVE;
 
 	}
+#else
+	(void)fluidmd; /* unused */
 #endif
 	return;
 }
@@ -154,23 +165,26 @@ void fluidsim_free(FluidsimModifierData *fluidmd)
 		}
 		MEM_freeN(fluidmd->fss);
 	}
+#else
+	(void)fluidmd; /* unused */
 #endif
+	
 	return;
 }
 
 #ifndef DISABLE_ELBEEM
 /* read .bobj.gz file into a fluidsimDerivedMesh struct */
-DerivedMesh *fluidsim_read_obj(char *filename)
+static DerivedMesh *fluidsim_read_obj(const char *filename)
 {
-	int wri,i,j;
-	float wrf;
+	int wri = 0,i;
 	int gotBytes;
 	gzFile gzf;
 	int numverts = 0, numfaces = 0;
 	DerivedMesh *dm = NULL;
-	MFace *mface;
-	MVert *mvert;
-	short *normals;
+	MFace *mf;
+	MVert *mv;
+	short *normals, *no_s;
+	float no[3];
 
 	// ------------------------------------------------
 	// get numverts + numfaces first
@@ -186,28 +200,25 @@ DerivedMesh *fluidsim_read_obj(char *filename)
 	numverts = wri;
 
 	// skip verts
-	for(i=0; i<numverts*3; i++)
-	{
-		gotBytes = gzread(gzf, &wrf, sizeof( wrf ));
-	}
+	gotBytes = gzseek(gzf, numverts * 3 * sizeof(float), SEEK_CUR) != -1;
+
 
 	// read number of normals
-	gotBytes = gzread(gzf, &wri, sizeof(wri));
+	if(gotBytes)
+		gotBytes = gzread(gzf, &wri, sizeof(wri));
 
 	// skip normals
-	for(i=0; i<numverts*3; i++)
-	{
-		gotBytes = gzread(gzf, &wrf, sizeof( wrf ));
-	}
+	gotBytes = gzseek(gzf, numverts * 3 * sizeof(float), SEEK_CUR) != -1;
 
 	/* get no. of triangles */
-	gotBytes = gzread(gzf, &wri, sizeof(wri));
+	if(gotBytes)
+		gotBytes = gzread(gzf, &wri, sizeof(wri));
 	numfaces = wri;
 
 	gzclose( gzf );
 	// ------------------------------------------------
 
-	if(!numfaces || !numverts)
+	if(!numfaces || !numverts || !gotBytes)
 		return NULL;
 
 	gzf = gzopen(filename, "rb");
@@ -228,17 +239,10 @@ DerivedMesh *fluidsim_read_obj(char *filename)
 	gotBytes = gzread(gzf, &wri, sizeof(wri));
 
 	// read vertex position from file
-	mvert = CDDM_get_verts(dm);
-	for(i=0; i<numverts; i++)
-	{
-		MVert *mv = &mvert[i];
+	mv = CDDM_get_verts(dm);
 
-		for(j=0; j<3; j++)
-		{
-			gotBytes = gzread(gzf, &wrf, sizeof( wrf ));
-			mv->co[j] = wrf;
-		}
-	}
+	for(i=0; i<numverts; i++, mv++)
+		gotBytes = gzread(gzf, mv->co, sizeof(float) * 3);
 
 	// should be the same as numverts
 	gotBytes = gzread(gzf, &wri, sizeof(wri));
@@ -260,29 +264,31 @@ DerivedMesh *fluidsim_read_obj(char *filename)
 	}
 
 	// read normals from file (but don't save them yet)
-	for(i=0; i<numverts*3; i++)
+	for(i=numverts, no_s= normals; i>0; i--, no_s += 3)
 	{
-		gotBytes = gzread(gzf, &wrf, sizeof( wrf ));
-		normals[i] = (short)(wrf*32767.0f);
+		gotBytes = gzread(gzf, no, sizeof(float) * 3);
+		normal_float_to_short_v3(no_s, no);
 	}
 
 	/* read no. of triangles */
 	gotBytes = gzread(gzf, &wri, sizeof(wri));
 
-	if(wri!=numfaces)
+	if(wri!=numfaces) {
 		printf("Fluidsim: error in reading data from file.\n");
+		if(dm)
+			dm->release(dm);
+		gzclose( gzf );
+		MEM_freeN(normals);
+		return NULL;
+	}
 
 	// read triangles from file
-	mface = CDDM_get_tessfaces(dm);
-	for(i=0; i<numfaces; i++)
+	mf = CDDM_get_tessfaces(dm);
+	for(i=numfaces; i>0; i--, mf++)
 	{
-		int face[4];
-		MFace *mf = &mface[i];
+		int face[3];
 
-		gotBytes = gzread(gzf, &(face[0]), sizeof( face[0] ));
-		gotBytes = gzread(gzf, &(face[1]), sizeof( face[1] ));
-		gotBytes = gzread(gzf, &(face[2]), sizeof( face[2] ));
-		face[3] = 0;
+		gotBytes = gzread(gzf, face, sizeof(int) * 3);
 
 		// check if 3rd vertex has index 0 (not allowed in blender)
 		if(face[2])
@@ -297,7 +303,7 @@ DerivedMesh *fluidsim_read_obj(char *filename)
 			mf->v2 = face[2];
 			mf->v3 = face[0];
 		}
-		mf->v4 = face[3];
+		mf->v4 = 0;
 
 		test_index_face(mf, NULL, 0, 3);
 	}
@@ -380,7 +386,7 @@ void fluid_estimate_memory(Object *ob, FluidsimSettings *fss, char *value)
 
 
 /* read zipped fluidsim velocities into the co's of the fluidsimsettings normals struct */
-void fluidsim_read_vel_cache(FluidsimModifierData *fluidmd, DerivedMesh *dm, char *filename)
+static void fluidsim_read_vel_cache(FluidsimModifierData *fluidmd, DerivedMesh *dm, char *filename)
 {
 	int wri, i, j;
 	float wrf;
@@ -443,7 +449,7 @@ void fluidsim_read_vel_cache(FluidsimModifierData *fluidmd, DerivedMesh *dm, cha
 	gzclose(gzf);
 }
 
-DerivedMesh *fluidsim_read_cache(Object *ob, DerivedMesh *orgdm, FluidsimModifierData *fluidmd, int framenr, int useRenderParams)
+static DerivedMesh *fluidsim_read_cache(DerivedMesh *orgdm, FluidsimModifierData *fluidmd, int framenr, int useRenderParams)
 {
 	int displaymode = 0;
 	int curFrame = framenr - 1 /*scene->r.sfra*/; /* start with 0 at start frame */
@@ -460,7 +466,7 @@ DerivedMesh *fluidsim_read_cache(Object *ob, DerivedMesh *orgdm, FluidsimModifie
 		displaymode = fss->renderDisplayMode;
 	}
 
-	strncpy(targetDir, fss->surfdataPath, FILE_MAXDIR);
+	BLI_strncpy(targetDir, fss->surfdataPath, sizeof(targetDir));
 
 	// use preview or final mesh?
 	if(displaymode==1)
@@ -477,11 +483,10 @@ DerivedMesh *fluidsim_read_cache(Object *ob, DerivedMesh *orgdm, FluidsimModifie
 		strcat(targetDir,"fluidsurface_final_####");
 	}
 
-	BLI_path_abs(targetDir, G.sce);
+	BLI_path_abs(targetDir, G.main->name);
 	BLI_path_frame(targetDir, curFrame, 0); // fixed #frame-no
 
-	strcpy(targetFile,targetDir);
-	strcat(targetFile, ".bobj.gz");
+	BLI_snprintf(targetFile, sizeof(targetFile), "%s.bobj.gz", targetDir);
 
 	dm = fluidsim_read_obj(targetFile);
 
@@ -534,10 +539,12 @@ DerivedMesh *fluidsim_read_cache(Object *ob, DerivedMesh *orgdm, FluidsimModifie
 
 	return dm;
 }
-
 #endif // DISABLE_ELBEEM
 
-DerivedMesh *fluidsimModifier_do(FluidsimModifierData *fluidmd, Scene *scene, Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc)
+DerivedMesh *fluidsimModifier_do(FluidsimModifierData *fluidmd, Scene *scene,
+						Object *UNUSED(ob),
+						DerivedMesh *dm,
+						int useRenderParams, int UNUSED(isFinalCalc))
 {
 #ifndef DISABLE_ELBEEM
 	DerivedMesh *result = NULL;
@@ -558,7 +565,7 @@ DerivedMesh *fluidsimModifier_do(FluidsimModifierData *fluidmd, Scene *scene, Ob
 	
 	// timescale not supported yet
 	// clmd->sim_parms->timescale= timescale;
-	
+
 	// support reversing of baked fluid frames here
 	if((fss->flag & OB_FLUIDSIM_REVERSE) && (fss->lastgoodframe >= 0))
 	{
@@ -567,42 +574,17 @@ DerivedMesh *fluidsimModifier_do(FluidsimModifierData *fluidmd, Scene *scene, Ob
 	}
 	
 	/* try to read from cache */
-	if(((fss->lastgoodframe >= framenr) || (fss->lastgoodframe < 0)) && (result = fluidsim_read_cache(ob, dm, fluidmd, framenr, useRenderParams)))
-	{
-		// fss->lastgoodframe = framenr; // set also in src/fluidsim.c
+	/* if the frame is there, fine, otherwise don't do anything */
+	if((result = fluidsim_read_cache(dm, fluidmd, framenr, useRenderParams)))
 		return result;
-	}
-	else
-	{	
-		// display last known good frame
-		if(fss->lastgoodframe >= 0)
-		{
-			if((result = fluidsim_read_cache(ob, dm, fluidmd, fss->lastgoodframe, useRenderParams))) 
-			{
-				return result;
-			}
-			
-			// it was supposed to be a valid frame but it isn't!
-			fss->lastgoodframe = framenr - 1;
-			
-			
-			// this could be likely the case when you load an old fluidsim
-			if((result = fluidsim_read_cache(ob, dm, fluidmd, fss->lastgoodframe, useRenderParams))) 
-			{
-				return result;
-			}
-		}
-		
-		result = CDDM_copy(dm, 1);
-
-		if(result) 
-		{
-			return result;
-		}
-	}
 	
 	return dm;
 #else
+	/* unused */
+	(void)fluidmd;
+	(void)scene;
+	(void)dm;
+	(void)useRenderParams;
 	return NULL;
 #endif
 }
diff --git a/source/blender/modifiers/intern/MOD_fluidsim_util.h b/source/blender/modifiers/intern/MOD_fluidsim_util.h
index a06c74cb8dd..f8af8e6f583 100644
--- a/source/blender/modifiers/intern/MOD_fluidsim_util.h
+++ b/source/blender/modifiers/intern/MOD_fluidsim_util.h
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -27,6 +27,11 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/modifiers/intern/MOD_fluidsim_util.h
+ *  \ingroup modifiers
+ */
+
+
 #ifndef MOD_FLUIDSIM_UTIL_H
 #define MOD_FLUIDSIM_UTIL_H
 
@@ -42,6 +47,6 @@ void fluidsim_free(struct FluidsimModifierData *fluidmd);
 struct DerivedMesh *fluidsimModifier_do(struct FluidsimModifierData *fluidmd,
 	struct Scene *scene, struct Object *ob, struct DerivedMesh *dm,
 	int useRenderParams, int isFinalCalc);
-	
+
 #endif
 
diff --git a/source/blender/modifiers/intern/MOD_hook.c b/source/blender/modifiers/intern/MOD_hook.c
index 2c9ae311585..2a85378f987 100644
--- a/source/blender/modifiers/intern/MOD_hook.c
+++ b/source/blender/modifiers/intern/MOD_hook.c
@@ -30,20 +30,28 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_hook.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_action.h"
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
 #include "BKE_deform.h"
 
+
 #include "depsgraph_private.h"
 #include "MEM_guardedalloc.h"
 
+#include "MOD_util.h"
 
 static void initData(ModifierData *md) 
 {
@@ -68,13 +76,14 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strncpy(thmd->subtarget, hmd->subtarget, 32);
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	HookModifierData *hmd = (HookModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(!hmd->indexar && hmd->name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(hmd->name[0]) dataMask |= CD_MASK_MDEFORMVERT;
+	if(hmd->indexar) dataMask |= CD_MASK_ORIGINDEX;
 
 	return dataMask;
 }
@@ -86,7 +95,7 @@ static void freeData(ModifierData *md)
 	if (hmd->indexar) MEM_freeN(hmd->indexar);
 }
 
-static int isDisabled(ModifierData *md, int useRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
 {
 	HookModifierData *hmd = (HookModifierData*) md;
 
@@ -103,8 +112,10 @@ static void foreachObjectLink(
 	walk(userData, ob, &hmd->object);
 }
 
-static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *scene,
-					Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	HookModifierData *hmd = (HookModifierData*) md;
 
@@ -118,15 +129,37 @@ static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *sc
 	}
 }
 
-static void deformVerts(
-					 ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	 float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static float hook_falloff(float *co_1, float *co_2, const float falloff_squared, float fac)
+{
+	if(falloff_squared) {
+		float len_squared = len_squared_v3v3(co_1, co_2);
+		if(len_squared > falloff_squared) {
+			return 0.0f;
+		}
+		else if(len_squared > 0.0) {
+			return fac * (1.0 - (len_squared / falloff_squared));
+		}
+	}
+
+	return fac;
+}
+
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *dm,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	HookModifierData *hmd = (HookModifierData*) md;
 	bPoseChannel *pchan= get_pose_channel(hmd->object->pose, hmd->subtarget);
 	float vec[3], mat[4][4], dmat[4][4];
-	int i;
-	DerivedMesh *dm = derivedData;
+	int i, *index_pt;
+	const float falloff_squared= hmd->falloff * hmd->falloff; /* for faster comparisons */
+	
+	int max_dvert= 0;
+	MDeformVert *dvert= NULL;
+	int defgrp_index = -1;
 	
 	/* get world-space matrix of target, corrected for the space the verts are in */
 	if (hmd->subtarget[0] && pchan) {
@@ -141,98 +174,90 @@ static void deformVerts(
 	mul_serie_m4(mat, ob->imat, dmat, hmd->parentinv,
 			 NULL, NULL, NULL, NULL, NULL);
 
-	/* vertex indices? */
-	if(hmd->indexar) {
-		for(i = 0; i < hmd->totindex; i++) {
-			int index = hmd->indexar[i];
-
-			/* This should always be true and I don't generally like 
-			* "paranoid" style code like this, but old files can have
-			* indices that are out of range because old blender did
-			* not correct them on exit editmode. - zr
-			*/
-			if(index < numVerts) {
-				float *co = vertexCos[index];
-				float fac = hmd->force;
-
-				/* if DerivedMesh is present and has original index data,
-				* use it
-				*/
-				if(dm && dm->getVertDataArray(dm, CD_ORIGINDEX)) {
+	if((defgrp_index= defgroup_name_index(ob, hmd->name)) != -1) {
+		Mesh *me = ob->data;
+		if(dm) {
+			dvert= dm->getVertDataArray(dm, CD_MDEFORMVERT);
+			if(dvert) {
+				max_dvert = numVerts;
+			}
+		}
+		else if(me->dvert) {
+			dvert= me->dvert;
+			if(dvert) {
+				max_dvert = me->totvert;
+			}
+		}
+	}
+
+	/* Regarding index range checking below.
+	 *
+	 * This should always be true and I don't generally like 
+	 * "paranoid" style code like this, but old files can have
+	 * indices that are out of range because old blender did
+	 * not correct them on exit editmode. - zr
+	 */
+	
+	if(hmd->force == 0.0f) {
+		/* do nothing, avoid annoying checks in the loop */
+	}
+	else if(hmd->indexar) { /* vertex indices? */
+		const float fac_orig= hmd->force;
+		float fac;
+		const int *origindex_ar;
+
+		/* if DerivedMesh is present and has original index data,
+		* use it
+		*/
+		if(dm && (origindex_ar= dm->getVertDataArray(dm, CD_ORIGINDEX))) {
+			for(i= 0, index_pt= hmd->indexar; i < hmd->totindex; i++, index_pt++) {
+				if(*index_pt < numVerts) {
 					int j;
-					int orig_index;
-					for(j = 0; j < numVerts; ++j) {
-						fac = hmd->force;
-						orig_index = *(int *)dm->getVertData(dm, j,
-								CD_ORIGINDEX);
-						if(orig_index == index) {
-							co = vertexCos[j];
-							if(hmd->falloff != 0.0) {
-								float len = len_v3v3(co, hmd->cent);
-								if(len > hmd->falloff) fac = 0.0;
-								else if(len > 0.0)
-									fac *= sqrt(1.0 - len / hmd->falloff);
-							}
 
-							if(fac != 0.0) {
-								mul_v3_m4v3(vec, mat, co);
-								interp_v3_v3v3(co, co, vec, fac);
+					for(j = 0; j < numVerts; j++) {
+						if(origindex_ar[j] == *index_pt) {
+							float *co = vertexCos[j];
+							if((fac= hook_falloff(hmd->cent, co, falloff_squared, fac_orig))) {
+								if(dvert)
+									fac *= defvert_find_weight(dvert+j, defgrp_index);
+
+								if(fac) {
+									mul_v3_m4v3(vec, mat, co);
+									interp_v3_v3v3(co, co, vec, fac);
+								}
 							}
 						}
 					}
-				} else {
-					if(hmd->falloff != 0.0) {
-						float len = len_v3v3(co, hmd->cent);
-						if(len > hmd->falloff) fac = 0.0;
-						else if(len > 0.0)
-							fac *= sqrt(1.0 - len / hmd->falloff);
-					}
-
-					if(fac != 0.0) {
-						mul_v3_m4v3(vec, mat, co);
-						interp_v3_v3v3(co, co, vec, fac);
-					}
 				}
 			}
 		}
-	} 
-	else if(hmd->name[0]) {	/* vertex group hook */
-		Mesh *me = ob->data;
-		int use_dverts = 0;
-		int maxVerts = 0;
-		int defgrp_index = defgroup_name_index(ob, hmd->name);
-
-		if(dm) {
-			if(dm->getVertData(dm, 0, CD_MDEFORMVERT)) {
-				maxVerts = dm->getNumVerts(dm);
-				use_dverts = 1;
+		else { /* missing dm or ORIGINDEX */
+			for(i= 0, index_pt= hmd->indexar; i < hmd->totindex; i++, index_pt++) {
+				if(*index_pt < numVerts) {
+					float *co = vertexCos[*index_pt];
+					if((fac= hook_falloff(hmd->cent, co, falloff_squared, fac_orig))) {
+						if(dvert)
+							fac *= defvert_find_weight(dvert+(*index_pt), defgrp_index);
+
+						if(fac) {
+							mul_v3_m4v3(vec, mat, co);
+							interp_v3_v3v3(co, co, vec, fac);
+						}
+					}
+				}
 			}
 		}
-		else if(me->dvert) {
-			maxVerts = me->totvert;
-			use_dverts = 1;
-		}
+	}
+	else if(dvert) {	/* vertex group hook */
+		const float fac_orig= hmd->force;
 
-		if(defgrp_index >= 0 && use_dverts) {
-			MDeformVert *dvert = me->dvert;
-			int i;
+		for(i = 0; i < max_dvert; i++, dvert++) {
 			float fac;
+			float *co = vertexCos[i];
 
-			for(i = 0; i < maxVerts; i++, dvert++) {
-				if(dm) dvert = dm->getVertData(dm, i, CD_MDEFORMVERT);
-
-				fac= defvert_find_weight(dvert, defgrp_index);
-
-				if(fac > 0.0f) {
-					float *co = vertexCos[i];
-
-					if(hmd->falloff != 0.0) {
-						float len = len_v3v3(co, hmd->cent);
-						if(len > hmd->falloff) fac = 0.0;
-						else if(len > 0.0)
-							fac *= sqrt(1.0 - len / hmd->falloff);
-					}
-
+			if((fac= hook_falloff(hmd->cent, co, falloff_squared, fac_orig))) {
+				fac *= defvert_find_weight(dvert, defgrp_index);
+				if(fac) {
 					mul_v3_m4v3(vec, mat, co);
 					interp_v3_v3v3(co, co, vec, fac);
 				}
@@ -249,7 +274,7 @@ static void deformVertsEM(
 
 	if(!derivedData) dm = CDDM_from_editmesh(editData, ob->data);
 
-	deformVerts(md, ob, derivedData, vertexCos, numVerts, 0, 0);
+	deformVerts(md, ob, dm, vertexCos, numVerts, 0, 0);
 
 	if(!derivedData) dm->release(dm);
 }
@@ -264,6 +289,7 @@ ModifierTypeInfo modifierType_Hook = {
 							| eModifierTypeFlag_SupportsEditmode,
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -274,6 +300,7 @@ ModifierTypeInfo modifierType_Hook = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_lattice.c b/source/blender/modifiers/intern/MOD_lattice.c
index 4270f2ff6e8..22427d04338 100644
--- a/source/blender/modifiers/intern/MOD_lattice.c
+++ b/source/blender/modifiers/intern/MOD_lattice.c
@@ -30,10 +30,18 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_lattice.c
+ *  \ingroup modifiers
+ */
+
+
 #include <string.h>
 
 #include "DNA_object_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_lattice.h"
 #include "BKE_modifier.h"
@@ -52,18 +60,18 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strncpy(tlmd->name, lmd->name, 32);
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	LatticeModifierData *lmd = (LatticeModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(lmd->name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(lmd->name[0]) dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
 
-static int isDisabled(ModifierData *md, int userRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(userRenderParams))
 {
 	LatticeModifierData *lmd = (LatticeModifierData*) md;
 
@@ -80,8 +88,10 @@ static void foreachObjectLink(
 	walk(userData, ob, &lmd->object);
 }
 
-static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *scene,
-					   Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	LatticeModifierData *lmd = (LatticeModifierData*) md;
 
@@ -93,9 +103,12 @@ static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *sc
 	}
 }
 
-static void deformVerts(
-					ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	 float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	LatticeModifierData *lmd = (LatticeModifierData*) md;
 
@@ -129,6 +142,7 @@ ModifierTypeInfo modifierType_Lattice = {
 							| eModifierTypeFlag_SupportsEditmode,
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -139,6 +153,7 @@ ModifierTypeInfo modifierType_Lattice = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_mask.c b/source/blender/modifiers/intern/MOD_mask.c
index 6a62ce645d8..7b969f9322e 100644
--- a/source/blender/modifiers/intern/MOD_mask.c
+++ b/source/blender/modifiers/intern/MOD_mask.c
@@ -30,8 +30,14 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_mask.c
+ *  \ingroup modifiers
+ */
+
+
 #include "MEM_guardedalloc.h"
 
+#include "BLI_utildefines.h"
 #include "BLI_ghash.h"
 
 #include "DNA_armature_types.h"
@@ -46,18 +52,20 @@
 
 #include "depsgraph_private.h"
 
+#include "MOD_util.h"
 
 static void copyData(ModifierData *md, ModifierData *target)
 {
 	MaskModifierData *mmd = (MaskModifierData*) md;
 	MaskModifierData *tmmd = (MaskModifierData*) target;
 	
-	strcpy(tmmd->vgroup, mmd->vgroup);
+	BLI_strncpy(tmmd->vgroup, mmd->vgroup, sizeof(tmmd->vgroup));
+	tmmd->flag = mmd->flag;
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
 {
-	return (1 << CD_MDEFORMVERT);
+	return CD_MASK_MDEFORMVERT;
 }
 
 static void foreachObjectLink(
@@ -69,8 +77,10 @@ static void foreachObjectLink(
 	walk(userData, ob, &mmd->ob_arm);
 }
 
-static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *scene,
-					   Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	MaskModifierData *mmd = (MaskModifierData *)md;
 
@@ -84,8 +94,9 @@ static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *sc
 }
 
 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
-		DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	MaskModifierData *mmd= (MaskModifierData *)md;
 	DerivedMesh *dm= derivedData, *result= NULL;
@@ -129,7 +140,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 			return derivedData;		
 		
 		/* hashes for finding mapping of:
-		 * 	- vgroups to indicies -> vgroupHash  (string, int)
+		 * 	- vgroups to indices -> vgroupHash  (string, int)
 		 *	- bones to vgroup indices -> boneHash (index of vgroup, dummy)
 		 */
 		vgroupHash= BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "mask vgroup gh");
@@ -398,6 +409,7 @@ ModifierTypeInfo modifierType_Mask = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -408,6 +420,7 @@ ModifierTypeInfo modifierType_Mask = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_meshdeform.c b/source/blender/modifiers/intern/MOD_meshdeform.c
index b89db2fdc2d..a34eff6120c 100644
--- a/source/blender/modifiers/intern/MOD_meshdeform.c
+++ b/source/blender/modifiers/intern/MOD_meshdeform.c
@@ -30,11 +30,17 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_meshdeform.c
+ *  \ingroup modifiers
+ */
+
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
+
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_global.h"
@@ -78,18 +84,18 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tmmd->object = mmd->object;
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {	
 	MeshDeformModifierData *mmd = (MeshDeformModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(mmd->defgrp_name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(mmd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
 
-static int isDisabled(ModifierData *md, int useRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
 {
 	MeshDeformModifierData *mmd = (MeshDeformModifierData*) md;
 
@@ -106,9 +112,10 @@ static void foreachObjectLink(
 	walk(userData, ob, &mmd->object);
 }
 
-static void updateDepgraph(
-						  ModifierData *md, DagForest *forest, struct Scene *scene, Object *ob,
-	   DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	MeshDeformModifierData *mmd = (MeshDeformModifierData*) md;
 
@@ -205,7 +212,7 @@ static void meshdeformModifier_do(
 	/* if we don't have one computed, use derivedmesh from data
 	 * without any modifiers */
 	if(!cagedm) {
-		cagedm= get_dm(md->scene, mmd->object, NULL, NULL, NULL, 0);
+		cagedm= get_dm(mmd->object, NULL, NULL, NULL, 0);
 		if(cagedm)
 			cagedm->needsFree= 1;
 	}
@@ -339,11 +346,14 @@ static void meshdeformModifier_do(
 	cagedm->release(cagedm);
 }
 
-static void deformVerts(
-					   ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
-	DerivedMesh *dm= get_dm(md->scene, ob, NULL, derivedData, NULL, 0);;
+	DerivedMesh *dm= get_dm(ob, NULL, derivedData, NULL, 0);
 
 	modifier_vgroup_cache(md, vertexCos); /* if next modifier needs original vertices */
 	
@@ -353,10 +363,13 @@ static void deformVerts(
 		dm->release(dm);
 }
 
-static void deformVertsEM(ModifierData *md, Object *ob, struct BMEditMesh *editData,
-	  DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
+static void deformVertsEM(ModifierData *md, Object *ob,
+						struct EditMesh *UNUSED(editData),
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts)
 {
-	DerivedMesh *dm= get_dm(md->scene, ob, NULL, derivedData, NULL, 0);;
+	DerivedMesh *dm= get_dm(ob, NULL, derivedData, NULL, 0);
 
 	meshdeformModifier_do(md, ob, dm, vertexCos, numVerts);
 
@@ -437,6 +450,7 @@ ModifierTypeInfo modifierType_MeshDeform = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -447,6 +461,7 @@ ModifierTypeInfo modifierType_MeshDeform = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_mirror.c b/source/blender/modifiers/intern/MOD_mirror.c
index f393d834874..2540a1e3b3b 100644
--- a/source/blender/modifiers/intern/MOD_mirror.c
+++ b/source/blender/modifiers/intern/MOD_mirror.c
@@ -71,8 +71,9 @@ static void foreachObjectLink(
 		 void *userData)
 {
 	MirrorModifierData *mmd = (MirrorModifierData*) md;
-
-	walk(userData, ob, &mmd->mirror_ob);
+	
+	if (mmd->mirror_ob)
+		walk(userData, ob, &mmd->mirror_ob);
 }
 
 static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *scene,
@@ -233,7 +234,7 @@ static DerivedMesh *applyModifier(
 }
 
 static DerivedMesh *applyModifierEM(
-		ModifierData *md, Object *ob, struct EditMesh *editData,
+		ModifierData *md, Object *ob, struct BMEditMesh *editData,
   DerivedMesh *derivedData)
 {
 	return applyModifier(md, ob, derivedData, 0, 1);
@@ -254,6 +255,7 @@ ModifierTypeInfo modifierType_Mirror = {
 	/* copyData */          copyData,
 	/* deformVerts */       0,
 	/* deformVertsEM */     0,
+	/* deformMatrices */    0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
 	/* applyModifierEM */   applyModifierEM,
diff --git a/source/blender/modifiers/intern/MOD_multires.c b/source/blender/modifiers/intern/MOD_multires.c
index 699ab44a75c..b61302d118b 100644
--- a/source/blender/modifiers/intern/MOD_multires.c
+++ b/source/blender/modifiers/intern/MOD_multires.c
@@ -30,6 +30,11 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_multires.c
+ *  \ingroup modifiers
+ */
+
+
 #include <stddef.h>
 
 #include "BKE_cdderivedmesh.h"
@@ -40,6 +45,8 @@
 
 #include "DNA_mesh_types.h"
 
+#include "MOD_util.h"
+
 static void initData(ModifierData *md)
 {
 	MultiresModifierData *mmd = (MultiresModifierData*)md;
@@ -59,6 +66,8 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tmmd->sculptlvl = mmd->sculptlvl;
 	tmmd->renderlvl = mmd->renderlvl;
 	tmmd->totlvl = mmd->totlvl;
+	tmmd->simple = mmd->simple;
+	tmmd->flags = mmd->flags;
 }
 
 static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *dm,
@@ -72,9 +81,8 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *dm,
 
 	if(mmd->totlvl) {
 		if(!CustomData_get_layer(&me->ldata, CD_MDISPS)) {
-			/* multires can't work without displacement layer */
-			modifier_setError(md, "Modifier needs mesh with displacement data.");
-			return dm;
+			/* multires always needs a displacement layer */
+			CustomData_add_layer(&me->fdata, CD_MDISPS, CD_CALLOC, NULL, me->totface);
 		}
 	}
 
@@ -108,6 +116,7 @@ ModifierTypeInfo modifierType_Multires = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -118,6 +127,7 @@ ModifierTypeInfo modifierType_Multires = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_none.c b/source/blender/modifiers/intern/MOD_none.c
index 0c749b79f5a..bebb9b58774 100644
--- a/source/blender/modifiers/intern/MOD_none.c
+++ b/source/blender/modifiers/intern/MOD_none.c
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -34,13 +34,22 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/modifiers/intern/MOD_none.c
+ *  \ingroup modifiers
+ */
+
+
+
+
+#include "BLI_utildefines.h"
+
 #include "MOD_modifiertypes.h"
 
 /* We only need to define isDisabled; because it always returns 1,
  * no other functions will be called
  */
 
-static int isDisabled(ModifierData *md, int userRenderParams)
+static int isDisabled(ModifierData *UNUSED(md), int UNUSED(userRenderParams))
 {
 	return 1;
 }
@@ -55,6 +64,7 @@ ModifierTypeInfo modifierType_None = {
 
 	/* copyData */          0,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -65,6 +75,7 @@ ModifierTypeInfo modifierType_None = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_particleinstance.c b/source/blender/modifiers/intern/MOD_particleinstance.c
index 100a22603d5..92c8b089360 100644
--- a/source/blender/modifiers/intern/MOD_particleinstance.c
+++ b/source/blender/modifiers/intern/MOD_particleinstance.c
@@ -30,6 +30,11 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_particleinstance.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_meshdata_types.h"
 
 #include "MEM_guardedalloc.h"
@@ -37,13 +42,15 @@
 #include "BLI_math.h"
 #include "BLI_listbase.h"
 #include "BLI_rand.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_lattice.h"
 #include "BKE_modifier.h"
 #include "BKE_particle.h"
 #include "BKE_pointcache.h"
-#include "BKE_utildefines.h"
+
+#include "MOD_util.h"
 
 #include "depsgraph_private.h"
 
@@ -72,12 +79,14 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tpimd->random_position = pimd->random_position;
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 0;
 }
 static void updateDepgraph(ModifierData *md, DagForest *forest,
-		 struct Scene *scene,Object *ob, DagNode *obNode)
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	ParticleInstanceModifierData *pimd = (ParticleInstanceModifierData*) md;
 
@@ -98,9 +107,10 @@ static void foreachObjectLink(ModifierData *md, Object *ob,
 	walk(userData, ob, &pimd->ob);
 }
 
-static DerivedMesh * applyModifier(
-		ModifierData *md, Object *ob, DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+static DerivedMesh * applyModifier(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm = derivedData, *result;
 	ParticleInstanceModifierData *pimd= (ParticleInstanceModifierData*) md;
@@ -310,10 +320,9 @@ static DerivedMesh * applyModifier(
 
 	return dm;
 }
-
-static DerivedMesh *applyModifierEM(
-		ModifierData *md, Object *ob, struct EditMesh *editData,
-  DerivedMesh *derivedData)
+static DerivedMesh *applyModifierEM(ModifierData *md, Object *ob,
+						struct EditMesh *UNUSED(editData),
+						DerivedMesh *derivedData)
 {
 	return applyModifier(md, ob, derivedData, 0, 1);
 }
@@ -331,6 +340,7 @@ ModifierTypeInfo modifierType_ParticleInstance = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -341,6 +351,7 @@ ModifierTypeInfo modifierType_ParticleInstance = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_particlesystem.c b/source/blender/modifiers/intern/MOD_particlesystem.c
index 4feeef54882..80c96fd8553 100644
--- a/source/blender/modifiers/intern/MOD_particlesystem.c
+++ b/source/blender/modifiers/intern/MOD_particlesystem.c
@@ -30,10 +30,18 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_particlesystem.c
+ *  \ingroup modifiers
+ */
+
+
 #include "stddef.h"
 
 #include "DNA_material_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_material.h"
 #include "BKE_modifier.h"
@@ -77,41 +85,36 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tpsmd->psys = psmd->psys;
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	ParticleSystemModifierData *psmd= (ParticleSystemModifierData*) md;
 	CustomDataMask dataMask = 0;
-	Material *ma;
 	MTex *mtex;
 	int i;
 
 	if(!psmd->psys->part)
 		return 0;
 
-	ma= give_current_material(ob, psmd->psys->part->omat);
-	if(ma) {
-		for(i=0; i<MAX_MTEX; i++) {
-			mtex=ma->mtex[i];
-			if(mtex && (ma->septex & (1<<i))==0)
-				if(mtex->pmapto && (mtex->texco & TEXCO_UV))
-					dataMask |= (1 << CD_MTFACE);
-		}
+	for(i=0; i<MAX_MTEX; i++) {
+		mtex = psmd->psys->part->mtex[i];
+		if(mtex && mtex->mapto && (mtex->texco & TEXCO_UV))
+			dataMask |= CD_MASK_MTFACE;
 	}
 
 	if(psmd->psys->part->tanfac!=0.0)
-		dataMask |= (1 << CD_MTFACE);
+		dataMask |= CD_MASK_MTFACE;
 
 	/* ask for vertexgroups if we need them */
 	for(i=0; i<PSYS_TOT_VG; i++){
 		if(psmd->psys->vgroup[i]){
-			dataMask |= (1 << CD_MDEFORMVERT);
+			dataMask |= CD_MASK_MDEFORMVERT;
 			break;
 		}
 	}
 	
 	/* particles only need this if they are after a non deform modifier, and
 	* the modifier stack will only create them in that case. */
-	dataMask |= CD_MASK_ORIGSPACE;
+	dataMask |= CD_MASK_ORIGSPACE|CD_MASK_ORIGINDEX;
 
 	dataMask |= CD_MASK_ORCO;
 	
@@ -119,9 +122,12 @@ static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
 }
 
 /* saves the current emitter state for a particle system and calculates particles */
-static void deformVerts(
-						   ModifierData *md, Object *ob, DerivedMesh *derivedData,
-		float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int UNUSED(numVerts),
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm = derivedData;
 	ParticleSystemModifierData *psmd= (ParticleSystemModifierData*) md;
@@ -137,7 +143,7 @@ static void deformVerts(
 		return;
 
 	if(dm==0) {
-		dm= get_dm(md->scene, ob, NULL, NULL, vertexCos, 1);
+		dm= get_dm(ob, NULL, NULL, vertexCos, 1);
 
 		if(!dm)
 			return;
@@ -150,6 +156,14 @@ static void deformVerts(
 		psmd->dm->needsFree = 1;
 		psmd->dm->release(psmd->dm);
 	}
+	else if(psmd->flag & eParticleSystemFlag_file_loaded) {
+		/* in file read dm just wasn't saved in file so no need to reset everything */
+		psmd->flag &= ~eParticleSystemFlag_file_loaded;
+	}
+	else {
+		/* no dm before, so recalc particles fully */
+		psys->recalc |= PSYS_RECALC_RESET;
+	}
 
 	/* make new dm */
 	psmd->dm=CDDM_copy(dm, 0);
@@ -168,10 +182,8 @@ static void deformVerts(
 	if(psmd->dm->getNumVerts(psmd->dm)!=psmd->totdmvert ||
 		  psmd->dm->getNumEdges(psmd->dm)!=psmd->totdmedge ||
 		  psmd->dm->getNumTessFaces(psmd->dm)!=psmd->totdmface){
-		/* in file read dm hasn't really changed but just wasn't saved in file */
 
 		psys->recalc |= PSYS_RECALC_RESET;
-		psmd->flag |= eParticleSystemFlag_DM_changed;
 
 		psmd->totdmvert= psmd->dm->getNumVerts(psmd->dm);
 		psmd->totdmedge= psmd->dm->getNumEdges(psmd->dm);
@@ -182,7 +194,6 @@ static void deformVerts(
 		psmd->flag &= ~eParticleSystemFlag_psys_updated;
 		particle_system_update(md->scene, ob, psys);
 		psmd->flag |= eParticleSystemFlag_psys_updated;
-		psmd->flag &= ~eParticleSystemFlag_DM_changed;
 	}
 }
 
@@ -218,6 +229,7 @@ ModifierTypeInfo modifierType_ParticleSystem = {
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
 	/* deformVertsEM */     0 /* deformVertsEM */ ,
+	/* deformMatrices */    0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
 	/* applyModifierEM */   0,
@@ -227,6 +239,7 @@ ModifierTypeInfo modifierType_ParticleSystem = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_screw.c b/source/blender/modifiers/intern/MOD_screw.c
index 7cec359fd33..68ad5437585 100644
--- a/source/blender/modifiers/intern/MOD_screw.c
+++ b/source/blender/modifiers/intern/MOD_screw.c
@@ -30,12 +30,19 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_screw.c
+ *  \ingroup modifiers
+ */
+
+
 /* Screw modifier: revolves the edges about an axis */
 
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
+
 
 #include "BKE_cdderivedmesh.h"
 
@@ -128,8 +135,9 @@ static void copyData(ModifierData *md, ModifierData *target)
 }
 
 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
-										DerivedMesh *derivedData,
-										int useRenderParams, int isFinalCalc)
+						DerivedMesh *derivedData,
+						int useRenderParams,
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm= derivedData;
 	DerivedMesh *result;
@@ -140,7 +148,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	int step;
 	int i, j;
 	int i1,i2;
-	int step_tot= ltmd->steps;
+	int step_tot= useRenderParams ? ltmd->render_steps : ltmd->steps;
 	const int do_flip = ltmd->flag & MOD_SCREW_NORMAL_FLIP ? 1 : 0;
 	int maxVerts=0, maxEdges=0, maxFaces=0;
 	int totvert= dm->getNumVerts(dm);
@@ -166,17 +174,10 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 	ScrewVertConnect *vc, *vc_tmp, *vert_connect= NULL;
 
-	float mat[4][4] =	{{0.0f, 0.0f, 0.0f, 0.0f},
-						 {0.0f, 0.0f, 0.0f, 0.0f},
-						 {0.0f, 0.0f, 0.0f, 0.0f},
-						 {0.0f, 0.0f, 0.0f, 1.0f}};
-
 	/* dont do anything? */
 	if (!totvert)
 		return CDDM_from_template(dm, 0, 0, 0, 0, 0);
 
-	step_tot= useRenderParams ? ltmd->render_steps : ltmd->steps;
-
 	switch(ltmd->axis) {
 	case 0:
 		other_axis_1=1;
@@ -221,7 +222,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 
 		/* angle */
 
-#if 0	// cant incluide this, not pradictable enough, though quite fun,.
+#if 0	// cant incluide this, not predictable enough, though quite fun,.
 		if(ltmd->flag & MOD_SCREW_OBJECT_ANGLE) {
 			float mtx3_tx[3][3];
 			copy_m3_m4(mtx3_tx, mtx_tx);
@@ -270,7 +271,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	step_tot = ((step_tot + 1) * ltmd->iter) - (ltmd->iter - 1);
 
 	/* will the screw be closed?
-	 * Note! smaller then FLT_EPSILON*100 gives problems with float precission so its never closed. */
+	 * Note! smaller then FLT_EPSILON*100 gives problems with float precision so its never closed. */
 	if (fabs(screw_ofs) <= (FLT_EPSILON*100) && fabs(fabs(angle) - (M_PI * 2)) <= (FLT_EPSILON*100)) {
 		close= 1;
 		step_tot--;
@@ -304,6 +305,8 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	medge_new =		result->getEdgeArray(result);
 	
 	origindex= result->getTessFaceDataArray(result, CD_ORIGINDEX);
+
+	DM_copy_vert_data(dm, result, 0, 0, totvert); /* copy first otherwise this overwrites our own vertex normals */
 	
 	/* Set the locations of the first set of verts */
 	
@@ -435,15 +438,15 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 			/* find the first vert */
 			vc= vert_connect;
 			for (i=0; i < totvert; i++, vc++) {
-				int v_best=-1, ed_loop_closed=0; /* vert and vert new */
-				int ed_loop_flip= 0; /* compiler complains if not initialized, but it should be initialized below */
-				float fl= -1.0f;
-				ScrewVertIter lt_iter;
-
 				/* Now do search for connected verts, order all edges and flip them
 				 * so resulting faces are flipped the right way */
 				vc_tot_linked= 0; /* count the number of linked verts for this loop */
 				if (vc->flag == 0) {
+					int v_best=-1, ed_loop_closed=0; /* vert and vert new */
+					ScrewVertIter lt_iter;
+					int ed_loop_flip= 0; /* compiler complains if not initialized, but it should be initialized below */
+					float fl= -1.0f;
+
 					/*printf("Loop on connected vert: %i\n", i);*/
 
 					for(j=0; j<2; j++) {
@@ -665,13 +668,12 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	}
 	/* done with edge connectivity based normal flipping */
 	
-	DM_copy_vert_data(dm, result, 0, 0, totvert);
-	
 	/* Add Faces */
 	for (step=1; step < step_tot; step++) {
 		const int varray_stride= totvert * step;
 		float step_angle;
 		float nor_tx[3];
+		float mat[4][4];
 		/* Rotation Matrix */
 		step_angle= (angle / (step_tot - (!close))) * step;
 
@@ -831,12 +833,15 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	dm = CDDM_copy(result, 1); /*builds ngon faces from tess (mface) faces*/
 	result->needsFree = 1;
 	result->release(result);
+	
+	return dm;
 }
 
 
-static void updateDepgraph(
-									ModifierData *md, DagForest *forest,
-									struct Scene *scene, Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	ScrewModifierData *ltmd= (ScrewModifierData*) md;
 
@@ -861,13 +866,15 @@ static void foreachObjectLink(
 
 /* This dosnt work with material*/
 static DerivedMesh *applyModifierEM(
-						ModifierData *md, Object *ob, struct EditMesh *editData,
+						ModifierData *md,
+						Object *ob,
+						struct EditMesh *UNUSED(editData),
 						DerivedMesh *derivedData)
 {
 	return applyModifier(md, ob, derivedData, 0, 1);
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 0;
 }
@@ -886,6 +893,7 @@ ModifierTypeInfo modifierType_Screw = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -896,6 +904,7 @@ ModifierTypeInfo modifierType_Screw = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_shapekey.c b/source/blender/modifiers/intern/MOD_shapekey.c
index f73dcc25235..94d23de6573 100644
--- a/source/blender/modifiers/intern/MOD_shapekey.c
+++ b/source/blender/modifiers/intern/MOD_shapekey.c
@@ -30,10 +30,18 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_shapekey.c
+ *  \ingroup modifiers
+ */
+
+
 #include "BLI_math.h"
 
 #include "DNA_key_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_key.h"
 #include "BKE_particle.h"
@@ -42,9 +50,12 @@
 
 #include "MEM_guardedalloc.h"
 
-static void deformVerts(
-					 ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	  float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *UNUSED(derivedData),
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	KeyBlock *kb= ob_get_keyblock(ob);
 	float (*deformedVerts)[3];
@@ -58,9 +69,33 @@ static void deformVerts(
 	}
 }
 
-static void deformVertsEM(
-					   ModifierData *md, Object *ob, struct EditMesh *editData,
-	DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
+static void deformMatrices(ModifierData *md, Object *ob, DerivedMesh *derivedData,
+						   float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
+{
+	Key *key= ob_get_key(ob);
+	KeyBlock *kb= ob_get_keyblock(ob);
+	float scale[3][3];
+
+	(void)vertexCos; /* unused */
+
+	if(kb && kb->totelem==numVerts && kb!=key->refkey) {
+		int a;
+
+		if(ob->shapeflag & OB_SHAPE_LOCK) scale_m3_fl(scale, 1);
+		else scale_m3_fl(scale, kb->curval);
+
+		for(a=0; a<numVerts; a++)
+			copy_m3_m3(defMats[a], scale);
+	}
+
+	deformVerts(md, ob, derivedData, vertexCos, numVerts, 0, 0);
+}
+
+static void deformVertsEM(ModifierData *md, Object *ob,
+						struct EditMesh *UNUSED(editData),
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts)
 {
 	Key *key= ob_get_key(ob);
 
@@ -68,17 +103,21 @@ static void deformVertsEM(
 		deformVerts(md, ob, derivedData, vertexCos, numVerts, 0, 0);
 }
 
-static void deformMatricesEM(
-						  ModifierData *md, Object *ob, struct EditMesh *editData,
-	   DerivedMesh *derivedData, float (*vertexCos)[3],
-						 float (*defMats)[3][3], int numVerts)
+static void deformMatricesEM(ModifierData *UNUSED(md), Object *ob,
+						struct EditMesh *UNUSED(editData),
+						DerivedMesh *UNUSED(derivedData),
+						float (*vertexCos)[3],
+						float (*defMats)[3][3],
+						int numVerts)
 {
 	Key *key= ob_get_key(ob);
 	KeyBlock *kb= ob_get_keyblock(ob);
 	float scale[3][3];
-	int a;
+
+	(void)vertexCos; /* unused */
 
 	if(kb && kb->totelem==numVerts && kb!=key->refkey) {
+		int a;
 		scale_m3_fl(scale, kb->curval);
 
 		for(a=0; a<numVerts; a++)
@@ -86,7 +125,6 @@ static void deformMatricesEM(
 	}
 }
 
-
 ModifierTypeInfo modifierType_ShapeKey = {
 	/* name */              "ShapeKey",
 	/* structName */        "ShapeKeyModifierData",
@@ -95,18 +133,20 @@ ModifierTypeInfo modifierType_ShapeKey = {
 	/* flags */             eModifierTypeFlag_AcceptsCVs
 							| eModifierTypeFlag_SupportsEditmode,
 
-	/* copyData */          0,
+	/* copyData */          NULL,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    deformMatrices,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  deformMatricesEM,
-	/* applyModifier */     0,
-	/* applyModifierEM */   0,
-	/* initData */          0,
-	/* requiredDataMask */  0,
-	/* freeData */          0,
-	/* isDisabled */        0,
-	/* updateDepgraph */    0,
-	/* dependsOnTime */     0,
-	/* foreachObjectLink */ 0,
-	/* foreachIDLink */     0,
+	/* applyModifier */     NULL,
+	/* applyModifierEM */   NULL,
+	/* initData */          NULL,
+	/* requiredDataMask */  NULL,
+	/* freeData */          NULL,
+	/* isDisabled */        NULL,
+	/* updateDepgraph */    NULL,
+	/* dependsOnTime */     NULL,
+	/* dependsOnNormals */	NULL,
+	/* foreachObjectLink */ NULL,
+	/* foreachIDLink */     NULL
 };
diff --git a/source/blender/modifiers/intern/MOD_shrinkwrap.c b/source/blender/modifiers/intern/MOD_shrinkwrap.c
index 6526be4cb53..cfd12833a38 100644
--- a/source/blender/modifiers/intern/MOD_shrinkwrap.c
+++ b/source/blender/modifiers/intern/MOD_shrinkwrap.c
@@ -30,8 +30,16 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_shrinkwrap.c
+ *  \ingroup modifiers
+ */
+
+
 #include <string.h>
 
+#include "BLI_string.h"
+#include "BLI_utildefines.h"
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
 #include "BKE_shrinkwrap.h"
@@ -62,7 +70,7 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tsmd->target	= smd->target;
 	tsmd->auxTarget = smd->auxTarget;
 
-	strcpy(tsmd->vgroup_name, smd->vgroup_name);
+	BLI_strncpy(tsmd->vgroup_name, smd->vgroup_name, sizeof(tsmd->vgroup_name));
 
 	tsmd->keepDist	= smd->keepDist;
 	tsmd->shrinkType= smd->shrinkType;
@@ -71,23 +79,23 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tsmd->subsurfLevels = smd->subsurfLevels;
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	ShrinkwrapModifierData *smd = (ShrinkwrapModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
 	if(smd->vgroup_name[0])
-		dataMask |= (1 << CD_MDEFORMVERT);
+		dataMask |= CD_MASK_MDEFORMVERT;
 
 	if(smd->shrinkType == MOD_SHRINKWRAP_PROJECT
 	&& smd->projAxis == MOD_SHRINKWRAP_PROJECT_OVER_NORMAL)
-		dataMask |= (1 << CD_MVERT);
+		dataMask |= CD_MASK_MVERT;
 		
 	return dataMask;
 }
 
-static int isDisabled(ModifierData *md, int useRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
 {
 	ShrinkwrapModifierData *smd = (ShrinkwrapModifierData*) md;
 	return !smd->target;
@@ -102,16 +110,21 @@ static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk,
 	walk(userData, ob, &smd->auxTarget);
 }
 
-static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm = derivedData;
 	CustomDataMask dataMask = requiredDataMask(ob, md);
 
 	/* ensure we get a CDDM with applied vertex coords */
 	if(dataMask)
-		dm= get_cddm(md->scene, ob, NULL, dm, vertexCos);
+		dm= get_cddm(ob, NULL, dm, vertexCos);
 
-	shrinkwrapModifier_deform((ShrinkwrapModifierData*)md, md->scene, ob, dm, vertexCos, numVerts);
+	shrinkwrapModifier_deform((ShrinkwrapModifierData*)md, ob, dm, vertexCos, numVerts);
 
 	if(dm != derivedData)
 		dm->release(dm);
@@ -124,15 +137,18 @@ static void deformVertsEM(ModifierData *md, Object *ob, struct EditMesh *editDat
 
 	/* ensure we get a CDDM with applied vertex coords */
 	if(dataMask)
-		dm= get_cddm(md->scene, ob, editData, dm, vertexCos);
+		dm= get_cddm(ob, editData, dm, vertexCos);
 
-	shrinkwrapModifier_deform((ShrinkwrapModifierData*)md, md->scene, ob, dm, vertexCos, numVerts);
+	shrinkwrapModifier_deform((ShrinkwrapModifierData*)md, ob, dm, vertexCos, numVerts);
 
 	if(dm != derivedData)
 		dm->release(dm);
 }
 
-static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *scene, Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	ShrinkwrapModifierData *smd = (ShrinkwrapModifierData*) md;
 
@@ -156,6 +172,7 @@ ModifierTypeInfo modifierType_Shrinkwrap = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -166,6 +183,7 @@ ModifierTypeInfo modifierType_Shrinkwrap = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_simpledeform.c b/source/blender/modifiers/intern/MOD_simpledeform.c
index c64fec4075d..0150322ae8c 100644
--- a/source/blender/modifiers/intern/MOD_simpledeform.c
+++ b/source/blender/modifiers/intern/MOD_simpledeform.c
@@ -30,17 +30,24 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_simpledeform.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 
 #include "BLI_math.h"
+#include "BLI_string.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_lattice.h"
 #include "BKE_modifier.h"
 #include "BKE_deform.h"
 #include "BKE_shrinkwrap.h"
-#include "BKE_utildefines.h"
+
 
 #include "depsgraph_private.h"
 
@@ -146,7 +153,7 @@ static void simpleDeform_bend(const float factor, const float dcut[3], float *co
 
 
 /* simple deform modifier */
-void SimpleDeformModifier_do(SimpleDeformModifierData *smd, struct Object *ob, struct DerivedMesh *dm, float (*vertexCos)[3], int numVerts)
+static void SimpleDeformModifier_do(SimpleDeformModifierData *smd, struct Object *ob, struct DerivedMesh *dm, float (*vertexCos)[3], int numVerts)
 {
 	static const float lock_axis[2] = {0.0f, 0.0f};
 
@@ -287,17 +294,17 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tsmd->originOpts= smd->originOpts;
 	tsmd->factor= smd->factor;
 	memcpy(tsmd->limit, smd->limit, sizeof(tsmd->limit));
-	strcpy(tsmd->vgroup_name, smd->vgroup_name);
+	BLI_strncpy(tsmd->vgroup_name, smd->vgroup_name, sizeof(tsmd->vgroup_name));
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	SimpleDeformModifierData *smd = (SimpleDeformModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
 	if(smd->vgroup_name[0])
-		dataMask |= (1 << CD_MDEFORMVERT);
+		dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
@@ -308,7 +315,10 @@ static void foreachObjectLink(ModifierData *md, Object *ob, void (*walk)(void *u
 	walk(userData, ob, &smd->origin);
 }
 
-static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *scene, Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	SimpleDeformModifierData *smd  = (SimpleDeformModifierData*)md;
 
@@ -316,7 +326,12 @@ static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *sc
 		dag_add_relation(forest, dag_get_node(forest, smd->origin), obNode, DAG_RL_OB_DATA, "SimpleDeform Modifier");
 }
 
-static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm = derivedData;
 	CustomDataMask dataMask = requiredDataMask(ob, md);
@@ -324,7 +339,7 @@ static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData,
 	/* we implement requiredDataMask but thats not really usefull since
 	   mesh_calc_modifiers pass a NULL derivedData */
 	if(dataMask)
-		dm= get_dm(md->scene, ob, NULL, dm, NULL, 0);
+		dm= get_dm(ob, NULL, dm, NULL, 0);
 
 	SimpleDeformModifier_do((SimpleDeformModifierData*)md, ob, dm, vertexCos, numVerts);
 
@@ -332,7 +347,11 @@ static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData,
 		dm->release(dm);
 }
 
-static void deformVertsEM(ModifierData *md, Object *ob, struct EditMesh *editData, DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
+static void deformVertsEM(ModifierData *md, Object *ob,
+						struct EditMesh *editData,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts)
 {
 	DerivedMesh *dm = derivedData;
 	CustomDataMask dataMask = requiredDataMask(ob, md);
@@ -340,7 +359,7 @@ static void deformVertsEM(ModifierData *md, Object *ob, struct EditMesh *editDat
 	/* we implement requiredDataMask but thats not really usefull since
 	   mesh_calc_modifiers pass a NULL derivedData */
 	if(dataMask)
-		dm= get_dm(md->scene, ob, editData, dm, NULL, 0);
+		dm= get_dm(ob, editData, dm, NULL, 0);
 
 	SimpleDeformModifier_do((SimpleDeformModifierData*)md, ob, dm, vertexCos, numVerts);
 
@@ -362,6 +381,7 @@ ModifierTypeInfo modifierType_SimpleDeform = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -372,6 +392,7 @@ ModifierTypeInfo modifierType_SimpleDeform = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_smoke.c b/source/blender/modifiers/intern/MOD_smoke.c
index 25153de7be4..46f0483dbff 100644
--- a/source/blender/modifiers/intern/MOD_smoke.c
+++ b/source/blender/modifiers/intern/MOD_smoke.c
@@ -30,11 +30,22 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_smoke.c
+ *  \ingroup modifiers
+ */
+
+
 #include "stddef.h"
 
 #include "MEM_guardedalloc.h"
 
+#include "DNA_group_types.h"
 #include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_smoke_types.h"
+
+#include "BLI_utildefines.h"
+
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
@@ -71,29 +82,34 @@ static void freeData(ModifierData *md)
 	smokeModifier_free (smd);
 }
 
-static void deformVerts(
-					 ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	  float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int UNUSED(numVerts),
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	SmokeModifierData *smd = (SmokeModifierData*) md;
-	DerivedMesh *dm = dm= get_cddm(md->scene, ob, NULL, derivedData, vertexCos);
+	DerivedMesh *dm = get_cddm(ob, NULL, derivedData, vertexCos);
 
-	smokeModifier_do(smd, md->scene, ob, dm, useRenderParams, isFinalCalc);
+	smokeModifier_do(smd, md->scene, ob, dm);
 
 	if(dm != derivedData)
 		dm->release(dm);
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 1;
 }
 
-static void updateDepgraph(
-					 ModifierData *md, DagForest *forest, struct Scene *scene, Object *ob,
-	  DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *scene,
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
-	/*SmokeModifierData *smd = (SmokeModifierData *) md;
+	SmokeModifierData *smd = (SmokeModifierData *) md;
+
 	if(smd && (smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain)
 	{
 		if(smd->domain->fluid_group)
@@ -107,7 +123,7 @@ static void updateDepgraph(
 					SmokeModifierData *smd2 = (SmokeModifierData *)modifiers_findByType(go->ob, eModifierType_Smoke);
 					
 					// check for initialized smoke object
-					if(smd2 && (smd2->type & MOD_SMOKE_TYPE_FLOW) && smd2->flow)
+					if(smd2 && (((smd2->type & MOD_SMOKE_TYPE_FLOW) && smd2->flow) || ((smd->type & MOD_SMOKE_TYPE_COLL) && smd2->coll)))
 					{
 						DagNode *curNode = dag_get_node(forest, go->ob);
 						dag_add_relation(forest, curNode, obNode, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Smoke Flow");
@@ -115,8 +131,20 @@ static void updateDepgraph(
 				}
 			}
 		}
+		else {
+			Base *base = scene->base.first;
+
+			for(; base; base = base->next) {
+				SmokeModifierData *smd2 = (SmokeModifierData *)modifiers_findByType(base->object, eModifierType_Smoke);
+
+				if(smd2 && (((smd2->type & MOD_SMOKE_TYPE_FLOW) && smd2->flow) || ((smd->type & MOD_SMOKE_TYPE_COLL) && smd2->coll)))
+				{
+					DagNode *curNode = dag_get_node(forest, base->object);
+					dag_add_relation(forest, curNode, obNode, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Smoke Flow");
+				}
+			}
+		}
 	}
-	*/
 }
 
 
@@ -131,6 +159,7 @@ ModifierTypeInfo modifierType_Smoke = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -141,6 +170,7 @@ ModifierTypeInfo modifierType_Smoke = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_smooth.c b/source/blender/modifiers/intern/MOD_smooth.c
index a42bf8abbaf..526b54d1cf8 100644
--- a/source/blender/modifiers/intern/MOD_smooth.c
+++ b/source/blender/modifiers/intern/MOD_smooth.c
@@ -30,14 +30,21 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_smooth.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_meshdata_types.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_particle.h"
 #include "BKE_deform.h"
 
+
 #include "MEM_guardedalloc.h"
 
 #include "MOD_modifiertypes.h"
@@ -65,7 +72,7 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strncpy(tsmd->defgrp_name, smd->defgrp_name, 32);
 }
 
-static int isDisabled(ModifierData *md, int useRenderParams)
+static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
 {
 	SmoothModifierData *smd = (SmoothModifierData*) md;
 	short flag;
@@ -78,13 +85,13 @@ static int isDisabled(ModifierData *md, int useRenderParams)
 	return 0;
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	SmoothModifierData *smd = (SmoothModifierData *)md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(smd->defgrp_name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(smd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
@@ -219,9 +226,9 @@ static void smoothModifier_do(
 
 static void deformVerts(
 					   ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	   float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+	   float (*vertexCos)[3], int numVerts, int UNUSED(useRenderParams), int UNUSED(isFinalCalc))
 {
-	DerivedMesh *dm= get_dm(md->scene, ob, NULL, derivedData, NULL, 0);
+	DerivedMesh *dm= get_dm(ob, NULL, derivedData, NULL, 0);
 
 	smoothModifier_do((SmoothModifierData *)md, ob, dm,
 			   vertexCos, numVerts);
@@ -234,7 +241,7 @@ static void deformVertsEM(
 					 ModifierData *md, Object *ob, struct EditMesh *editData,
 	  DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
 {
-	DerivedMesh *dm= get_dm(md->scene, ob, editData, derivedData, NULL, 0);
+	DerivedMesh *dm= get_dm(ob, editData, derivedData, NULL, 0);
 
 	smoothModifier_do((SmoothModifierData *)md, ob, dm,
 			   vertexCos, numVerts);
@@ -254,6 +261,7 @@ ModifierTypeInfo modifierType_Smooth = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -264,6 +272,7 @@ ModifierTypeInfo modifierType_Smooth = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_softbody.c b/source/blender/modifiers/intern/MOD_softbody.c
index 8f629001e0b..0abf2fa6281 100644
--- a/source/blender/modifiers/intern/MOD_softbody.c
+++ b/source/blender/modifiers/intern/MOD_softbody.c
@@ -30,22 +30,33 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_softbody.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_scene_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_particle.h"
 #include "BKE_softbody.h"
 
 #include "MOD_modifiertypes.h"
 
-static void deformVerts(
-					 ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	  float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *UNUSED(derivedData),
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	sbObjectStep(md->scene, ob, (float)md->scene->r.cfra, vertexCos, numVerts);
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 1;
 }
@@ -62,6 +73,7 @@ ModifierTypeInfo modifierType_Softbody = {
 
 	/* copyData */          0,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -72,6 +84,7 @@ ModifierTypeInfo modifierType_Softbody = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_solidify.c b/source/blender/modifiers/intern/MOD_solidify.c
index 9c17100b33f..50317e363ad 100644
--- a/source/blender/modifiers/intern/MOD_solidify.c
+++ b/source/blender/modifiers/intern/MOD_solidify.c
@@ -30,16 +30,22 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_solidify.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_meshdata_types.h"
 
 #include "BLI_math.h"
 #include "BLI_edgehash.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_mesh.h"
 #include "BKE_particle.h"
 #include "BKE_deform.h"
-#include "BKE_utildefines.h"
+
 
 #include "MOD_modifiertypes.h"
 
@@ -126,7 +132,7 @@ static void dm_calc_normal(DerivedMesh *dm, float (*temp_nors)[3])
 		}
 
 		for(edge_iter = BLI_edgehashIterator_new(edge_hash); !BLI_edgehashIterator_isDone(edge_iter); BLI_edgehashIterator_step(edge_iter)) {
-			/* Get the edge vert indicies, and edge value (the face indicies that use it)*/
+			/* Get the edge vert indices, and edge value (the face indices that use it)*/
 			BLI_edgehashIterator_getKey(edge_iter, (int*)&ed_v1, (int*)&ed_v2);
 			edge_ref = BLI_edgehashIterator_getValue(edge_iter);
 
@@ -179,35 +185,34 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strcpy(tsmd->defgrp_name, smd->defgrp_name);
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	SolidifyModifierData *smd = (SolidifyModifierData*) md;
 	CustomDataMask dataMask = 0;
 
 	/* ask for vertexgroups if we need them */
-	if(smd->defgrp_name[0]) dataMask |= (1 << CD_MDEFORMVERT);
+	if(smd->defgrp_name[0]) dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
 
 
-static DerivedMesh *applyModifier(ModifierData *md,
-						   Object *ob, 
-						   DerivedMesh *dm,
-						   int useRenderParams,
-						   int isFinalCalc)
+static DerivedMesh *applyModifier(ModifierData *md, Object *ob, 
+						DerivedMesh *dm,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	int i;
 	DerivedMesh *result, *copy;
-	SolidifyModifierData *smd = (SolidifyModifierData*) md;
+	const SolidifyModifierData *smd = (SolidifyModifierData*) md;
 
 	MFace *mf, *mface, *orig_mface;
 	MEdge *ed, *medge, *orig_medge;
 	MVert *mv, *mvert, *orig_mvert;
 
-	int numVerts = dm->getNumVerts(dm);
-	int numEdges = dm->getNumEdges(dm);
-	int numFaces = dm->getNumFaces(dm);
+	const int numVerts = dm->getNumVerts(dm);
+	const int numEdges = dm->getNumEdges(dm);
+	const int numFaces = dm->getNumFaces(dm);
 
 	/* use for edges */
 	int *new_vert_arr= NULL;
@@ -221,13 +226,13 @@ static DerivedMesh *applyModifier(ModifierData *md,
 
 	float (*vert_nors)[3]= NULL;
 
-	float ofs_orig=				- (((-smd->offset_fac + 1.0f) * 0.5f) * smd->offset);
-	float ofs_new= smd->offset	- (((-smd->offset_fac + 1.0f) * 0.5f) * smd->offset);
+	float const ofs_orig=				- (((-smd->offset_fac + 1.0f) * 0.5f) * smd->offset);
+	float const ofs_new= smd->offset	- (((-smd->offset_fac + 1.0f) * 0.5f) * smd->offset);
 
 	/* weights */
 	MDeformVert *dvert= NULL, *dv= NULL;
-	int defgrp_invert = ((smd->flag & MOD_SOLIDIFY_VGROUP_INV) != 0);
-	int defgrp_index= defgroup_name_index(ob, smd->defgrp_name);
+	const int defgrp_invert = ((smd->flag & MOD_SOLIDIFY_VGROUP_INV) != 0);
+	const int defgrp_index= defgroup_name_index(ob, smd->defgrp_name);
 
 	if (defgrp_index >= 0)
 		dvert = dm->getVertDataArray(dm, CD_MDEFORMVERT);
@@ -291,7 +296,7 @@ static DerivedMesh *applyModifier(ModifierData *md,
 
 		ehi= BLI_edgehashIterator_new(edgehash);
 		for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
-			int eidx= GET_INT_FROM_POINTER(BLI_edgehashIterator_getValue(ehi));
+			eidx= GET_INT_FROM_POINTER(BLI_edgehashIterator_getValue(ehi));
 			if(edge_users[eidx] >= 0) {
 				BLI_edgehashIterator_getKey(ehi, &v1, &v2);
 				orig_mvert[v1].flag |= ME_VERT_TMP_TAG;
@@ -408,7 +413,7 @@ static DerivedMesh *applyModifier(ModifierData *md,
 		float *vert_angles= MEM_callocN(sizeof(float) * numVerts * 2, "mod_solid_pair"); /* 2 in 1 */
 		float *vert_accum= vert_angles + numVerts;
 		float face_angles[4];
-		int i, j, vidx;
+		int j, vidx;
 
 		face_nors = CustomData_get_layer(&dm->faceData, CD_NORMAL);
 		if(!face_nors) {
@@ -442,11 +447,11 @@ static DerivedMesh *applyModifier(ModifierData *md,
 				j= 2;
 			}
 
-			for(; j>=0; j--) {
+			do {
 				vidx = *(&mf->v1 + j);
 				vert_accum[vidx] += face_angles[j];
 				vert_angles[vidx]+= shell_angle_to_dist(angle_normalized_v3v3(vert_nors[vidx], face_nors[i])) * face_angles[j];
-			}
+			} while(j--);
 		}
 
 		/* vertex group support */
@@ -634,7 +639,7 @@ static DerivedMesh *applyModifier(ModifierData *md,
 
 static DerivedMesh *applyModifierEM(ModifierData *md,
 							 Object *ob,
-							 struct EditMesh *editData,
+							 struct EditMesh *UNUSED(editData),
 							 DerivedMesh *derivedData)
 {
 	return applyModifier(md, ob, derivedData, 0, 1);
@@ -654,17 +659,19 @@ ModifierTypeInfo modifierType_Solidify = {
 							| eModifierTypeFlag_EnableInEditmode,
 
 	/* copyData */          copyData,
-	/* deformVerts */       0,
-	/* deformVertsEM */     0,
-	/* deformMatricesEM */  0,
+	/* deformVerts */       NULL,
+	/* deformMatrices */    NULL,
+	/* deformVertsEM */     NULL,
+	/* deformMatricesEM */  NULL,
 	/* applyModifier */     applyModifier,
 	/* applyModifierEM */   applyModifierEM,
 	/* initData */          initData,
 	/* requiredDataMask */  requiredDataMask,
-	/* freeData */          0,
-	/* isDisabled */        0,
-	/* updateDepgraph */    0,
-	/* dependsOnTime */     0,
-	/* foreachObjectLink */ 0,
-	/* foreachIDLink */     0,
+	/* freeData */          NULL,
+	/* isDisabled */        NULL,
+	/* updateDepgraph */    NULL,
+	/* dependsOnTime */     NULL,
+	/* dependsOnNormals */	NULL,
+	/* foreachObjectLink */ NULL,
+	/* foreachIDLink */     NULL
 };
diff --git a/source/blender/modifiers/intern/MOD_subsurf.c b/source/blender/modifiers/intern/MOD_subsurf.c
index e84d8e24faa..6d5477e5ec8 100644
--- a/source/blender/modifiers/intern/MOD_subsurf.c
+++ b/source/blender/modifiers/intern/MOD_subsurf.c
@@ -30,11 +30,19 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_subsurf.c
+ *  \ingroup modifiers
+ */
+
+
 #include "stddef.h"
 
 #include "DNA_scene_types.h"
 #include "DNA_object_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_scene.h"
 #include "BKE_subsurf.h"
@@ -83,9 +91,10 @@ static int isDisabled(ModifierData *md, int useRenderParams)
 	return get_render_subsurf_level(&md->scene->r, levels) == 0;
 }
 
-static DerivedMesh *applyModifier(
-		ModifierData *md, Object *ob, DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
+						DerivedMesh *derivedData,
+						int useRenderParams,
+						int isFinalCalc)
 {
 	SubsurfModifierData *smd = (SubsurfModifierData*) md;
 	DerivedMesh *result;
@@ -102,9 +111,9 @@ static DerivedMesh *applyModifier(
 	return result;
 }
 
-static DerivedMesh *applyModifierEM(
-		ModifierData *md, Object *ob, struct EditMesh *editData,
-  DerivedMesh *derivedData)
+static DerivedMesh *applyModifierEM(ModifierData *md, Object *UNUSED(ob),
+						struct EditMesh *UNUSED(editData),
+						DerivedMesh *derivedData)
 {
 	SubsurfModifierData *smd = (SubsurfModifierData*) md;
 	DerivedMesh *result;
@@ -129,6 +138,7 @@ ModifierTypeInfo modifierType_Subsurf = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -139,6 +149,7 @@ ModifierTypeInfo modifierType_Subsurf = {
 	/* isDisabled */        isDisabled,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_surface.c b/source/blender/modifiers/intern/MOD_surface.c
index a55d6bbd141..d229f75189f 100644
--- a/source/blender/modifiers/intern/MOD_surface.c
+++ b/source/blender/modifiers/intern/MOD_surface.c
@@ -30,11 +30,18 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_surface.c
+ *  \ingroup modifiers
+ */
+
+
 #include "DNA_scene_types.h"
 #include "DNA_object_types.h"
 #include "DNA_meshdata_types.h"
 
 #include "BLI_math.h"
+#include "BLI_utildefines.h"
+
 
 #include "BKE_cdderivedmesh.h"
 
@@ -76,24 +83,26 @@ static void freeData(ModifierData *md)
 	}
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 1;
 }
 
-static void deformVerts(
-					  ModifierData *md, Object *ob, DerivedMesh *derivedData,
-		float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int UNUSED(numVerts),
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	SurfaceModifierData *surmd = (SurfaceModifierData*) md;
-	unsigned int numverts = 0, i = 0;
 	
 	if(surmd->dm)
 		surmd->dm->release(surmd->dm);
 
 	/* if possible use/create DerivedMesh */
 	if(derivedData) surmd->dm = CDDM_copy(derivedData, 0);
-	else surmd->dm = get_dm(md->scene, ob, NULL, NULL, NULL, 0);
+	else surmd->dm = get_dm(ob, NULL, NULL, NULL, 0);
 	
 	if(!ob->pd)
 	{
@@ -103,6 +112,7 @@ static void deformVerts(
 	
 	if(surmd->dm)
 	{
+		unsigned int numverts = 0, i = 0;
 		int init = 0;
 		float *vec;
 		MVert *x, *v;
@@ -168,6 +178,7 @@ ModifierTypeInfo modifierType_Surface = {
 
 	/* copyData */          0,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -178,6 +189,7 @@ ModifierTypeInfo modifierType_Surface = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    0,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ 0,
 	/* foreachIDLink */     0,
 };
diff --git a/source/blender/modifiers/intern/MOD_util.c b/source/blender/modifiers/intern/MOD_util.c
index 25072ee7b9b..d5235736368 100644
--- a/source/blender/modifiers/intern/MOD_util.c
+++ b/source/blender/modifiers/intern/MOD_util.c
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -30,16 +30,23 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/modifiers/intern/MOD_util.c
+ *  \ingroup modifiers
+ */
+
+
 #include <string.h>
 
 #include "DNA_modifier_types.h"
 #include "DNA_object_types.h"
 #include "DNA_curve_types.h"
 
+#include "BLI_utildefines.h"
+
 #include "BKE_cdderivedmesh.h"
 #include "BKE_mesh.h"
 #include "BKE_displist.h"
-#include "BKE_utildefines.h"
+
 #include "BKE_modifier.h"
 
 #include "MOD_util.h"
@@ -53,7 +60,8 @@ void get_texture_value(Tex *texture, float *tex_co, TexResult *texres)
 {
 	int result_type;
 
-	result_type = multitex_ext(texture, tex_co, NULL, NULL, 0, texres);
+	/* no node textures for now */
+	result_type = multitex_ext_safe(texture, tex_co, texres);
 
 	/* if the texture gave an RGB value, we assume it didn't give a valid
 	* intensity, so calculate one (formula from do_material_tex).
@@ -84,13 +92,13 @@ void validate_layer_name(const CustomData *data, int type, char *name, char *out
 
 	/* if a layer name was given, try to find that layer */
 	if(name[0])
-		index = CustomData_get_named_layer_index(data, CD_MTFACE, name);
+		index = CustomData_get_named_layer_index(data, type, name);
 
 	if(index < 0) {
 		/* either no layer was specified, or the layer we want has been
 		* deleted, so assign the active layer to name
 		*/
-		index = CustomData_get_active_layer_index(data, CD_MTFACE);
+		index = CustomData_get_active_layer_index(data, type);
 		strcpy(outname, data->layers[index].name);
 	}
 	else
@@ -98,13 +106,13 @@ void validate_layer_name(const CustomData *data, int type, char *name, char *out
 }
 
 /* returns a cdderivedmesh if dm == NULL or is another type of derivedmesh */
-DerivedMesh *get_cddm(struct Scene *scene, Object *ob, struct EditMesh *em, DerivedMesh *dm, float (*vertexCos)[3])
+DerivedMesh *get_cddm(Object *ob, struct EditMesh *em, DerivedMesh *dm, float (*vertexCos)[3])
 {
 	if(dm && dm->type == DM_TYPE_CDDM)
 		return dm;
 
 	if(!dm) {
-		dm= get_dm(scene, ob, em, dm, vertexCos, 0);
+		dm= get_dm(ob, em, dm, vertexCos, 0);
 	}
 	else {
 		dm= CDDM_copy(dm, 0);
@@ -118,7 +126,7 @@ DerivedMesh *get_cddm(struct Scene *scene, Object *ob, struct EditMesh *em, Deri
 }
 
 /* returns a derived mesh if dm == NULL, for deforming modifiers that need it */
-DerivedMesh *get_dm(struct Scene *scene, Object *ob, struct EditMesh *em, DerivedMesh *dm, float (*vertexCos)[3], int orco)
+DerivedMesh *get_dm(Object *ob, struct EditMesh *em, DerivedMesh *dm, float (*vertexCos)[3], int orco)
 {
 	if(dm)
 		return dm;
@@ -143,9 +151,8 @@ DerivedMesh *get_dm(struct Scene *scene, Object *ob, struct EditMesh *em, Derive
 }
 
 /* only called by BKE_modifier.h/modifier.c */
-void modifier_type_init(ModifierTypeInfo *types[], ModifierType type)
+void modifier_type_init(ModifierTypeInfo *types[])
 {
-	memset(types, 0, sizeof(types));
 #define INIT_TYPE(typeName) (types[eModifierType_##typeName] = &modifierType_##typeName)
 	INIT_TYPE(None);
 	INIT_TYPE(Curve);
diff --git a/source/blender/modifiers/intern/MOD_util.h b/source/blender/modifiers/intern/MOD_util.h
index 5750e042199..a42151904e9 100644
--- a/source/blender/modifiers/intern/MOD_util.h
+++ b/source/blender/modifiers/intern/MOD_util.h
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -25,9 +25,17 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/modifiers/intern/MOD_util.h
+ *  \ingroup modifiers
+ */
+
+
 #ifndef MOD_UTIL_H
 #define MOD_UTIL_H
 
+/* so modifier types match their defines */
+#include "MOD_modifiertypes.h"
+
 struct Tex;
 struct TexResult;
 struct CustomData;
@@ -40,9 +48,7 @@ struct ModifierData;
 void get_texture_value(struct Tex *texture, float *tex_co, struct TexResult *texres);
 void modifier_vgroup_cache(struct ModifierData *md, float (*vertexCos)[3]);
 void validate_layer_name(const struct CustomData *data, int type, char *name, char *outname);
-struct DerivedMesh *get_cddm(struct Scene *scene, struct Object *ob, struct EditMesh *em, struct DerivedMesh *dm, float (*vertexCos)[3]);
-struct DerivedMesh *get_dm(struct Scene *scene, struct Object *ob, struct EditMesh *em, struct DerivedMesh *dm, float (*vertexCos)[3], int orco);
-
-void modifier_type_init(struct ModifierTypeInfo *types[], ModifierType type);
+struct DerivedMesh *get_cddm(struct Object *ob, struct EditMesh *em, struct DerivedMesh *dm, float (*vertexCos)[3]);
+struct DerivedMesh *get_dm(struct Object *ob, struct EditMesh *em, struct DerivedMesh *dm, float (*vertexCos)[3], int orco);
 
 #endif /* MOD_UTIL_H */
diff --git a/source/blender/modifiers/intern/MOD_uvproject.c b/source/blender/modifiers/intern/MOD_uvproject.c
index 3deef13735f..29bdde4d2f6 100644
--- a/source/blender/modifiers/intern/MOD_uvproject.c
+++ b/source/blender/modifiers/intern/MOD_uvproject.c
@@ -30,6 +30,11 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_uvproject.c
+ *  \ingroup modifiers
+ */
+
+
 /* UV Project modifier: Generates UVs projected from an object */
 
 #include "DNA_meshdata_types.h"
@@ -38,6 +43,8 @@
 
 #include "BLI_math.h"
 #include "BLI_uvproject.h"
+#include "BLI_utildefines.h"
+
 
 #include "BKE_DerivedMesh.h"
 
@@ -78,12 +85,12 @@ static void copyData(ModifierData *md, ModifierData *target)
 	tumd->scaley = umd->scaley;
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
 {
 	CustomDataMask dataMask = 0;
 
 	/* ask for UV coordinates */
-	dataMask |= (1 << CD_MTFACE);
+	dataMask |= CD_MASK_MTFACE;
 
 	return dataMask;
 }
@@ -109,8 +116,10 @@ static void foreachIDLink(ModifierData *md, Object *ob,
 						userData);
 }
 
-static void updateDepgraph(ModifierData *md,
-						 DagForest *forest, struct Scene *scene, Object *ob, DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						struct Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	UVProjectModifierData *umd = (UVProjectModifierData*) md;
 	int i;
@@ -376,9 +385,10 @@ static DerivedMesh *uvprojectModifier_do(UVProjectModifierData *umd,
 	return dm;
 }
 
-static DerivedMesh *applyModifier(
-		ModifierData *md, Object *ob, DerivedMesh *derivedData,
-  int useRenderParams, int isFinalCalc)
+static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *result;
 	UVProjectModifierData *umd = (UVProjectModifierData*) md;
@@ -388,9 +398,9 @@ static DerivedMesh *applyModifier(
 	return result;
 }
 
-static DerivedMesh *applyModifierEM(
-		ModifierData *md, Object *ob, struct EditMesh *editData,
-  DerivedMesh *derivedData)
+static DerivedMesh *applyModifierEM(ModifierData *md, Object *ob,
+						struct EditMesh *UNUSED(editData),
+						DerivedMesh *derivedData)
 {
 	return applyModifier(md, ob, derivedData, 0, 1);
 }
@@ -408,6 +418,7 @@ ModifierTypeInfo modifierType_UVProject = {
 
 	/* copyData */          copyData,
 	/* deformVerts */       0,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     0,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     applyModifier,
@@ -418,6 +429,7 @@ ModifierTypeInfo modifierType_UVProject = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     0,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     foreachIDLink,
 };
diff --git a/source/blender/modifiers/intern/MOD_wave.c b/source/blender/modifiers/intern/MOD_wave.c
index a4cf8f4a2c2..42b1369e8ca 100644
--- a/source/blender/modifiers/intern/MOD_wave.c
+++ b/source/blender/modifiers/intern/MOD_wave.c
@@ -30,12 +30,20 @@
 *
 */
 
+/** \file blender/modifiers/intern/MOD_wave.c
+ *  \ingroup modifiers
+ */
+
+
 #include "BLI_math.h"
 
 #include "DNA_meshdata_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_object_types.h"
 
+#include "BLI_utildefines.h"
+
+
 #include "BKE_DerivedMesh.h"
 #include "BKE_object.h"
 #include "BKE_deform.h"
@@ -93,7 +101,7 @@ static void copyData(ModifierData *md, ModifierData *target)
 	strncpy(twmd->defgrp_name, wmd->defgrp_name, 32);
 }
 
-static int dependsOnTime(ModifierData *md)
+static int dependsOnTime(ModifierData *UNUSED(md))
 {
 	return 1;
 }
@@ -118,9 +126,10 @@ static void foreachIDLink(ModifierData *md, Object *ob,
 	foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
 }
 
-static void updateDepgraph(
-					ModifierData *md, DagForest *forest, Scene *scene, Object *ob,
-	 DagNode *obNode)
+static void updateDepgraph(ModifierData *md, DagForest *forest,
+						Scene *UNUSED(scene),
+						Object *UNUSED(ob),
+						DagNode *obNode)
 {
 	WaveModifierData *wmd = (WaveModifierData*) md;
 
@@ -139,7 +148,7 @@ static void updateDepgraph(
 	}
 }
 
-static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 {
 	WaveModifierData *wmd = (WaveModifierData *)md;
 	CustomDataMask dataMask = 0;
@@ -147,11 +156,11 @@ static CustomDataMask requiredDataMask(Object *ob, ModifierData *md)
 
 	/* ask for UV coordinates if we need them */
 	if(wmd->texture && wmd->texmapping == MOD_WAV_MAP_UV)
-		dataMask |= (1 << CD_MTFACE);
+		dataMask |= CD_MASK_MTFACE;
 
 	/* ask for vertexgroups if we need them */
 	if(wmd->defgrp_name[0])
-		dataMask |= (1 << CD_MDEFORMVERT);
+		dataMask |= CD_MASK_MDEFORMVERT;
 
 	return dataMask;
 }
@@ -399,17 +408,20 @@ static void waveModifier_do(WaveModifierData *md,
 	if(wmd->texture) MEM_freeN(tex_co);
 }
 
-static void deformVerts(
-					 ModifierData *md, Object *ob, DerivedMesh *derivedData,
-	 float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+static void deformVerts(ModifierData *md, Object *ob,
+						DerivedMesh *derivedData,
+						float (*vertexCos)[3],
+						int numVerts,
+						int UNUSED(useRenderParams),
+						int UNUSED(isFinalCalc))
 {
 	DerivedMesh *dm= derivedData;
 	WaveModifierData *wmd = (WaveModifierData *)md;
 
 	if(wmd->flag & MOD_WAVE_NORM)
-		dm= get_cddm(md->scene, ob, NULL, dm, vertexCos);
+		dm= get_cddm(ob, NULL, dm, vertexCos);
 	else if(wmd->texture || wmd->defgrp_name[0])
-		dm= get_dm(md->scene, ob, NULL, dm, NULL, 0);
+		dm= get_dm(ob, NULL, dm, NULL, 0);
 
 	waveModifier_do(wmd, md->scene, ob, dm, vertexCos, numVerts);
 
@@ -425,9 +437,9 @@ static void deformVertsEM(
 	WaveModifierData *wmd = (WaveModifierData *)md;
 
 	if(wmd->flag & MOD_WAVE_NORM)
-		dm= get_cddm(md->scene, ob, editData, dm, vertexCos);
+		dm= get_cddm(ob, editData, dm, vertexCos);
 	else if(wmd->texture || wmd->defgrp_name[0])
-		dm= get_dm(md->scene, ob, editData, dm, NULL, 0);
+		dm= get_dm(ob, editData, dm, NULL, 0);
 
 	waveModifier_do(wmd, md->scene, ob, dm, vertexCos, numVerts);
 
@@ -445,6 +457,7 @@ ModifierTypeInfo modifierType_Wave = {
 							| eModifierTypeFlag_SupportsEditmode,
 	/* copyData */          copyData,
 	/* deformVerts */       deformVerts,
+	/* deformMatrices */    0,
 	/* deformVertsEM */     deformVertsEM,
 	/* deformMatricesEM */  0,
 	/* applyModifier */     0,
@@ -455,6 +468,7 @@ ModifierTypeInfo modifierType_Wave = {
 	/* isDisabled */        0,
 	/* updateDepgraph */    updateDepgraph,
 	/* dependsOnTime */     dependsOnTime,
+	/* dependsOnNormals */	0,
 	/* foreachObjectLink */ foreachObjectLink,
 	/* foreachIDLink */     foreachIDLink,
 };
diff --git a/source/blender/modifiers/intern/Makefile b/source/blender/modifiers/intern/Makefile
deleted file mode 100644
index 94ea068a1bc..00000000000
--- a/source/blender/modifiers/intern/Makefile
+++ /dev/null
@@ -1,55 +0,0 @@
-#
-# $Id$
-#
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software Foundation,
-# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
-# All rights reserved.
-#
-# The Original Code is: all of this file.
-#
-# Contributor(s): none yet.
-#
-# ***** END GPL LICENSE BLOCK *****
-#
-#
-
-LIBNAME = modifiers
-DIR = $(OCGDIR)/blender/$(LIBNAME)
-
-include nan_compile.mk
-
-CFLAGS += $(LEVEL_1_C_WARNINGS)
-
-CPPFLAGS += -I..
-
-CPPFLAGS += -I../../makesdna
-CPPFLAGS += -I../../makesrna
-CPPFLAGS += -I../../blenlib
-CPPFLAGS += -I../../blenkernel
-CPPFLAGS += -I../../blenkernel/intern
-CPPFLAGS += -I../../render/extern/include
-
-CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
-
-CPPFLAGS += -I$(NAN_DECIMATION)/include
-CPPFLAGS += -I$(NAN_ELBEEM)/include
-CPPFLAGS += -I$(NAN_OPENNL)/include
-CPPFLAGS += -I$(NAN_BSP)/include
-# CPPFLAGS += -I$(NAN_SMOKE)/include
-
-