Merge with trunk r48602

25 files changed, 691 insertions, 169 deletions

diff --git a/source/blender/blenkernel/intern/action.c b/source/blender/blenkernel/intern/action.c
index b3d2e3371f4..8d1707725b5 100644
--- a/source/blender/blenkernel/intern/action.c
+++ b/source/blender/blenkernel/intern/action.c
@@ -253,7 +253,7 @@ void set_active_action_group(bAction *act, bActionGroup *agrp, short select)
 }
 
 /* Sync colors used for action/bone group with theme settings */
-void action_group_colors_sync(bActionGroup *grp)
+void action_group_colors_sync(bActionGroup *grp, const bActionGroup *ref_grp)
 {
 	/* only do color copying if using a custom color (i.e. not default color)  */
 	if (grp->customCol) {
@@ -265,9 +265,15 @@ void action_group_colors_sync(bActionGroup *grp)
 			memcpy(&grp->cs, col_set, sizeof(ThemeWireColor));
 		}
 		else {
-			/* init custom colors with a generic multi-color rgb set, if not initialized already
-			 * (for custom color set) */
-			if (grp->cs.solid[0] == 0) {
+			/* if a reference group is provided, use the custom color from there... */
+			if (ref_grp) {
+				/* assumption: reference group has a color set */
+				memcpy(&grp->cs, &ref_grp->cs, sizeof(ThemeWireColor));
+			}
+			/* otherwise, init custom color with a generic/placeholder color set if
+			 * no previous theme color was used that we can just keep using
+			 */
+			else if (grp->cs.solid[0] == 0) {
 				/* define for setting colors in theme below */
 				rgba_char_args_set(grp->cs.solid, 0xff, 0x00, 0x00, 255);
 				rgba_char_args_set(grp->cs.select, 0x81, 0xe6, 0x14, 255);
diff --git a/source/blender/blenkernel/intern/anim.c b/source/blender/blenkernel/intern/anim.c
index 170638f0e8d..52399801691 100644
--- a/source/blender/blenkernel/intern/anim.c
+++ b/source/blender/blenkernel/intern/anim.c
@@ -78,9 +78,9 @@
 static void object_duplilist_recursive(ID *id, Scene *scene, Object *ob, ListBase *duplilist, float par_space_mat[][4], int par_index, int level, int animated);
 
 /* ******************************************************************** */
-/* Animation Visualisation */
+/* Animation Visualization */
 
-/* Initialize the default settings for animation visualisation */
+/* Initialize the default settings for animation visualization */
 void animviz_settings_init(bAnimVizSettings *avs)
 {
 	/* sanity check */
@@ -1490,7 +1490,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p
 			}
 
 			/* only counts visible particles */
-			++index;
+			index++;
 		}
 
 		/* restore objects since they were changed in BKE_object_where_is_calc_time */
diff --git a/source/blender/blenkernel/intern/anim_sys.c b/source/blender/blenkernel/intern/anim_sys.c
index a0da23a8f8f..943bad35cf2 100644
--- a/source/blender/blenkernel/intern/anim_sys.c
+++ b/source/blender/blenkernel/intern/anim_sys.c
@@ -1857,7 +1857,7 @@ static void nlastrip_evaluate_transition(PointerRNA *ptr, ListBase *channels, Li
 	/* prepare template for 'evaluation strip' 
 	 *	- based on the transition strip's evaluation strip data
 	 *	- strip_mode is NES_TIME_TRANSITION_* based on which endpoint
-	 *	- strip_time is the 'normalised' (i.e. in-strip) time for evaluation,
+	 *	- strip_time is the 'normalized' (i.e. in-strip) time for evaluation,
 	 *	  which doubles up as an additional weighting factor for the strip influences
 	 *	  which allows us to appear to be 'interpolating' between the two extremes
 	 */
diff --git a/source/blender/blenkernel/intern/armature.c b/source/blender/blenkernel/intern/armature.c
index 96959398bc2..5822b296a8a 100644
--- a/source/blender/blenkernel/intern/armature.c
+++ b/source/blender/blenkernel/intern/armature.c
@@ -2207,7 +2207,7 @@ void BKE_pchan_to_mat4(bPoseChannel *pchan, float chan_mat[4][4])
 		axis_angle_to_mat3(rmat, pchan->rotAxis, pchan->rotAngle);
 	}
 	else {
-		/* quats are normalised before use to eliminate scaling issues */
+		/* quats are normalized before use to eliminate scaling issues */
 		float quat[4];
 
 		/* NOTE: we now don't normalize the stored values anymore, since this was kindof evil in some cases
diff --git a/source/blender/blenkernel/intern/collision.c b/source/blender/blenkernel/intern/collision.c
index 1bd650ef568..d99c36b6c91 100644
--- a/source/blender/blenkernel/intern/collision.c
+++ b/source/blender/blenkernel/intern/collision.c
@@ -325,8 +325,7 @@ static int cloth_collision_response_static ( ClothModifierData *clmd, CollisionM
 
 			result = 1;
 		}
-		else
-		{
+		else {
 			// Apply repulse impulse if distance too short
 			// I_r = -min(dt*kd, max(0, 1d/dt - v_n))
 			// DG: this formula ineeds to be changed for this code since we apply impulses/repulses like this:
diff --git a/source/blender/blenkernel/intern/depsgraph.c b/source/blender/blenkernel/intern/depsgraph.c
index a1e67ebd414..2faa882e3ea 100644
--- a/source/blender/blenkernel/intern/depsgraph.c
+++ b/source/blender/blenkernel/intern/depsgraph.c
@@ -66,6 +66,7 @@
 #include "BKE_library.h"
 #include "BKE_main.h"
 #include "BKE_node.h"
+#include "BKE_material.h"
 #include "BKE_mball.h"
 #include "BKE_modifier.h"
 #include "BKE_object.h"
@@ -311,7 +312,7 @@ static void dag_add_driver_relation(AnimData *adt, DagForest *dag, DagNode *node
 	for (fcu = adt->drivers.first; fcu; fcu = fcu->next) {
 		ChannelDriver *driver = fcu->driver;
 		DriverVar *dvar;
-		int isdata_fcu = isdata || (fcu->rna_path && strstr(fcu->rna_path, "modifiers["));
+		int isdata_fcu = (isdata) || (fcu->rna_path && strstr(fcu->rna_path, "modifiers["));
 		
 		/* loop over variables to get the target relationships */
 		for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
@@ -347,6 +348,48 @@ static void dag_add_driver_relation(AnimData *adt, DagForest *dag, DagNode *node
 	}
 }
 
+/* XXX: forward def for material driver handling... */
+static void dag_add_material_driver_relations(DagForest *dag, DagNode *node, Material *ma);
+
+/* recursive handling for material nodetree drivers */
+static void dag_add_material_nodetree_driver_relations(DagForest *dag, DagNode *node, bNodeTree *ntree)
+{
+	bNode *n;
+	
+	/* nodetree itself */
+	if (ntree->adt) {
+		dag_add_driver_relation(ntree->adt, dag, node, 1);
+	}
+	
+	/* nodetree's nodes... */
+	for (n = ntree->nodes.first; n; n = n->next) {
+		if (n->id && GS(n->id->name) == ID_MA) {
+			dag_add_material_driver_relations(dag, node, (Material *)n->id);
+		}
+		else if (n->type == NODE_GROUP && n->id) {
+			dag_add_material_nodetree_driver_relations(dag, node, (bNodeTree *)n->id);
+		}
+	}
+}
+
+/* recursive handling for material drivers */
+static void dag_add_material_driver_relations(DagForest *dag, DagNode *node, Material *ma)
+{
+	/* material itself */
+	if (ma->adt) {
+		dag_add_driver_relation(ma->adt, dag, node, 1);
+	}
+	
+	/* textures */
+	// TODO...
+	//dag_add_texture_driver_relations(DagForest *dag, DagNode *node, ID *id);
+	
+	/* material's nodetree */
+	if (ma->nodetree) {
+		dag_add_material_nodetree_driver_relations(dag, node, ma->nodetree);
+	}
+}
+
 static void dag_add_collision_field_relation(DagForest *dag, Scene *scene, Object *ob, DagNode *node)
 {
 	Base *base;
@@ -516,7 +559,11 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O
 
 	/* softbody collision  */
 	if ((ob->type == OB_MESH) || (ob->type == OB_CURVE) || (ob->type == OB_LATTICE)) {
-		if (modifiers_isSoftbodyEnabled(ob) || modifiers_isClothEnabled(ob) || ob->particlesystem.first)
+		if (modifiers_isModifierEnabled(ob, eModifierType_Softbody) 
+			|| modifiers_isModifierEnabled(ob, eModifierType_Cloth)
+			|| modifiers_isModifierEnabled(ob, eModifierType_Smoke)
+			|| modifiers_isModifierEnabled(ob, eModifierType_DynamicPaint)
+			|| ob->particlesystem.first)
 			dag_add_collision_field_relation(dag, scene, ob, node);  /* TODO: use effectorweight->group */
 	}
 	
@@ -572,6 +619,20 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O
 		break;
 	}
 	
+	/* material drivers */
+	if (ob->totcol) {
+		int a;
+		
+		for (a = 1; a <= ob->totcol; a++) {
+			Material *ma = give_current_material(ob, a);
+			
+			if (ma) {
+				/* recursively figure out if there are drivers, and hook these up to this object */
+				dag_add_material_driver_relations(dag, node, ma);
+			}
+		}
+	}
+	
 	/* particles */
 	psys = ob->particlesystem.first;
 	if (psys) {
@@ -605,15 +666,15 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O
 				/* note that this relation actually runs in the wrong direction, the problem
 				 * is that dupli system all have this (due to parenting), and the render
 				 * engine instancing assumes particular ordering of objects in list */
-				dag_add_relation(dag, node, node2, DAG_RL_OB_OB, "Particle Object Visualisation");
+				dag_add_relation(dag, node, node2, DAG_RL_OB_OB, "Particle Object Visualization");
 				if (part->dup_ob->type == OB_MBALL)
-					dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA, "Particle Object Visualisation");
+					dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA, "Particle Object Visualization");
 			}
 
 			if (part->ren_as == PART_DRAW_GR && part->dup_group) {
 				for (go = part->dup_group->gobject.first; go; go = go->next) {
 					node2 = dag_get_node(dag, go->ob);
-					dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Particle Group Visualisation");
+					dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Particle Group Visualization");
 				}
 			}
 
diff --git a/source/blender/blenkernel/intern/dynamicpaint.c b/source/blender/blenkernel/intern/dynamicpaint.c
index 6589b1e1082..dd5751c5d1f 100644
--- a/source/blender/blenkernel/intern/dynamicpaint.c
+++ b/source/blender/blenkernel/intern/dynamicpaint.c
@@ -33,6 +33,7 @@
 #include "BLI_utildefines.h"
 
 #include "DNA_anim_types.h"
+#include "DNA_armature_types.h"
 #include "DNA_constraint_types.h"
 #include "DNA_dynamicpaint_types.h"
 #include "DNA_group_types.h" /*GroupObject*/
@@ -46,6 +47,7 @@
 #include "DNA_texture_types.h"
 
 #include "BKE_animsys.h"
+#include "BKE_armature.h"
 #include "BKE_bvhutils.h"   /* bvh tree	*/
 #include "BKE_blender.h"
 #include "BKE_cdderivedmesh.h"
@@ -528,11 +530,6 @@ static int subframe_updateObject(Scene *scene, Object *ob, int flags, float fram
 			}
 		}
 	}
-	/* for curve following objects, parented curve has to be updated too */
-	if (ob->type == OB_CURVE) {
-		Curve *cu = ob->data;
-		BKE_animsys_evaluate_animdata(scene, &cu->id, cu->adt, frame, ADT_RECALC_ANIM);
-	}
 
 	/* was originally OB_RECALC_ALL - TODO - which flags are really needed??? */
 	ob->recalc |= OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME;
@@ -547,6 +544,18 @@ static int subframe_updateObject(Scene *scene, Object *ob, int flags, float fram
 	else
 		BKE_object_where_is_calc_time(scene, ob, frame);
 
+	/* for curve following objects, parented curve has to be updated too */
+	if (ob->type == OB_CURVE) {
+		Curve *cu = ob->data;
+		BKE_animsys_evaluate_animdata(scene, &cu->id, cu->adt, frame, ADT_RECALC_ANIM);
+	}
+	/* and armatures... */
+	if (ob->type == OB_ARMATURE) {
+		bArmature *arm = ob->data;
+		BKE_animsys_evaluate_animdata(scene, &arm->id, arm->adt, frame, ADT_RECALC_ANIM);
+		BKE_pose_where_is(scene, ob);
+	}
+
 	return 0;
 }
 
@@ -1677,7 +1686,7 @@ struct DerivedMesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd,
 												c[1] = material->g;
 												c[2] = material->b;
 											}
-											else { /* default grey */
+											else { /* default gray */
 												c[0] = 0.65f;
 												c[1] = 0.65f;
 												c[2] = 0.65f;
diff --git a/source/blender/blenkernel/intern/effect.c b/source/blender/blenkernel/intern/effect.c
index b5254b97844..b32ac24084f 100644
--- a/source/blender/blenkernel/intern/effect.c
+++ b/source/blender/blenkernel/intern/effect.c
@@ -789,6 +789,12 @@ static void do_texture_effector(EffectorCache *eff, EffectorData *efd, EffectedP
 		multitex_ext(eff->pd->tex, tex_co, NULL, NULL, 0, result+3);
 
 		if (mode == PFIELD_TEX_GRAD || !hasrgb) { /* if we don't have rgb fall back to grad */
+			/* generate intensity if texture only has rgb value */
+			if (hasrgb & TEX_RGB) {
+				int i;
+				for (i=0; i<4; i++)
+					result[i].tin = (1.0f / 3.0f) * (result[i].tr + result[i].tg + result[i].tb);
+			}
 			force[0] = (result[0].tin - result[1].tin) * strength;
 			force[1] = (result[0].tin - result[2].tin) * strength;
 			force[2] = (result[0].tin - result[3].tin) * strength;
diff --git a/source/blender/blenkernel/intern/fcurve.c b/source/blender/blenkernel/intern/fcurve.c
index e20a74e713c..d072ffb72ec 100644
--- a/source/blender/blenkernel/intern/fcurve.c
+++ b/source/blender/blenkernel/intern/fcurve.c
@@ -811,7 +811,7 @@ void calchandles_fcurve(FCurve *fcu)
 		if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0] = bezt->vec[1][0];
 		
 		/* calculate auto-handles */
-		BKE_nurb_handle_calc(bezt, prev, next, 1);  /* 1==special autohandle */
+		BKE_nurb_handle_calc(bezt, prev, next, 1);  /* (1 == special) autohandle */
 		
 		/* for automatic ease in and out */
 		if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM) && ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM)) {
diff --git a/source/blender/blenkernel/intern/fmodifier.c b/source/blender/blenkernel/intern/fmodifier.c
index b7ede15d00b..f981ecaf810 100644
--- a/source/blender/blenkernel/intern/fmodifier.c
+++ b/source/blender/blenkernel/intern/fmodifier.c
@@ -285,7 +285,7 @@ static FModifierTypeInfo FMI_GENERATOR = {
  * x is the evaluation 'time', and 'y' is the resultant value
  *
  * Functions available are
- *	sin, cos, tan, sinc (normalised sin), natural log, square root 
+ *	sin, cos, tan, sinc (normalized sin), natural log, square root 
  */
 
 static void fcm_fn_generator_new_data(void *mdata)
@@ -297,7 +297,7 @@ static void fcm_fn_generator_new_data(void *mdata)
 	data->phase_multiplier = 1.0f;
 }
 
-/* Unary 'normalised sine' function
+/* Unary 'normalized sine' function
  *  y = sin(PI + x) / (PI * x),
  * except for x = 0 when y = 1.
  */
@@ -326,7 +326,7 @@ static void fcm_fn_generator_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float
 		case FCM_GENERATOR_FN_COS: /* cosine wave */
 			fn = cos;
 			break;
-		case FCM_GENERATOR_FN_SINC: /* normalised sine wave */
+		case FCM_GENERATOR_FN_SINC: /* normalized sine wave */
 			fn = sinc;
 			break;
 			
diff --git a/source/blender/blenkernel/intern/image.c b/source/blender/blenkernel/intern/image.c
index ea396b6d88c..d2a2412843a 100644
--- a/source/blender/blenkernel/intern/image.c
+++ b/source/blender/blenkernel/intern/image.c
@@ -514,17 +514,21 @@ void BKE_image_merge(Image *dest, Image *source)
 }
 
 /* note, we could be clever and scale all imbuf's but since some are mipmaps its not so simple */
-void BKE_image_scale(Image *image, int width, int height)
+int BKE_image_scale(Image *image, int width, int height)
 {
 	ImBuf *ibuf;
 	void *lock;
 
 	ibuf = BKE_image_acquire_ibuf(image, NULL, &lock);
 
-	IMB_scaleImBuf(ibuf, width, height);
-	ibuf->userflags |= IB_BITMAPDIRTY;
+	if (ibuf) {
+		IMB_scaleImBuf(ibuf, width, height);
+		ibuf->userflags |= IB_BITMAPDIRTY;
+	}
 
 	BKE_image_release_ibuf(image, lock);
+
+	return (ibuf != NULL);
 }
 
 Image *BKE_image_load(const char *filepath)
@@ -2780,10 +2784,14 @@ ImBuf *BKE_image_get_ibuf(Image *ima, ImageUser *iuser)
 	return BKE_image_acquire_ibuf(ima, iuser, NULL);
 }
 
-int BKE_image_user_frame_get(const ImageUser *iuser, int cfra, int fieldnr)
+int BKE_image_user_frame_get(const ImageUser *iuser, int cfra, int fieldnr, short *r_is_in_range)
 {
 	const int len = (iuser->fie_ima * iuser->frames) / 2;
 
+	if (r_is_in_range) {
+		*r_is_in_range = FALSE;
+	}
+
 	if (len == 0) {
 		return 0;
 	}
@@ -2796,10 +2804,23 @@ int BKE_image_user_frame_get(const ImageUser *iuser, int cfra, int fieldnr)
 			cfra = ((cfra) % len);
 			if (cfra < 0) cfra += len;
 			if (cfra == 0) cfra = len;
+
+			if (r_is_in_range) {
+				*r_is_in_range = TRUE;
+			}
 		}
 
-		if (cfra < 0) cfra = 0;
-		else if (cfra > len) cfra = len;
+		if (cfra < 0) {
+			cfra = 0;
+		}
+		else if (cfra > len) {
+			cfra = len;
+		}
+		else {
+			if (r_is_in_range) {
+				*r_is_in_range = TRUE;
+			}
+		}
 
 		/* convert current frame to current field */
 		cfra = 2 * (cfra);
@@ -2808,7 +2829,6 @@ int BKE_image_user_frame_get(const ImageUser *iuser, int cfra, int fieldnr)
 		/* transform to images space */
 		framenr = (cfra + iuser->fie_ima - 2) / iuser->fie_ima;
 		if (framenr > iuser->frames) framenr = iuser->frames;
-		framenr += iuser->offset;
 
 		if (iuser->cycl) {
 			framenr = ((framenr) % len);
@@ -2816,6 +2836,9 @@ int BKE_image_user_frame_get(const ImageUser *iuser, int cfra, int fieldnr)
 			if (framenr == 0) framenr = len;
 		}
 
+		/* important to apply after else we cant loop on frames 100 - 110 for eg. */
+		framenr += iuser->offset;
+
 		return framenr;
 	}
 }
@@ -2823,7 +2846,15 @@ int BKE_image_user_frame_get(const ImageUser *iuser, int cfra, int fieldnr)
 void BKE_image_user_frame_calc(ImageUser *iuser, int cfra, int fieldnr)
 {
 	if (iuser) {
-		const int framenr = BKE_image_user_frame_get(iuser, cfra, fieldnr);
+		short is_in_range;
+		const int framenr = BKE_image_user_frame_get(iuser, cfra, fieldnr, &is_in_range);
+
+		if (is_in_range) {
+			iuser->flag |= IMA_USER_FRAME_IN_RANGE;
+		}
+		else {
+			iuser->flag &= ~IMA_USER_FRAME_IN_RANGE;
+		}
 
 		/* allows image users to handle redraws */
 		if (iuser->flag & IMA_ANIM_ALWAYS)
@@ -2851,7 +2882,7 @@ void BKE_image_user_file_path(ImageUser *iuser, Image *ima, char *filepath)
 	if (ima->source == IMA_SRC_SEQUENCE) {
 		char head[FILE_MAX], tail[FILE_MAX];
 		unsigned short numlen;
-		int frame = iuser->framenr;
+		int frame = iuser ? iuser->framenr : ima->lastframe;
 
 		BLI_stringdec(filepath, head, tail, &numlen);
 		BLI_stringenc(filepath, head, tail, numlen, frame);
diff --git a/source/blender/blenkernel/intern/key.c b/source/blender/blenkernel/intern/key.c
index deb294a6738..bed70bbd780 100644
--- a/source/blender/blenkernel/intern/key.c
+++ b/source/blender/blenkernel/intern/key.c
@@ -771,7 +771,7 @@ void do_rel_key(const int start, int end, const int tot, char *basispoin, Key *k
 					
 					ofsp = ofs;
 					
-					while (cp[0]) {     /* cp[0]==amount */
+					while (cp[0]) {  /* (cp[0] == amount) */
 						
 						switch (cp[1]) {
 							case IPO_FLOAT:
@@ -936,7 +936,7 @@ static void do_key(const int start, int end, const int tot, char *poin, Key *key
 		
 		ofsp = ofs;
 
-		while (cp[0]) {     /* cp[0]==amount */
+		while (cp[0]) {  /* (cp[0] == amount) */
 
 			switch (cp[1]) {
 				case IPO_FLOAT:
diff --git a/source/blender/blenkernel/intern/mask.c b/source/blender/blenkernel/intern/mask.c
index d85722931a7..b400332db81 100644
--- a/source/blender/blenkernel/intern/mask.c
+++ b/source/blender/blenkernel/intern/mask.c
@@ -64,7 +64,7 @@ static MaskSplinePoint *mask_spline_point_next(MaskSpline *spline, MaskSplinePoi
 		if (spline->flag & MASK_SPLINE_CYCLIC) {
 			return &points_array[0];
 		}
-		else  {
+		else {
 			return NULL;
 		}
 	}
@@ -79,7 +79,7 @@ static MaskSplinePoint *mask_spline_point_prev(MaskSpline *spline, MaskSplinePoi
 		if (spline->flag & MASK_SPLINE_CYCLIC) {
 			return &points_array[spline->tot_point - 1];
 		}
-		else  {
+		else {
 			return NULL;
 		}
 	}
@@ -94,7 +94,7 @@ static BezTriple *mask_spline_point_next_bezt(MaskSpline *spline, MaskSplinePoin
 		if (spline->flag & MASK_SPLINE_CYCLIC) {
 			return &(points_array[0].bezt);
 		}
-		else  {
+		else {
 			return NULL;
 		}
 	}
@@ -188,6 +188,41 @@ void BKE_mask_layer_unique_name(Mask *mask, MaskLayer *masklay)
 	BLI_uniquename(&mask->masklayers, masklay, "MaskLayer", '.', offsetof(MaskLayer, name), sizeof(masklay->name));
 }
 
+MaskLayer *BKE_mask_layer_copy(MaskLayer *layer)
+{
+	MaskLayer *layer_new;
+	MaskSpline *spline;
+
+	layer_new = MEM_callocN(sizeof(MaskLayer), "new mask layer");
+
+	BLI_strncpy(layer_new->name, layer->name, sizeof(layer_new->name));
+
+	layer_new->alpha = layer->alpha;
+	layer_new->blend = layer->blend;
+	layer_new->blend_flag = layer->blend_flag;
+	layer_new->flag = layer->flag;
+	layer_new->restrictflag = layer->restrictflag;
+
+	for (spline = layer->splines.first; spline; spline = spline->next) {
+		MaskSpline *spline_new = BKE_mask_spline_copy(spline);
+
+		BLI_addtail(&layer_new->splines, spline_new);
+	}
+
+	return layer_new;
+}
+
+void BKE_mask_layer_copy_list(ListBase *masklayers_new, ListBase *masklayers)
+{
+	MaskLayer *layer;
+
+	for (layer = masklayers->first; layer; layer = layer->next) {
+		MaskLayer *layer_new = BKE_mask_layer_copy(layer);
+
+		BLI_addtail(masklayers_new, layer_new);
+	}
+}
+
 /* splines */
 
 MaskSpline *BKE_mask_spline_add(MaskLayer *masklay)
@@ -988,21 +1023,34 @@ void BKE_mask_spline_free(MaskSpline *spline)
 	MEM_freeN(spline);
 }
 
+static MaskSplinePoint *mask_spline_points_copy(MaskSplinePoint *points, int tot_point)
+{
+	MaskSplinePoint *npoints;
+	int i;
+
+	npoints = MEM_dupallocN(points);
+
+	for (i = 0; i < tot_point; i++) {
+		MaskSplinePoint *point = &npoints[i];
+
+		if (point->uw)
+			point->uw = MEM_dupallocN(point->uw);
+	}
+
+	return npoints;
+}
+
 MaskSpline *BKE_mask_spline_copy(MaskSpline *spline)
 {
 	MaskSpline *nspline = MEM_callocN(sizeof(MaskSpline), "new spline");
-	int i;
 
 	*nspline = *spline;
 
 	nspline->points_deform = NULL;
-	nspline->points = MEM_dupallocN(nspline->points);
-
-	for (i = 0; i < nspline->tot_point; i++) {
-		MaskSplinePoint *point = &nspline->points[i];
+	nspline->points = mask_spline_points_copy(spline->points, spline->tot_point);
 
-		if (point->uw)
-			point->uw = MEM_dupallocN(point->uw);
+	if (spline->points_deform) {
+		nspline->points_deform = mask_spline_points_copy(spline->points_deform, spline->tot_point);
 	}
 
 	return nspline;
@@ -1068,20 +1116,25 @@ void BKE_mask_layer_free(MaskLayer *masklay)
 	MEM_freeN(masklay);
 }
 
-void BKE_mask_free(Mask *mask)
+void BKE_mask_layer_free_list(ListBase *masklayers)
 {
-	MaskLayer *masklay = mask->masklayers.first;
+	MaskLayer *masklay = masklayers->first;
 
 	while (masklay) {
-		MaskLayer *next_masklay = masklay->next;
+		MaskLayer *masklay_next = masklay->next;
 
-		BLI_remlink(&mask->masklayers, masklay);
+		BLI_remlink(masklayers, masklay);
 		BKE_mask_layer_free(masklay);
 
-		masklay = next_masklay;
+		masklay = masklay_next;
 	}
 }
 
+void BKE_mask_free(Mask *mask)
+{
+	BKE_mask_layer_free_list(&mask->masklayers);
+}
+
 void BKE_mask_unlink(Main *bmain, Mask *mask)
 {
 	bScreen *scr;
@@ -2093,9 +2146,9 @@ int BKE_mask_get_duration(Mask *mask)
 }
 
 /* rasterization */
-void BKE_mask_rasterize(Mask *mask, int width, int height, float *buffer,
-                        const short do_aspect_correct, const short do_mask_aa,
-                        const short do_feather)
+void BKE_mask_rasterize_layers(ListBase *masklayers, int width, int height, float *buffer,
+                               const short do_aspect_correct, const short do_mask_aa,
+                               const short do_feather)
 {
 	MaskLayer *masklay;
 
@@ -2103,7 +2156,7 @@ void BKE_mask_rasterize(Mask *mask, int width, int height, float *buffer,
 	const int buffer_size = width * height;
 	float *buffer_tmp = MEM_mallocN(sizeof(float) * buffer_size, __func__);
 
-	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
+	for (masklay = masklayers->first; masklay; masklay = masklay->next) {
 		MaskSpline *spline;
 		float alpha;
 
@@ -2226,3 +2279,10 @@ void BKE_mask_rasterize(Mask *mask, int width, int height, float *buffer,
 
 	MEM_freeN(buffer_tmp);
 }
+
+void BKE_mask_rasterize(Mask *mask, int width, int height, float *buffer,
+                        const short do_aspect_correct, const short do_mask_aa,
+                        const short do_feather)
+{
+	BKE_mask_rasterize_layers(&mask->masklayers, width, height, buffer, do_aspect_correct, do_mask_aa, do_feather);
+}
diff --git a/source/blender/blenkernel/intern/material.c b/source/blender/blenkernel/intern/material.c
index 48d629a2944..23f197155a1 100644
--- a/source/blender/blenkernel/intern/material.c
+++ b/source/blender/blenkernel/intern/material.c
@@ -36,6 +36,7 @@
 
 #include "MEM_guardedalloc.h"
 
+#include "DNA_anim_types.h"
 #include "DNA_curve_types.h"
 #include "DNA_material_types.h"
 #include "DNA_mesh_types.h"
@@ -1050,6 +1051,52 @@ int material_in_material(Material *parmat, Material *mat)
 	else
 		return 0;
 }
+
+
+/* ****************** */
+
+/* Update drivers for materials in a nodetree */
+static void material_node_drivers_update(Scene *scene, bNodeTree *ntree, float ctime)
+{
+	bNode *node;
+	
+	/* nodetree itself */
+	if (ntree->adt && ntree->adt->drivers.first) {
+		BKE_animsys_evaluate_animdata(scene, &ntree->id, ntree->adt, ctime, ADT_RECALC_DRIVERS);
+	}
+	
+	/* nodes... */
+	for (node = ntree->nodes.first; node; node = node->next) {
+		if (node->id && GS(node->id->name) == ID_MA) {
+			/* TODO: prevent infinite recursion here... */
+			material_drivers_update(scene, (Material *)node->id, ctime);
+		}
+		else if (node->type == NODE_GROUP && node->id) {
+			material_node_drivers_update(scene, (bNodeTree *)node->id, ctime);
+		}
+	}
+}
+
+/* Calculate all drivers for materials 
+ * FIXME: this is really a terrible method which may result in some things being calculated
+ * multiple times. However, without proper despgraph support for these things, we are forced
+ * into this sort of thing...
+ */
+void material_drivers_update(Scene *scene, Material *ma, float ctime)
+{
+	//if (G.f & G_DEBUG)
+	//	printf("material_drivers_update(%s, %s)\n", scene->id.name, ma->id.name);
+	
+	/* material itself */
+	if (ma->adt && ma->adt->drivers.first) {
+		BKE_animsys_evaluate_animdata(scene, &ma->id, ma->adt, ctime, ADT_RECALC_DRIVERS);
+	}
+	
+	/* nodes */
+	if (ma->nodetree) {
+		material_node_drivers_update(scene, ma->nodetree, ctime);
+	}
+}
 	
 /* ****************** */
 #if 0 /* UNUSED */
@@ -1060,19 +1107,19 @@ static char colname_array[125][20]= {
 "LightGreen", "Chartreuse", "YellowGreen", "Yellow", "Gold",
 "Green", "LawnGreen", "GreenYellow", "LightOlive", "Yellow",
 "DarkBlue", "DarkPurple", "HotPink", "VioletPink", "RedPink",
-"SlateGray", "DarkGrey", "PalePurple", "IndianRed", "Tomato",
+"SlateGray", "DarkGray", "PalePurple", "IndianRed", "Tomato",
 "SeaGreen", "PaleGreen", "GreenKhaki", "LightBrown", "LightSalmon",
 "SpringGreen", "PaleGreen", "MediumOlive", "YellowBrown", "LightGold",
 "LightGreen", "LightGreen", "LightGreen", "GreenYellow", "PaleYellow",
 "HalfBlue", "DarkSky", "HalfMagenta", "VioletRed", "DeepPink",
 "SteelBlue", "SkyBlue", "Orchid", "LightHotPink", "HotPink",
-"SeaGreen", "SlateGray", "MediumGrey", "Burlywood", "LightPink",
+"SeaGreen", "SlateGray", "MediumGray", "Burlywood", "LightPink",
 "SpringGreen", "Aquamarine", "PaleGreen", "Khaki", "PaleOrange",
 "SpringGreen", "SeaGreen", "PaleGreen", "PaleWhite", "YellowWhite",
 "LightBlue", "Purple", "MediumOrchid", "Magenta", "Magenta",
 "RoyalBlue", "SlateBlue", "MediumOrchid", "Orchid", "Magenta",
 "DeepSkyBlue", "LightSteelBlue", "LightSkyBlue", "Violet", "LightPink",
-"Cyan", "DarkTurquoise", "SkyBlue", "Grey", "Snow",
+"Cyan", "DarkTurquoise", "SkyBlue", "Gray", "Snow",
 "Mint", "Mint", "Aquamarine", "MintCream", "Ivory",
 "Blue", "Blue", "DarkMagenta", "DarkOrchid", "Magenta",
 "SkyBlue", "RoyalBlue", "LightSlateBlue", "MediumOrchid", "Magenta",
diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c
index e3b13ca0f17..8d81e7b595d 100644
--- a/source/blender/blenkernel/intern/mesh.c
+++ b/source/blender/blenkernel/intern/mesh.c
@@ -2153,7 +2153,7 @@ void BKE_mesh_convert_mfaces_to_mpolys_ex(ID *id, CustomData *fdata, CustomData
 		}
 	}
 
-	/* note, we don't convert FGons at all, these are not even real ngons,
+	/* note, we don't convert NGons at all, these are not even real ngons,
 	 * they have their own UV's, colors etc - its more an editing feature. */
 
 	BLI_edgehash_free(eh, NULL);
@@ -3146,19 +3146,17 @@ void BKE_mesh_translate(Mesh *me, float offset[3], int do_keys)
 	}
 }
 
-
 void BKE_mesh_ensure_navmesh(Mesh *me)
 {
 	if (!CustomData_has_layer(&me->pdata, CD_RECAST)) {
 		int i;
 		int numFaces = me->totpoly;
 		int *recastData;
-		CustomData_add_layer_named(&me->pdata, CD_RECAST, CD_CALLOC, NULL, numFaces, "recastData");
-		recastData = (int *)CustomData_get_layer(&me->pdata, CD_RECAST);
+		recastData = (int *)MEM_mallocN(numFaces * sizeof(int), __func__);
 		for (i = 0; i < numFaces; i++) {
 			recastData[i] = i + 1;
 		}
-		CustomData_add_layer_named(&me->pdata, CD_RECAST, CD_REFERENCE, recastData, numFaces, "recastData");
+		CustomData_add_layer_named(&me->pdata, CD_RECAST, CD_ASSIGN, recastData, numFaces, "recastData");
 	}
 }
 
diff --git a/source/blender/blenkernel/intern/mesh_validate.c b/source/blender/blenkernel/intern/mesh_validate.c
index 669ae4f198a..4528b748412 100644
--- a/source/blender/blenkernel/intern/mesh_validate.c
+++ b/source/blender/blenkernel/intern/mesh_validate.c
@@ -50,6 +50,16 @@
 
 #define SELECT 1
 
+typedef union {
+	uint32_t verts[2];
+	int64_t edval;
+} EdgeUUID;
+
+typedef struct SortFace {
+	EdgeUUID		es[4];
+	unsigned int	index;
+} SortFace;
+
 /* Used to detect polys (faces) using exactly the same vertices. */
 /* Used to detect loops used by no (disjoint) or more than one (intersect) polys. */
 typedef struct SortPoly {
@@ -60,6 +70,84 @@ typedef struct SortPoly {
 	int invalid; /* Poly index. */
 } SortPoly;
 
+static void edge_store_assign(uint32_t verts[2],  const uint32_t v1, const uint32_t v2)
+{
+	if (v1 < v2) {
+		verts[0] = v1;
+		verts[1] = v2;
+	}
+	else {
+		verts[0] = v2;
+		verts[1] = v1;
+	}
+}
+
+static void edge_store_from_mface_quad(EdgeUUID es[4], MFace *mf)
+{
+	edge_store_assign(es[0].verts, mf->v1, mf->v2);
+	edge_store_assign(es[1].verts, mf->v2, mf->v3);
+	edge_store_assign(es[2].verts, mf->v3, mf->v4);
+	edge_store_assign(es[3].verts, mf->v4, mf->v1);
+}
+
+static void edge_store_from_mface_tri(EdgeUUID es[4], MFace *mf)
+{
+	edge_store_assign(es[0].verts, mf->v1, mf->v2);
+	edge_store_assign(es[1].verts, mf->v2, mf->v3);
+	edge_store_assign(es[2].verts, mf->v3, mf->v1);
+	es[3].verts[0] = es[3].verts[1] = UINT_MAX;
+}
+
+static int int64_cmp(const void *v1, const void *v2)
+{
+	const int64_t x1 = *(const int64_t *)v1;
+	const int64_t x2 = *(const int64_t *)v2;
+
+	if (x1 > x2) {
+		return 1;
+	}
+	else if (x1 < x2) {
+		return -1;
+	}
+
+	return 0;
+}
+
+static int search_face_cmp(const void *v1, const void *v2)
+{
+	const SortFace *sfa = v1, *sfb = v2;
+
+	if (sfa->es[0].edval > sfb->es[0].edval) {
+		return 1;
+	}
+	else if	(sfa->es[0].edval < sfb->es[0].edval) {
+		return -1;
+	}
+
+	else if	(sfa->es[1].edval > sfb->es[1].edval) {
+		return 1;
+	}
+	else if	(sfa->es[1].edval < sfb->es[1].edval) {
+		return -1;
+	}
+
+	else if	(sfa->es[2].edval > sfb->es[2].edval) {
+		return 1;
+	}
+	else if	(sfa->es[2].edval < sfb->es[2].edval) {
+		return -1;
+	}
+
+	else if	(sfa->es[3].edval > sfb->es[3].edval) {
+		return 1;
+	}
+	else if	(sfa->es[3].edval < sfb->es[3].edval) {
+		return -1;
+	}
+
+	return 0;
+}
+
 /* TODO check there is not some standard define of this somewhere! */
 static int int_cmp(const void *v1, const void *v2)
 {
@@ -98,6 +186,7 @@ static int search_polyloop_cmp(const void *v1, const void *v2)
 int BKE_mesh_validate_arrays(Mesh *mesh,
                              MVert *mverts, unsigned int totvert,
                              MEdge *medges, unsigned int totedge,
+                             MFace *mfaces, unsigned int totface,
                              MLoop *mloops, unsigned int totloop,
                              MPoly *mpolys, unsigned int totpoly,
                              MDeformVert *dverts, /* assume totvert length */
@@ -117,10 +206,12 @@ int BKE_mesh_validate_arrays(Mesh *mesh,
 	int *v;
 
 	short do_edge_free = FALSE;
+	short do_face_free = FALSE;
 	short do_polyloop_free = FALSE; /* This regroups loops and polys! */
 
 	short verts_fixed = FALSE;
 	short vert_weights_fixed = FALSE;
+	int msel_fixed = FALSE;
 
 	int do_edge_recalc = FALSE;
 
@@ -193,6 +284,143 @@ int BKE_mesh_validate_arrays(Mesh *mesh,
 		}
 	}
 
+	if (mfaces && !mpolys) {
+#		define REMOVE_FACE_TAG(_mf) { _mf->v3 = 0; do_face_free = TRUE; } (void)0
+#		define CHECK_FACE_VERT_INDEX(a, b) \
+					if (mf->a == mf->b) { \
+						PRINT("    face %u: verts invalid, " STRINGIFY(a) "/" STRINGIFY(b) " both %u\n", i, mf->a); \
+						remove = do_fixes; \
+					} (void)0
+#		define CHECK_FACE_EDGE(a, b) \
+					if (!BLI_edgehash_haskey(edge_hash, mf->a, mf->b)) { \
+						PRINT("    face %u: edge " STRINGIFY(a) "/" STRINGIFY(b) \
+						      " (%u,%u) is missing egde data\n", i, mf->a, mf->b); \
+						do_edge_recalc = TRUE; \
+					}
+
+		MFace *mf;
+		MFace *mf_prev;
+
+		SortFace *sort_faces = MEM_callocN(sizeof(SortFace) * totface, "search faces");
+		SortFace *sf;
+		SortFace *sf_prev;
+		unsigned int totsortface = 0;
+
+		for (i = 0, mf = mfaces, sf = sort_faces; i < totface; i++, mf++) {
+			int remove = FALSE;
+			int fidx;
+			unsigned int fv[4];
+
+			fidx = mf->v4 ? 3 : 2;
+			do {
+				fv[fidx] = *(&(mf->v1) + fidx);
+				if (fv[fidx] >= totvert) {
+					PRINT("    face %u: 'v%d' index out of range, %u\n", i, fidx + 1, fv[fidx]);
+					remove = do_fixes;
+				}
+			} while (fidx--);
+
+			if (remove == FALSE) {
+				if (mf->v4) {
+					CHECK_FACE_VERT_INDEX(v1, v2);
+					CHECK_FACE_VERT_INDEX(v1, v3);
+					CHECK_FACE_VERT_INDEX(v1, v4);
+
+					CHECK_FACE_VERT_INDEX(v2, v3);
+					CHECK_FACE_VERT_INDEX(v2, v4);
+
+					CHECK_FACE_VERT_INDEX(v3, v4);
+				}
+				else {
+					CHECK_FACE_VERT_INDEX(v1, v2);
+					CHECK_FACE_VERT_INDEX(v1, v3);
+
+					CHECK_FACE_VERT_INDEX(v2, v3);
+				}
+
+				if (remove == FALSE) {
+					if (totedge) {
+						if (mf->v4) {
+							CHECK_FACE_EDGE(v1, v2);
+							CHECK_FACE_EDGE(v2, v3);
+							CHECK_FACE_EDGE(v3, v4);
+							CHECK_FACE_EDGE(v4, v1);
+						}
+						else {
+							CHECK_FACE_EDGE(v1, v2);
+							CHECK_FACE_EDGE(v2, v3);
+							CHECK_FACE_EDGE(v3, v1);
+						}
+					}
+
+					sf->index = i;
+
+					if (mf->v4) {
+						edge_store_from_mface_quad(sf->es, mf);
+
+						qsort(sf->es, 4, sizeof(int64_t), int64_cmp);
+					}
+					else {
+						edge_store_from_mface_tri(sf->es, mf);
+						qsort(sf->es, 3, sizeof(int64_t), int64_cmp);
+					}
+
+					totsortface++;
+					sf++;
+				}
+			}
+
+			if (remove) {
+				REMOVE_FACE_TAG(mf);
+			}
+		}
+
+		qsort(sort_faces, totsortface, sizeof(SortFace), search_face_cmp);
+
+		sf = sort_faces;
+		sf_prev = sf;
+		sf++;
+
+		for (i = 1; i < totsortface; i++, sf++) {
+			int remove = FALSE;
+
+			/* on a valid mesh, code below will never run */
+			if (memcmp(sf->es, sf_prev->es, sizeof(sf_prev->es)) == 0) {
+				mf = mfaces + sf->index;
+
+				if (do_verbose) {
+					mf_prev = mfaces + sf_prev->index;
+
+					if (mf->v4) {
+						PRINT("    face %u & %u: are duplicates (%u,%u,%u,%u) (%u,%u,%u,%u)\n",
+						      sf->index, sf_prev->index, mf->v1, mf->v2, mf->v3, mf->v4,
+						      mf_prev->v1, mf_prev->v2, mf_prev->v3, mf_prev->v4);
+					}
+					else {
+						PRINT("    face %u & %u: are duplicates (%u,%u,%u) (%u,%u,%u)\n",
+						      sf->index, sf_prev->index, mf->v1, mf->v2, mf->v3,
+						      mf_prev->v1, mf_prev->v2, mf_prev->v3);
+					}
+				}
+
+				remove = do_fixes;
+			}
+			else {
+				sf_prev = sf;
+			}
+
+			if (remove) {
+				REMOVE_FACE_TAG(mf);
+			}
+		}
+
+		MEM_freeN(sort_faces);
+
+#		undef REMOVE_FACE_TAG
+#		undef CHECK_FACE_VERT_INDEX
+#		undef CHECK_FACE_EDGE
+	}
+
 	/* Checking loops and polys is a bit tricky, as they are quite intricated...
 	 *
 	 * Polys must have:
@@ -527,14 +755,16 @@ int BKE_mesh_validate_arrays(Mesh *mesh,
 		}
 	}
 
-	PRINT("BKE_mesh_validate: finished\n\n");
-
 #   undef REMOVE_EDGE_TAG
 #   undef IS_REMOVED_EDGE
 #   undef REMOVE_LOOP_TAG
 #   undef REMOVE_POLY_TAG
 
 	if (mesh) {
+		if (do_face_free) {
+			BKE_mesh_strip_loose_faces(mesh);
+		}
+
 		if (do_polyloop_free) {
 			BKE_mesh_strip_loose_polysloops(mesh);
 		}
@@ -548,7 +778,51 @@ int BKE_mesh_validate_arrays(Mesh *mesh,
 		}
 	}
 
-	return (verts_fixed || vert_weights_fixed || do_polyloop_free || do_edge_free || do_edge_recalc);
+	if (mesh && mesh->mselect) {
+		MSelect *msel;
+		int free_msel = FALSE;
+
+		for (i = 0, msel = mesh->mselect; i < mesh->totselect; i++, msel++) {
+			int tot_elem;
+
+			if (msel->index < 0) {
+				PRINT("Mesh select element %d type %d index is negative, "
+				      "resetting selection stack.\n", i, msel->type);
+				free_msel = TRUE;
+				break;
+			}
+
+			switch (msel->type) {
+				case ME_VSEL:
+					tot_elem = mesh->totvert;
+					break;
+				case ME_ESEL:
+					tot_elem = mesh->totedge;
+					break;
+				case ME_FSEL:
+					tot_elem = mesh->totface;
+					break;
+			}
+
+			if (msel->index > tot_elem) {
+				PRINT("Mesh select element %d type %d index %d is larger than data array size %d, "
+				      "resetting selection stack.\n", i, msel->type, msel->index, tot_elem);
+
+				free_msel = TRUE;
+				break;
+			}
+		}
+
+		if (free_msel) {
+			MEM_freeN(mesh->mselect);
+			mesh->mselect = NULL;
+			mesh->totselect = 0;
+		}
+	}
+
+	PRINT("BKE_mesh_validate: finished\n\n");
+
+	return (verts_fixed || vert_weights_fixed || do_polyloop_free || do_edge_free || do_edge_recalc || msel_fixed);
 }
 
 static int mesh_validate_customdata(CustomData *data, short do_verbose, const short do_fixes)
@@ -605,6 +879,7 @@ int BKE_mesh_validate(Mesh *me, int do_verbose)
 	arrays_fixed = BKE_mesh_validate_arrays(me,
 	                                        me->mvert, me->totvert,
 	                                        me->medge, me->totedge,
+	                                        me->mface, me->totface,
 	                                        me->mloop, me->totloop,
 	                                        me->mpoly, me->totpoly,
 	                                        me->dvert,
@@ -622,6 +897,7 @@ int BKE_mesh_validate_dm(DerivedMesh *dm)
 	return BKE_mesh_validate_arrays(NULL,
 	                                dm->getVertArray(dm), dm->getNumVerts(dm),
 	                                dm->getEdgeArray(dm), dm->getNumEdges(dm),
+	                                dm->getTessFaceArray(dm), dm->getNumTessFaces(dm),
 	                                dm->getLoopArray(dm), dm->getNumLoops(dm),
 	                                dm->getPolyArray(dm), dm->getNumPolys(dm),
 	                                dm->getVertDataArray(dm, CD_MDEFORMVERT),
diff --git a/source/blender/blenkernel/intern/modifier.c b/source/blender/blenkernel/intern/modifier.c
index b4c30203000..65538e5bea2 100644
--- a/source/blender/blenkernel/intern/modifier.c
+++ b/source/blender/blenkernel/intern/modifier.c
@@ -331,6 +331,13 @@ int modifiers_isClothEnabled(Object *ob)
 	return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 }
 
+int modifiers_isModifierEnabled(Object *ob, int modifierType)
+{
+	ModifierData *md = modifiers_findByType(ob, modifierType);
+
+	return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
+}
+
 int modifiers_isParticleEnabled(Object *ob)
 {
 	ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
diff --git a/source/blender/blenkernel/intern/modifiers_bmesh.c b/source/blender/blenkernel/intern/modifiers_bmesh.c
index 99bb3468320..72c3cda9272 100644
--- a/source/blender/blenkernel/intern/modifiers_bmesh.c
+++ b/source/blender/blenkernel/intern/modifiers_bmesh.c
@@ -72,8 +72,8 @@ void DM_to_bmesh_ex(DerivedMesh *dm, BMesh *bm)
 	BM_data_layer_add(bm, &bm->edata, CD_BWEIGHT);
 	BM_data_layer_add(bm, &bm->vdata, CD_BWEIGHT);
 
-	vtable = MEM_callocN(sizeof(void**) * totvert, "vert table in BMDM_Copy");
-	etable = MEM_callocN(sizeof(void**) * totedge, "edge table in BMDM_Copy");
+	vtable = MEM_callocN(sizeof(void **) * totvert, "vert table in BMDM_Copy");
+	etable = MEM_callocN(sizeof(void **) * totedge, "edge table in BMDM_Copy");
 
 	/*do verts*/
 	mv = mvert = dm->dupVertArray(dm);
diff --git a/source/blender/blenkernel/intern/nla.c b/source/blender/blenkernel/intern/nla.c
index 2b4fe72e8bb..fb15aa82fa2 100644
--- a/source/blender/blenkernel/intern/nla.c
+++ b/source/blender/blenkernel/intern/nla.c
@@ -1391,7 +1391,7 @@ static void BKE_nlastrip_validate_autoblends(NlaTrack *nlt, NlaStrip *nls)
 		
 	/* set overlaps for this strip 
 	 *	- don't use the values obtained though if the end in question 
-	 *	  is directly followed/preceeded by another strip, forming an 
+	 *	  is directly followed/preceded by another strip, forming an 
 	 *	  'island' of continuous strips
 	 */
 	if ((ps || ns) && ((nls->prev == NULL) || IS_EQF(nls->prev->end, nls->start) == 0)) {
diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c
index 8fb8d863a8c..f0d47791374 100644
--- a/source/blender/blenkernel/intern/object.c
+++ b/source/blender/blenkernel/intern/object.c
@@ -843,7 +843,7 @@ Object *BKE_object_add_only_object(int type, const char *name)
 
 	ob->pc_ids.first = ob->pc_ids.last = NULL;
 	
-	/* Animation Visualisation defaults */
+	/* Animation Visualization defaults */
 	animviz_settings_init(&ob->avs);
 
 	return ob;
@@ -1460,7 +1460,7 @@ void BKE_object_rot_to_mat3(Object *ob, float mat[][3])
 		axis_angle_to_mat3(dmat, ob->drotAxis, ob->drotAngle);
 	}
 	else {
-		/* quats are normalised before use to eliminate scaling issues */
+		/* quats are normalized before use to eliminate scaling issues */
 		float tquat[4];
 		
 		normalize_qt_qt(tquat, ob->quat);
@@ -2538,7 +2538,7 @@ void BKE_object_handle_update(Scene *scene, Object *ob)
 				printf("recalcdata %s\n", ob->id.name + 2);
 
 			if (adt) {
-				/* evaluate drivers */
+				/* evaluate drivers - datalevel */
 				// XXX: for mesh types, should we push this to derivedmesh instead?
 				BKE_animsys_evaluate_animdata(scene, data_id, adt, ctime, ADT_RECALC_DRIVERS);
 			}
@@ -2595,8 +2595,26 @@ void BKE_object_handle_update(Scene *scene, Object *ob)
 					BKE_lattice_modifiers_calc(scene, ob);
 					break;
 			}
-
-
+			
+			/* related materials */
+			/* XXX: without depsgraph tagging, this will always need to be run, which will be slow! 
+			 * However, not doing anything (or trying to hack around this lack) is not an option 
+			 * anymore, especially due to Cycles [#31834] 
+			 */
+			if (ob->totcol) {
+				int a;
+				
+				for (a = 1; a <= ob->totcol; a++) {
+					Material *ma = give_current_material(ob, a);
+					
+					if (ma) {
+						/* recursively update drivers for this material */
+						material_drivers_update(scene, ma, ctime);
+					}
+				}
+			}
+			
+			/* particles */
 			if (ob->particlesystem.first) {
 				ParticleSystem *tpsys, *psys;
 				DerivedMesh *dm;
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index 569e69f2d51..65f22ebc88f 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -3320,7 +3320,7 @@ static int collision_response(ParticleData *pa, ParticleCollision *col, BVHTreeR
 			}
 		}
 
-		/* stickness was possibly added before, so cancel that before calculating new normal velocity */
+		/* stickiness was possibly added before, so cancel that before calculating new normal velocity */
 		/* otherwise particles go flying out of the surface because of high reversed sticky velocity */
 		if (v0_dot < 0.0f) {
 			v0_dot += pd->pdef_stickness;
@@ -3379,7 +3379,7 @@ static int collision_response(ParticleData *pa, ParticleCollision *col, BVHTreeR
 				madd_v3_v3fl(pa->state.vel, nor, -dot);
 		}
 
-		/* add stickness to surface */
+		/* add stickiness to surface */
 		madd_v3_v3fl(pa->state.vel, pce->nor, -pd->pdef_stickness);
 
 		/* set coordinates for next iteration */
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index 8cb47118e7d..78ccdc425e5 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -1220,7 +1220,11 @@ static void seq_open_anim_file(Sequence *seq)
 	}
 
 	if (seq->flag & SEQ_USE_PROXY_CUSTOM_DIR) {
-		IMB_anim_set_index_dir(seq->anim, seq->strip->proxy->dir);
+		char dir[FILE_MAX];
+		BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
+		BLI_path_abs(dir, G.main->name);
+
+		IMB_anim_set_index_dir(seq->anim, dir);
 	}
 }
 
@@ -2089,7 +2093,7 @@ static ImBuf *seq_render_mask_strip(
 		fp_src = maskbuf;
 		fp_dst = ibuf->rect_float;
 		i = context.rectx * context.recty;
-		while(--i) {
+		while (--i) {
 			fp_dst[0] = fp_dst[1] = fp_dst[2] = *fp_src;
 			fp_dst[3] = 1.0f;
 
@@ -2115,7 +2119,7 @@ static ImBuf *seq_render_mask_strip(
 		fp_src = maskbuf;
 		ub_dst = (unsigned char *)ibuf->rect;
 		i = context.rectx * context.recty;
-		while(--i) {
+		while (--i) {
 			ub_dst[0] = ub_dst[1] = ub_dst[2] = (unsigned char)(*fp_src * 255.0f); /* already clamped */
 			ub_dst[3] = 255;
 
diff --git a/source/blender/blenkernel/intern/tracking.c b/source/blender/blenkernel/intern/tracking.c
index 3dea8a85915..6167536fb9b 100644
--- a/source/blender/blenkernel/intern/tracking.c
+++ b/source/blender/blenkernel/intern/tracking.c
@@ -3028,9 +3028,9 @@ static unsigned char *detect_get_frame_ucharbuf(ImBuf *ibuf)
 
 			if (ibuf->rect_float) {
 				const float *rrgbf = ibuf->rect_float + pixel * 4;
-				const float grey_f = 0.2126f * rrgbf[0] + 0.7152f * rrgbf[1] + 0.0722f * rrgbf[2];
+				const float gray_f = 0.2126f * rrgbf[0] + 0.7152f * rrgbf[1] + 0.0722f * rrgbf[2];
 
-				*cp = FTOCHAR(grey_f);
+				*cp = FTOCHAR(gray_f);
 			}
 			else {
 				const unsigned char *rrgb = (unsigned char *)ibuf->rect + pixel * 4;
diff --git a/source/blender/blenkernel/intern/unit.c b/source/blender/blenkernel/intern/unit.c
index aa9cc40f71f..df4d2d8cc38 100644
--- a/source/blender/blenkernel/intern/unit.c
+++ b/source/blender/blenkernel/intern/unit.c
@@ -108,154 +108,154 @@ static struct bUnitCollection buDummyCollecton = {buDummyDef, 0, 0, sizeof(buDum
 
 /* Lengths */
 static struct bUnitDef buMetricLenDef[] = {
-	{"kilometer", "kilometers",		"km", NULL,	"Kilometers", UN_SC_KM, 0.0,	B_UNIT_DEF_NONE},
-	{"hectometer", "hectometers",	"hm", NULL,	"100 Meters", UN_SC_HM, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"dekameter", "dekameters",		"dam",NULL,	"10 Meters",  UN_SC_DAM, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"meter", "meters",				"m",  NULL,	"Meters",     UN_SC_M, 0.0, 	B_UNIT_DEF_NONE}, /* base unit */
-	{"decimetre", "decimetres",		"dm", NULL,	"10 Centimeters", UN_SC_DM, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"centimeter", "centimeters",	"cm", NULL,	"Centimeters", UN_SC_CM, 0.0,	B_UNIT_DEF_NONE},
-	{"millimeter", "millimeters",	"mm", NULL,	"Millimeters", UN_SC_MM, 0.0,	B_UNIT_DEF_NONE},
-	{"micrometer", "micrometers",	"µm", "um",	"Micrometers", UN_SC_UM, 0.0,	B_UNIT_DEF_NONE}, // micron too?
+	{"kilometer", "kilometers",     "km",  NULL, "Kilometers", UN_SC_KM, 0.0,     B_UNIT_DEF_NONE},
+	{"hectometer", "hectometers",   "hm",  NULL, "100 Meters", UN_SC_HM, 0.0,     B_UNIT_DEF_SUPPRESS},
+	{"dekameter", "dekameters",     "dam", NULL, "10 Meters",  UN_SC_DAM, 0.0,    B_UNIT_DEF_SUPPRESS},
+	{"meter", "meters",             "m",   NULL, "Meters",     UN_SC_M, 0.0,      B_UNIT_DEF_NONE},     /* base unit */
+	{"decimeter", "decimeters",     "dm",  NULL, "10 Centimeters", UN_SC_DM, 0.0, B_UNIT_DEF_SUPPRESS},
+	{"centimeter", "centimeters",   "cm",  NULL, "Centimeters", UN_SC_CM, 0.0,    B_UNIT_DEF_NONE},
+	{"millimeter", "millimeters",   "mm",  NULL, "Millimeters", UN_SC_MM, 0.0,    B_UNIT_DEF_NONE},
+	{"micrometer", "micrometers",   "µm",  "um", "Micrometers", UN_SC_UM, 0.0,    B_UNIT_DEF_NONE},     // micron too?
 
 	/* These get displayed because of float precision problems in the transform header,
 	 * could work around, but for now probably people wont use these */
 #if 0
-	{"nanometer", "Nanometers",		"nm", NULL,	0.000000001, 0.0,	B_UNIT_DEF_NONE},
-	{"picometer", "Picometers",		"pm", NULL,	0.000000000001, 0.0,B_UNIT_DEF_NONE},
+	{"nanometer", "Nanometers",     "nm", NULL, 0.000000001, 0.0,   B_UNIT_DEF_NONE},
+	{"picometer", "Picometers",     "pm", NULL, 0.000000000001, 0.0, B_UNIT_DEF_NONE},
 #endif
 	{NULL, NULL, NULL,	NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buMetricLenCollecton = {buMetricLenDef, 3, 0, sizeof(buMetricLenDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buMetricLenCollecton = {buMetricLenDef, 3, 0, sizeof(buMetricLenDef) / sizeof(bUnitDef)};
 
 static struct bUnitDef buImperialLenDef[] = {
-	{"mile", "miles",		"mi", "m", "Miles",		UN_SC_MI, 0.0,	B_UNIT_DEF_NONE},
-	{"furlong", "furlongs",	"fur", NULL, "Furlongs",UN_SC_FUR, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"chain", "chains",		"ch", NULL, "Chains",	UN_SC_CH, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"yard", "yards",		"yd", NULL, "Yards",	UN_SC_YD, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"foot", "feet",		"'", "ft", "Feet",		UN_SC_FT, 0.0,	B_UNIT_DEF_NONE}, /* base unit */
-	{"inch", "inches",		"\"", "in", "Inches",	UN_SC_IN, 0.0,	B_UNIT_DEF_NONE},
-	{"thou", "thou",		"thou", "mil", "Thou",	UN_SC_MIL, 0.0,	B_UNIT_DEF_NONE}, /* plural for thou has no 's' */
+	{"mile", "miles",       "mi", "m", "Miles",      UN_SC_MI, 0.0,  B_UNIT_DEF_NONE},
+	{"furlong", "furlongs", "fur", NULL, "Furlongs", UN_SC_FUR, 0.0, B_UNIT_DEF_SUPPRESS},
+	{"chain", "chains",     "ch", NULL, "Chains",    UN_SC_CH, 0.0,  B_UNIT_DEF_SUPPRESS},
+	{"yard", "yards",       "yd", NULL, "Yards",     UN_SC_YD, 0.0,  B_UNIT_DEF_SUPPRESS},
+	{"foot", "feet",        "'", "ft", "Feet",       UN_SC_FT, 0.0,  B_UNIT_DEF_NONE}, /* base unit */
+	{"inch", "inches",      "\"", "in", "Inches",    UN_SC_IN, 0.0,  B_UNIT_DEF_NONE},
+	{"thou", "thou",        "thou", "mil", "Thou",   UN_SC_MIL, 0.0, B_UNIT_DEF_NONE}, /* plural for thou has no 's' */
 	{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buImperialLenCollecton = {buImperialLenDef, 4, 0, sizeof(buImperialLenDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buImperialLenCollecton = {buImperialLenDef, 4, 0, sizeof(buImperialLenDef) / sizeof(bUnitDef)};
 
 /* Areas */
 static struct bUnitDef buMetricAreaDef[] = {
-	{"square kilometer", "square kilometers",	"km²", "km2",	"Square Kilometers", UN_SC_KM*UN_SC_KM, 0.0,	B_UNIT_DEF_NONE},
-	{"square hectometer","square hectometers",	"hm²", "hm2",	"Square Hectometers", UN_SC_HM*UN_SC_HM, 0.0,	B_UNIT_DEF_NONE}, /* hectare */
-	{"square dekameter", "square dekameters",	"dam²","dam2",	"Square Dekameters", UN_SC_DAM*UN_SC_DAM, 0.0,	B_UNIT_DEF_SUPPRESS}, /* are */
-	{"square meter", "square meters",			"m²",  "m2",	"Square Meters", UN_SC_M*UN_SC_M, 0.0, 			B_UNIT_DEF_NONE}, /* base unit */
-	{"square decimetre", "square decimetres",	"dm²", "dm2",	"Square Decimetres", UN_SC_DM*UN_SC_DM, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"square centimeter", "square centimeters",	"cm²", "cm2",	"Square Centimeters", UN_SC_CM*UN_SC_CM, 0.0,	B_UNIT_DEF_NONE},
-	{"square millimeter", "square millimeters",	"mm²", "mm2",	"Square Millimeters", UN_SC_MM*UN_SC_MM, 0.0,	B_UNIT_DEF_NONE},
-	{"square micrometer", "square micrometers",	"µm²", "um2",	"Square Micrometers", UN_SC_UM*UN_SC_UM, 0.0,	B_UNIT_DEF_NONE},
-	{NULL, NULL, NULL,	NULL, NULL, 0.0, 0.0}
+	{"square kilometer",  "square kilometers",  "km²", "km2",   "Square Kilometers", UN_SC_KM * UN_SC_KM, 0.0,    B_UNIT_DEF_NONE},
+	{"square hectometer", "square hectometers", "hm²", "hm2",   "Square Hectometers", UN_SC_HM * UN_SC_HM, 0.0,   B_UNIT_DEF_NONE},   /* hectare */
+	{"square dekameter",  "square dekameters",  "dam²", "dam2",  "Square Dekameters", UN_SC_DAM * UN_SC_DAM, 0.0, B_UNIT_DEF_SUPPRESS},  /* are */
+	{"square meter",      "square meters",      "m²",  "m2",    "Square Meters", UN_SC_M * UN_SC_M, 0.0,          B_UNIT_DEF_NONE},   /* base unit */
+	{"square decimeter",  "square decimetees",  "dm²", "dm2",   "Square Decimeters", UN_SC_DM * UN_SC_DM, 0.0,    B_UNIT_DEF_SUPPRESS},
+	{"square centimeter", "square centimeters", "cm²", "cm2",   "Square Centimeters", UN_SC_CM * UN_SC_CM, 0.0,   B_UNIT_DEF_NONE},
+	{"square millimeter", "square millimeters", "mm²", "mm2",   "Square Millimeters", UN_SC_MM * UN_SC_MM, 0.0,   B_UNIT_DEF_NONE},
+	{"square micrometer", "square micrometers", "µm²", "um2",   "Square Micrometers", UN_SC_UM * UN_SC_UM, 0.0,   B_UNIT_DEF_NONE},
+	{NULL, NULL, NULL,  NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buMetricAreaCollecton = {buMetricAreaDef, 3, 0, sizeof(buMetricAreaDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buMetricAreaCollecton = {buMetricAreaDef, 3, 0, sizeof(buMetricAreaDef) / sizeof(bUnitDef)};
 
 static struct bUnitDef buImperialAreaDef[] = {
-	{"square mile", "square miles",			"sq mi", "sq m","Square Miles", UN_SC_MI*UN_SC_MI, 0.0,		B_UNIT_DEF_NONE},
-	{"square furlong", "square furlongs",	"sq fur",NULL,	"Square Furlongs", UN_SC_FUR*UN_SC_FUR, 0.0,B_UNIT_DEF_SUPPRESS},
-	{"square chain", "square chains",		"sq ch", NULL,	"Square Chains", UN_SC_CH*UN_SC_CH, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"square yard", "square yards",			"sq yd", NULL,	"Square Yards", UN_SC_YD*UN_SC_YD, 0.0,		B_UNIT_DEF_NONE},
-	{"square foot", "square feet",			"sq ft", NULL,	"Square Feet", UN_SC_FT*UN_SC_FT, 0.0,		B_UNIT_DEF_NONE}, /* base unit */
-	{"square inch", "square inches",		"sq in", NULL,	"Square Inches", UN_SC_IN*UN_SC_IN, 0.0,	B_UNIT_DEF_NONE},
-	{"square thou", "square thous",			"sq mil",NULL,	"Square Thous", UN_SC_MIL*UN_SC_MIL, 0.0,	B_UNIT_DEF_NONE},
+	{"square mile", "square miles",       "sq mi", "sq m", "Square Miles", UN_SC_MI * UN_SC_MI, 0.0,      B_UNIT_DEF_NONE},
+	{"square furlong", "square furlongs", "sq fur", NULL,  "Square Furlongs", UN_SC_FUR * UN_SC_FUR, 0.0, B_UNIT_DEF_SUPPRESS},
+	{"square chain", "square chains",     "sq ch",  NULL,  "Square Chains", UN_SC_CH * UN_SC_CH, 0.0,     B_UNIT_DEF_SUPPRESS},
+	{"square yard", "square yards",       "sq yd",  NULL,  "Square Yards", UN_SC_YD * UN_SC_YD, 0.0,      B_UNIT_DEF_NONE},
+	{"square foot", "square feet",        "sq ft",  NULL,  "Square Feet", UN_SC_FT * UN_SC_FT, 0.0,       B_UNIT_DEF_NONE}, /* base unit */
+	{"square inch", "square inches",      "sq in",  NULL,  "Square Inches", UN_SC_IN * UN_SC_IN, 0.0,     B_UNIT_DEF_NONE},
+	{"square thou", "square thous",       "sq mil", NULL,  "Square Thous", UN_SC_MIL * UN_SC_MIL, 0.0,    B_UNIT_DEF_NONE},
 	{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buImperialAreaCollecton = {buImperialAreaDef, 4, 0, sizeof(buImperialAreaDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buImperialAreaCollecton = {buImperialAreaDef, 4, 0, sizeof(buImperialAreaDef) / sizeof(bUnitDef)};
 
 /* Volumes */
 static struct bUnitDef buMetricVolDef[] = {
-	{"cubic kilometer", "cubic kilometers",		"km³", "km3",	"Cubic Kilometers", UN_SC_KM*UN_SC_KM*UN_SC_KM, 0.0,	B_UNIT_DEF_NONE},
-	{"cubic hectometer","cubic hectometers",	"hm³", "hm3",	"Cubic Hectometers", UN_SC_HM*UN_SC_HM*UN_SC_HM, 0.0,	B_UNIT_DEF_NONE},
-	{"cubic dekameter", "cubic dekameters",		"dam³","dam3",	"Cubic Dekameters", UN_SC_DAM*UN_SC_DAM*UN_SC_DAM, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"cubic meter", "cubic meters",				"m³",  "m3",	"Cubic Meters", UN_SC_M*UN_SC_M*UN_SC_M, 0.0, 			B_UNIT_DEF_NONE}, /* base unit */
-	{"cubic decimetre", "cubic decimetres",		"dm³", "dm3",	"Cubic Decimetres", UN_SC_DM*UN_SC_DM*UN_SC_DM, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"cubic centimeter", "cubic centimeters",	"cm³", "cm3",	"Cubic Centimeters", UN_SC_CM*UN_SC_CM*UN_SC_CM, 0.0,	B_UNIT_DEF_NONE},
-	{"cubic millimeter", "cubic millimeters",	"mm³", "mm3",	"Cubic Millimeters", UN_SC_MM*UN_SC_MM*UN_SC_MM, 0.0,	B_UNIT_DEF_NONE},
-	{"cubic micrometer", "cubic micrometers",	"µm³", "um3",	"Cubic Micrometers", UN_SC_UM*UN_SC_UM*UN_SC_UM, 0.0,	B_UNIT_DEF_NONE},
-	{NULL, NULL, NULL,	NULL, NULL, 0.0, 0.0}
+	{"cubic kilometer",  "cubic kilometers",  "km³",  "km3",  "Cubic Kilometers", UN_SC_KM * UN_SC_KM * UN_SC_KM, 0.0,    B_UNIT_DEF_NONE},
+	{"cubic hectometer", "cubic hectometers", "hm³",  "hm3",  "Cubic Hectometers", UN_SC_HM * UN_SC_HM * UN_SC_HM, 0.0,   B_UNIT_DEF_NONE},
+	{"cubic dekameter",  "cubic dekameters",  "dam³", "dam3", "Cubic Dekameters", UN_SC_DAM * UN_SC_DAM * UN_SC_DAM, 0.0, B_UNIT_DEF_SUPPRESS},
+	{"cubic meter",      "cubic meters",      "m³",   "m3",   "Cubic Meters", UN_SC_M * UN_SC_M * UN_SC_M, 0.0,           B_UNIT_DEF_NONE}, /* base unit */
+	{"cubic decimeter",  "cubic decimeters",  "dm³",  "dm3",  "Cubic Decimeters", UN_SC_DM * UN_SC_DM * UN_SC_DM, 0.0,    B_UNIT_DEF_SUPPRESS},
+	{"cubic centimeter", "cubic centimeters", "cm³",  "cm3",  "Cubic Centimeters", UN_SC_CM * UN_SC_CM * UN_SC_CM, 0.0,   B_UNIT_DEF_NONE},
+	{"cubic millimeter", "cubic millimeters", "mm³",  "mm3",  "Cubic Millimeters", UN_SC_MM * UN_SC_MM * UN_SC_MM, 0.0,   B_UNIT_DEF_NONE},
+	{"cubic micrometer", "cubic micrometers", "µm³",  "um3",  "Cubic Micrometers", UN_SC_UM * UN_SC_UM * UN_SC_UM, 0.0,   B_UNIT_DEF_NONE},
+	{NULL, NULL, NULL,  NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buMetricVolCollecton = {buMetricVolDef, 3, 0, sizeof(buMetricVolDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buMetricVolCollecton = {buMetricVolDef, 3, 0, sizeof(buMetricVolDef) / sizeof(bUnitDef)};
 
 static struct bUnitDef buImperialVolDef[] = {
-	{"cubic mile", "cubic miles",		"cu mi", "cu m","Cubic Miles", UN_SC_MI*UN_SC_MI*UN_SC_MI, 0.0,		B_UNIT_DEF_NONE},
-	{"cubic furlong", "cubic furlongs",	"cu fur",NULL,	"Cubic Furlongs", UN_SC_FUR*UN_SC_FUR*UN_SC_FUR, 0.0,B_UNIT_DEF_SUPPRESS},
-	{"cubic chain", "cubic chains",		"cu ch", NULL,	"Cubic Chains", UN_SC_CH*UN_SC_CH*UN_SC_CH, 0.0,	B_UNIT_DEF_SUPPRESS},
-	{"cubic yard", "cubic yards",		"cu yd", NULL,	"Cubic Yards", UN_SC_YD*UN_SC_YD*UN_SC_YD, 0.0,		B_UNIT_DEF_NONE},
-	{"cubic foot", "cubic feet",		"cu ft", NULL,	"Cubic Feet", UN_SC_FT*UN_SC_FT*UN_SC_FT, 0.0,		B_UNIT_DEF_NONE}, /* base unit */
-	{"cubic inch", "cubic inches",		"cu in", NULL,	"Cubic Inches", UN_SC_IN*UN_SC_IN*UN_SC_IN, 0.0,	B_UNIT_DEF_NONE},
-	{"cubic thou", "cubic thous",		"cu mil",NULL,	"Cubic Thous", UN_SC_MIL*UN_SC_MIL*UN_SC_MIL, 0.0,	B_UNIT_DEF_NONE},
+	{"cubic mile", "cubic miles",       "cu mi", "cu m", "Cubic Miles", UN_SC_MI * UN_SC_MI * UN_SC_MI, 0.0,     B_UNIT_DEF_NONE},
+	{"cubic furlong", "cubic furlongs", "cu fur", NULL,  "Cubic Furlongs", UN_SC_FUR * UN_SC_FUR * UN_SC_FUR, 0.0, B_UNIT_DEF_SUPPRESS},
+	{"cubic chain", "cubic chains",     "cu ch", NULL,   "Cubic Chains", UN_SC_CH * UN_SC_CH * UN_SC_CH, 0.0,    B_UNIT_DEF_SUPPRESS},
+	{"cubic yard", "cubic yards",       "cu yd", NULL,   "Cubic Yards", UN_SC_YD * UN_SC_YD * UN_SC_YD, 0.0,     B_UNIT_DEF_NONE},
+	{"cubic foot", "cubic feet",        "cu ft", NULL,   "Cubic Feet", UN_SC_FT * UN_SC_FT * UN_SC_FT, 0.0,      B_UNIT_DEF_NONE}, /* base unit */
+	{"cubic inch", "cubic inches",      "cu in", NULL ,  "Cubic Inches", UN_SC_IN * UN_SC_IN * UN_SC_IN, 0.0,    B_UNIT_DEF_NONE},
+	{"cubic thou", "cubic thous",       "cu mil", NULL,  "Cubic Thous", UN_SC_MIL * UN_SC_MIL * UN_SC_MIL, 0.0,  B_UNIT_DEF_NONE},
 	{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buImperialVolCollecton = {buImperialVolDef, 4, 0, sizeof(buImperialVolDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buImperialVolCollecton = {buImperialVolDef, 4, 0, sizeof(buImperialVolDef) / sizeof(bUnitDef)};
 
 /* Mass */
 static struct bUnitDef buMetricMassDef[] = {
-	{"ton", "tonnes",			"ton", "t", "1000 Kilograms", UN_SC_MTON, 0.0,	B_UNIT_DEF_NONE},
-	{"quintal", "quintals",		"ql", "q",	"100 Kilograms", UN_SC_QL, 0.0,		B_UNIT_DEF_NONE},
-	{"kilogram", "kilograms",	"kg", NULL,	"Kilograms", UN_SC_KG, 0.0,			B_UNIT_DEF_NONE}, /* base unit */
-	{"hectogram", "hectograms",	"hg", NULL,	"Hectograms", UN_SC_HG, 0.0,		B_UNIT_DEF_NONE},
-	{"dekagram", "dekagrams",	"dag",NULL,	"10 Grams", UN_SC_DAG, 0.0,			B_UNIT_DEF_SUPPRESS},
-	{"gram", "grams",			"g",  NULL,	"Grams", UN_SC_G, 0.0,				B_UNIT_DEF_NONE},
-	{NULL, NULL, NULL,	NULL, NULL, 0.0, 0.0}
+	{"ton", "tonnes",           "ton", "t",  "1000 Kilograms", UN_SC_MTON, 0.0,  B_UNIT_DEF_NONE},
+	{"quintal", "quintals",     "ql",  "q",  "100 Kilograms", UN_SC_QL, 0.0,     B_UNIT_DEF_NONE},
+	{"kilogram", "kilograms",   "kg",  NULL, "Kilograms", UN_SC_KG, 0.0,         B_UNIT_DEF_NONE}, /* base unit */
+	{"hectogram", "hectograms", "hg",  NULL, "Hectograms", UN_SC_HG, 0.0,        B_UNIT_DEF_NONE},
+	{"dekagram", "dekagrams",   "dag", NULL, "10 Grams", UN_SC_DAG, 0.0,         B_UNIT_DEF_SUPPRESS},
+	{"gram", "grams",           "g",   NULL, "Grams", UN_SC_G, 0.0,              B_UNIT_DEF_NONE},
+	{NULL, NULL, NULL,  NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buMetricMassCollecton = {buMetricMassDef, 2, 0, sizeof(buMetricMassDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buMetricMassCollecton = {buMetricMassDef, 2, 0, sizeof(buMetricMassDef) / sizeof(bUnitDef)};
 
 static struct bUnitDef buImperialMassDef[] = {
-	{"ton", "tonnes",	"ton", "t",	"Tonnes", UN_SC_ITON, 0.0,		B_UNIT_DEF_NONE},
+	{"ton", "tonnes",   "ton", "t", "Tonnes", UN_SC_ITON, 0.0,      B_UNIT_DEF_NONE},
 	{"centum weight", "centum weights", "cwt", NULL, "Centum weights", UN_SC_CWT, 0.0, B_UNIT_DEF_NONE},
-	{"stone", "stones",	"st", NULL,		"Stones", UN_SC_ST, 0.0,	B_UNIT_DEF_NONE},
-	{"pound", "pounds",	"lb", NULL,		"Pounds", UN_SC_LB, 0.0,	B_UNIT_DEF_NONE}, /* base unit */
-	{"ounce", "ounces",	"oz", NULL,		"Ounces", UN_SC_OZ, 0.0,	B_UNIT_DEF_NONE},
+	{"stone", "stones", "st", NULL,     "Stones", UN_SC_ST, 0.0,    B_UNIT_DEF_NONE},
+	{"pound", "pounds", "lb", NULL,     "Pounds", UN_SC_LB, 0.0,    B_UNIT_DEF_NONE}, /* base unit */
+	{"ounce", "ounces", "oz", NULL,     "Ounces", UN_SC_OZ, 0.0,    B_UNIT_DEF_NONE},
 	{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buImperialMassCollecton = {buImperialMassDef, 3, 0, sizeof(buImperialMassDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buImperialMassCollecton = {buImperialMassDef, 3, 0, sizeof(buImperialMassDef) / sizeof(bUnitDef)};
 
 /* Even if user scales the system to a point where km^3 is used, velocity and
  * acceleration aren't scaled: that's why we have so few units for them */
 
 /* Velocity */
 static struct bUnitDef buMetricVelDef[] = {
-	{"meter per second", "meters per second",		"m/s",  NULL,	"Meters per second", UN_SC_M, 0.0,			  B_UNIT_DEF_NONE}, /* base unit */
-	{"kilometer per hour", "kilometers per hour",	"km/h", NULL,	"Kilometers per hour", UN_SC_KM/3600.0f, 0.0, B_UNIT_DEF_SUPPRESS},
-	{NULL, NULL, NULL,	NULL, NULL, 0.0, 0.0}
+	{"meter per second", "meters per second",       "m/s",  NULL,   "Meters per second", UN_SC_M, 0.0,            B_UNIT_DEF_NONE}, /* base unit */
+	{"kilometer per hour", "kilometers per hour",   "km/h", NULL,   "Kilometers per hour", UN_SC_KM / 3600.0f, 0.0, B_UNIT_DEF_SUPPRESS},
+	{NULL, NULL, NULL,  NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buMetricVelCollecton = {buMetricVelDef, 0, 0, sizeof(buMetricVelDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buMetricVelCollecton = {buMetricVelDef, 0, 0, sizeof(buMetricVelDef) / sizeof(bUnitDef)};
 
 static struct bUnitDef buImperialVelDef[] = {
-	{"foot per second", "feet per second",	"ft/s", "fps",	"Feet per second", UN_SC_FT, 0.0,		B_UNIT_DEF_NONE}, /* base unit */
-	{"mile per hour", "miles per hour",		"mph", NULL,	"Miles per hour", UN_SC_MI/3600.0f, 0.0,B_UNIT_DEF_SUPPRESS},
+	{"foot per second", "feet per second",  "ft/s", "fps",  "Feet per second", UN_SC_FT, 0.0,       B_UNIT_DEF_NONE}, /* base unit */
+	{"mile per hour", "miles per hour",     "mph", NULL,    "Miles per hour", UN_SC_MI / 3600.0f, 0.0, B_UNIT_DEF_SUPPRESS},
 	{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buImperialVelCollecton = {buImperialVelDef, 0, 0, sizeof(buImperialVelDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buImperialVelCollecton = {buImperialVelDef, 0, 0, sizeof(buImperialVelDef) / sizeof(bUnitDef)};
 
 /* Acceleration */
 static struct bUnitDef buMetricAclDef[] = {
 	{"meter per second squared", "meters per second squared", "m/s²", "m/s2", "Meters per second squared", UN_SC_M, 0.0, B_UNIT_DEF_NONE}, /* base unit */
-	{NULL, NULL, NULL,	NULL, NULL, 0.0, 0.0}
+	{NULL, NULL, NULL,  NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buMetricAclCollecton = {buMetricAclDef, 0, 0, sizeof(buMetricAclDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buMetricAclCollecton = {buMetricAclDef, 0, 0, sizeof(buMetricAclDef) / sizeof(bUnitDef)};
 
 static struct bUnitDef buImperialAclDef[] = {
 	{"foot per second squared", "feet per second squared", "ft/s²", "ft/s2", "Feet per second squared", UN_SC_FT, 0.0, B_UNIT_DEF_NONE}, /* base unit */
 	{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buImperialAclCollecton = {buImperialAclDef, 0, 0, sizeof(buImperialAclDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buImperialAclCollecton = {buImperialAclDef, 0, 0, sizeof(buImperialAclDef) / sizeof(bUnitDef)};
 
 /* Time */
 static struct bUnitDef buNaturalTimeDef[] = {
 	/* weeks? - probably not needed for blender */
-	{"day", "days",					"d", NULL,	"Days",			90000.0, 0.0,	B_UNIT_DEF_NONE},
-	{"hour", "hours",				"hr", "h",	"Hours",		3600.0, 0.0,	B_UNIT_DEF_NONE},
-	{"minute", "minutes",			"min", "m",	"Minutes",		60.0, 0.0,		B_UNIT_DEF_NONE},
-	{"second", "seconds",			"sec", "s",	"Seconds",		1.0, 0.0,		B_UNIT_DEF_NONE}, /* base unit */
-	{"millisecond", "milliseconds",	"ms", NULL,	"Milliseconds",	0.001, 0.0,		B_UNIT_DEF_NONE},
-	{"microsecond", "microseconds",	"µs", "us",	"Microseconds",	0.000001, 0.0,	B_UNIT_DEF_NONE},
+	{"day", "days",                 "d", NULL,  "Days",         90000.0, 0.0,   B_UNIT_DEF_NONE},
+	{"hour", "hours",               "hr", "h",  "Hours",        3600.0, 0.0,    B_UNIT_DEF_NONE},
+	{"minute", "minutes",           "min", "m", "Minutes",      60.0, 0.0,      B_UNIT_DEF_NONE},
+	{"second", "seconds",           "sec", "s", "Seconds",      1.0, 0.0,       B_UNIT_DEF_NONE}, /* base unit */
+	{"millisecond", "milliseconds", "ms", NULL, "Milliseconds", 0.001, 0.0,     B_UNIT_DEF_NONE},
+	{"microsecond", "microseconds", "µs", "us", "Microseconds", 0.000001, 0.0,  B_UNIT_DEF_NONE},
 	{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buNaturalTimeCollecton = {buNaturalTimeDef, 3, 0, sizeof(buNaturalTimeDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buNaturalTimeCollecton = {buNaturalTimeDef, 3, 0, sizeof(buNaturalTimeDef) / sizeof(bUnitDef)};
 
 
 static struct bUnitDef buNaturalRotDef[] = {
@@ -264,7 +264,7 @@ static struct bUnitDef buNaturalRotDef[] = {
 //	{"turn", "turns",				"t", NULL, "Turns",			1.0/(M_PI*2.0), 0.0,B_UNIT_DEF_NONE},
 	{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}
 };
-static struct bUnitCollection buNaturalRotCollection = {buNaturalRotDef, 0, 0, sizeof(buNaturalRotDef)/sizeof(bUnitDef)};
+static struct bUnitCollection buNaturalRotCollection = {buNaturalRotDef, 0, 0, sizeof(buNaturalRotDef) / sizeof(bUnitDef)};
 
 #define UNIT_SYSTEM_TOT (((sizeof(bUnitSystems) / 9) / sizeof(void *)) - 1)
 static struct bUnitCollection *bUnitSystems[][9] = {
diff --git a/source/blender/blenkernel/intern/writeffmpeg.c b/source/blender/blenkernel/intern/writeffmpeg.c
index b3101638a4e..f72942df8b3 100644
--- a/source/blender/blenkernel/intern/writeffmpeg.c
+++ b/source/blender/blenkernel/intern/writeffmpeg.c
@@ -924,7 +924,7 @@ void BKE_ffmpeg_filepath_get(char *string, RenderData *rd)
 		fe++;
 	}
 
-	if (!*fe) {
+	if (*fe == NULL) {
 		strcat(string, autosplit);
 
 		BLI_path_frame_range(string, rd->sfra, rd->efra, 4);