Merge branch 'master' into viewport_experiments

166 files changed, 4375 insertions, 1024 deletions

diff --git a/source/blender/blenfont/intern/blf_lang.c b/source/blender/blenfont/intern/blf_lang.c
index 8951ef50607..99e1aa5d3e3 100644
--- a/source/blender/blenfont/intern/blf_lang.c
+++ b/source/blender/blenfont/intern/blf_lang.c
@@ -209,13 +209,16 @@ void BLF_lang_init(void)
 	 * Would also be good to find nicer way to check if LANG is correct.
 	 */
 	const char *lang = getenv("LANG");
-	if(lang != NULL) {
+	if (lang != NULL) {
 		char *old_locale = setlocale(LC_ALL, NULL);
+		/* Make a copy so subsequenct setlocale() doesn't interfere. */
+		old_locale = BLI_strdup(old_locale);
 		if (setlocale(LC_ALL, lang) == NULL) {
 			setenv("LANG", "C", 1);
 			printf("Warning: Falling back to the standard locale (\"C\")\n");
 		}
 		setlocale(LC_ALL, old_locale);
+		MEM_freeN(old_locale);
 	}
 #endif
 
diff --git a/source/blender/blenkernel/BKE_DerivedMesh.h b/source/blender/blenkernel/BKE_DerivedMesh.h
index da982f869e8..04251641d9b 100644
--- a/source/blender/blenkernel/BKE_DerivedMesh.h
+++ b/source/blender/blenkernel/BKE_DerivedMesh.h
@@ -88,6 +88,7 @@ struct MTFace;
 struct Object;
 struct Scene;
 struct Mesh;
+struct MLoopNorSpaceArray;
 struct BMEditMesh;
 struct KeyBlock;
 struct ModifierData;
@@ -199,6 +200,10 @@ struct DerivedMesh {
 	/** Calculate loop (split) normals */
 	void (*calcLoopNormals)(DerivedMesh *dm, const bool use_split_normals, const float split_angle);
 
+	/** Calculate loop (split) normals, and returns split loop normal spacearr. */
+	void (*calcLoopNormalsSpaceArray)(DerivedMesh *dm, const bool use_split_normals, const float split_angle,
+	                                  struct MLoopNorSpaceArray *r_lnors_spacearr);
+
 	/** Recalculates mesh tessellation */
 	void (*recalcTessellation)(DerivedMesh *dm);
 
diff --git a/source/blender/blenkernel/BKE_blender.h b/source/blender/blenkernel/BKE_blender.h
index a2214f79618..2c53a247f6d 100644
--- a/source/blender/blenkernel/BKE_blender.h
+++ b/source/blender/blenkernel/BKE_blender.h
@@ -42,7 +42,7 @@ extern "C" {
  * and keep comment above the defines.
  * Use STRINGIFY() rather than defining with quotes */
 #define BLENDER_VERSION         273
-#define BLENDER_SUBVERSION      5
+#define BLENDER_SUBVERSION      6
 /* 262 was the last editmesh release but it has compatibility code for bmesh data */
 #define BLENDER_MINVERSION      270
 #define BLENDER_MINSUBVERSION   5
@@ -88,7 +88,7 @@ void BKE_userdef_free(void);
 void BKE_userdef_state(void);
 	
 /* set this callback when a UI is running */
-void set_blender_test_break_cb(void (*func)(void) );
+void set_blender_test_break_cb(void (*func)(void));
 int blender_test_break(void);
 
 #define BKE_UNDO_STR_MAX 64
diff --git a/source/blender/blenkernel/BKE_cdderivedmesh.h b/source/blender/blenkernel/BKE_cdderivedmesh.h
index 448617f73f9..59ec316a403 100644
--- a/source/blender/blenkernel/BKE_cdderivedmesh.h
+++ b/source/blender/blenkernel/BKE_cdderivedmesh.h
@@ -40,6 +40,7 @@
 struct DerivedMesh;
 struct BMEditMesh;
 struct Mesh;
+struct MLoopNorSpaceArray;
 struct Object;
 
 /* creates a new CDDerivedMesh */
@@ -107,6 +108,8 @@ void CDDM_calc_normals(struct DerivedMesh *dm);
 void CDDM_calc_normals_tessface(struct DerivedMesh *dm);
 
 void CDDM_calc_loop_normals(struct DerivedMesh *dm, const bool use_split_normals, const float split_angle);
+void CDDM_calc_loop_normals_spacearr(struct DerivedMesh *dm, const bool use_split_normals, const float split_angle,
+                                     struct MLoopNorSpaceArray *r_lnors_spacearr);
 
 /* calculates edges for a CDDerivedMesh (from face data)
  * this completely replaces the current edge data in the DerivedMesh
diff --git a/source/blender/blenkernel/BKE_customdata.h b/source/blender/blenkernel/BKE_customdata.h
index f11aad27e4b..f3f1e0a407e 100644
--- a/source/blender/blenkernel/BKE_customdata.h
+++ b/source/blender/blenkernel/BKE_customdata.h
@@ -397,6 +397,8 @@ enum {
 	CD_FAKE_BWEIGHT     = CD_FAKE | CD_BWEIGHT,  /* *sigh*. */
 	CD_FAKE_UV          = CD_FAKE | CD_MLOOPUV,  /* UV flag, because we handle both loop's UVs and poly's textures. */
 
+	CD_FAKE_LNOR        = CD_FAKE | CD_CUSTOMLOOPNORMAL,  /* Because we play with clnor and temp lnor layers here. */
+
 	CD_FAKE_SHARP       = CD_FAKE | 200,  /* Sharp flag for edges, smooth flag for faces. */
 };
 
diff --git a/source/blender/blenkernel/BKE_data_transfer.h b/source/blender/blenkernel/BKE_data_transfer.h
index d31804b3cae..cea093adca4 100644
--- a/source/blender/blenkernel/BKE_data_transfer.h
+++ b/source/blender/blenkernel/BKE_data_transfer.h
@@ -57,6 +57,7 @@ enum {
 	DT_TYPE_FREESTYLE_EDGE          = 1 << 12,
 
 	DT_TYPE_VCOL                    = 1 << 16,
+	DT_TYPE_LNOR                    = 1 << 17,
 
 	DT_TYPE_UV                      = 1 << 24,
 	DT_TYPE_SHARP_FACE              = 1 << 25,
@@ -67,7 +68,7 @@ enum {
 	DT_TYPE_VERT_ALL                = DT_TYPE_MDEFORMVERT | DT_TYPE_SHAPEKEY | DT_TYPE_SKIN | DT_TYPE_BWEIGHT_VERT,
 	DT_TYPE_EDGE_ALL                = DT_TYPE_SHARP_EDGE | DT_TYPE_SEAM | DT_TYPE_CREASE | DT_TYPE_BWEIGHT_EDGE |
 	                                  DT_TYPE_FREESTYLE_EDGE,
-	DT_TYPE_LOOP_ALL                = DT_TYPE_VCOL | DT_TYPE_UV,
+	DT_TYPE_LOOP_ALL                = DT_TYPE_VCOL | DT_TYPE_LNOR | DT_TYPE_UV,
 	DT_TYPE_POLY_ALL                = DT_TYPE_UV | DT_TYPE_SHARP_FACE | DT_TYPE_FREESTYLE_FACE,
 };
 
@@ -85,7 +86,7 @@ int BKE_object_data_transfer_dttype_to_srcdst_index(const int dtdata_type);
 #define DT_DATATYPE_IS_EDGE(_dt) \
 	ELEM(_dt, DT_TYPE_CREASE, DT_TYPE_SHARP_EDGE, DT_TYPE_SEAM, DT_TYPE_BWEIGHT_EDGE, DT_TYPE_FREESTYLE_EDGE)
 #define DT_DATATYPE_IS_LOOP(_dt) \
-	ELEM(_dt, DT_TYPE_UV, DT_TYPE_VCOL)
+	ELEM(_dt, DT_TYPE_UV, DT_TYPE_VCOL, DT_TYPE_LNOR)
 #define DT_DATATYPE_IS_POLY(_dt) \
 	ELEM(_dt, DT_TYPE_UV, DT_TYPE_SHARP_FACE, DT_TYPE_FREESTYLE_FACE)
 
diff --git a/source/blender/blenkernel/BKE_group.h b/source/blender/blenkernel/BKE_group.h
index f528fe8c7f9..820e1ea1494 100644
--- a/source/blender/blenkernel/BKE_group.h
+++ b/source/blender/blenkernel/BKE_group.h
@@ -50,6 +50,7 @@ bool          BKE_group_object_add(struct Group *group, struct Object *ob, struc
 bool          BKE_group_object_unlink(struct Group *group, struct Object *ob, struct Scene *scene, struct Base *base);
 struct Group *BKE_group_object_find(struct Group *group, struct Object *ob);
 bool          BKE_group_object_exists(struct Group *group, struct Object *ob);
+bool          BKE_group_object_cyclic_check(struct Main *bmain, struct Object *object, struct Group *group);
 bool          BKE_group_is_animated(struct Group *group, struct Object *parent);
 
 void          BKE_group_tag_recalc(struct Group *group);
diff --git a/source/blender/blenkernel/BKE_image.h b/source/blender/blenkernel/BKE_image.h
index 5ee8ae231d8..2c9ecef4c2d 100644
--- a/source/blender/blenkernel/BKE_image.h
+++ b/source/blender/blenkernel/BKE_image.h
@@ -91,6 +91,7 @@ void    BKE_imformat_defaults(struct ImageFormatData *im_format);
 void    BKE_imbuf_to_image_format(struct ImageFormatData *im_format, const struct ImBuf *imbuf);
 
 struct anim *openanim(const char *name, int flags, int streamindex, char colorspace[IMA_MAX_SPACE]);
+struct anim *openanim_noload(const char *name, int flags, int streamindex, char colorspace[IMA_MAX_SPACE]);
 
 void    BKE_image_de_interlace(struct Image *ima, int odd);
 
@@ -185,9 +186,6 @@ void BKE_image_walk_all_users(const struct Main *mainp, void *customdata,
 /* ensures an Image exists for viewing nodes or render */
 struct Image *BKE_image_verify_viewer(int type, const char *name);
 
-/* force an ImBuf to become part of Image */
-void BKE_image_assign_ibuf(struct Image *ima, struct ImBuf *ibuf);
-
 /* called on frame change or before render */
 void BKE_image_user_frame_calc(struct ImageUser *iuser, int cfra, int fieldnr);
 void BKE_image_user_check_frame_calc(struct ImageUser *iuser, int cfra, int fieldnr);
diff --git a/source/blender/blenkernel/BKE_library.h b/source/blender/blenkernel/BKE_library.h
index 500c2813a75..e88a4e88209 100644
--- a/source/blender/blenkernel/BKE_library.h
+++ b/source/blender/blenkernel/BKE_library.h
@@ -107,8 +107,8 @@ void BKE_library_make_local(struct Main *bmain, struct Library *lib, bool untagg
 struct ID *BKE_libblock_find_name_ex(struct Main *bmain, const short type, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();
 struct ID *BKE_libblock_find_name(const short type, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();
 
-void set_free_windowmanager_cb(void (*func)(struct bContext *, struct wmWindowManager *) );
-void set_free_notifier_reference_cb(void (*func)(const void *) );
+void set_free_windowmanager_cb(void (*func)(struct bContext *, struct wmWindowManager *));
+void set_free_notifier_reference_cb(void (*func)(const void *));
 
 /* use when "" is given to new_id() */
 #define ID_FALLBACK_NAME N_("Untitled")
diff --git a/source/blender/blenkernel/BKE_mesh.h b/source/blender/blenkernel/BKE_mesh.h
index c9f61cac254..224be0f3685 100644
--- a/source/blender/blenkernel/BKE_mesh.h
+++ b/source/blender/blenkernel/BKE_mesh.h
@@ -36,6 +36,9 @@ struct BoundBox;
 struct DispList;
 struct EdgeHash;
 struct ListBase;
+struct LinkNode;
+struct BLI_Stack;
+struct MemArena;
 struct BMEditMesh;
 struct BMesh;
 struct Main;
@@ -174,11 +177,6 @@ void BKE_mesh_calc_normals_tessface(
         struct MVert *mverts, int numVerts,
         struct MFace *mfaces, int numFaces,
         float (*r_faceNors)[3]);
-void BKE_mesh_normals_loop_split(
-        struct MVert *mverts, const int numVerts, struct MEdge *medges, const int numEdges,
-        struct MLoop *mloops, float (*r_loopnors)[3], const int numLoops,
-        struct MPoly *mpolys, float (*polynors)[3], const int numPolys,
-        const bool use_split_normals, float split_angle);
 void BKE_mesh_loop_tangents_ex(
         struct MVert *mverts, const int numVerts, struct MLoop *mloops, float (*r_looptangent)[4], float (*loopnors)[3],
         struct MLoopUV *loopuv, const int numLoops, struct MPoly *mpolys, const int numPolys,
@@ -186,6 +184,56 @@ void BKE_mesh_loop_tangents_ex(
 void BKE_mesh_loop_tangents(
         struct Mesh *mesh, const char *uvmap, float (*r_looptangents)[4], struct ReportList *reports);
 
+/**
+ * References a contiguous loop-fan with normal offset vars.
+ */
+typedef struct MLoopNorSpace {
+	float vec_lnor[3];      /* Automatically computed loop normal. */
+	float vec_ref[3];       /* Reference vector, orthogonal to vec_lnor. */
+	float vec_ortho[3];     /* Third vector, orthogonal to vec_lnor and vec_ref. */
+	float ref_alpha;        /* Reference angle, around vec_ortho, in ]0, pi] range (0.0 marks that space as invalid). */
+	float ref_beta;         /* Reference angle, around vec_lnor, in ]0, 2pi] range (0.0 marks that space as invalid). */
+	struct LinkNode *loops; /* All indices (uint_in_ptr) of loops using this lnor space (i.e. smooth fan of loops). */
+} MLoopNorSpace;
+/**
+ * Collection of #MLoopNorSpace basic storage & pre-allocation.
+ */
+typedef struct MLoopNorSpaceArray {
+	MLoopNorSpace **lspacearr;    /* MLoop aligned array */
+	struct LinkNode *loops_pool;  /* Allocated once, avoids to call BLI_linklist_prepend_arena() for each loop! */
+	struct MemArena *mem;
+} MLoopNorSpaceArray;
+void BKE_lnor_spacearr_init(MLoopNorSpaceArray *lnors_spacearr, const int numLoops);
+void BKE_lnor_spacearr_clear(MLoopNorSpaceArray *lnors_spacearr);
+void BKE_lnor_spacearr_free(MLoopNorSpaceArray *lnors_spacearr);
+MLoopNorSpace *BKE_lnor_space_create(MLoopNorSpaceArray *lnors_spacearr);
+void BKE_lnor_space_define(
+        MLoopNorSpace *lnor_space, const float lnor[3], float vec_ref[3], float vec_other[3],
+        struct BLI_Stack *edge_vectors);
+void BKE_lnor_space_add_loop(
+        MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpace *lnor_space, const int ml_index, const bool add_to_list);
+void BKE_lnor_space_custom_data_to_normal(MLoopNorSpace *lnor_space, const short clnor_data[2], float r_custom_lnor[3]);
+void BKE_lnor_space_custom_normal_to_data(MLoopNorSpace *lnor_space, const float custom_lnor[3], short r_clnor_data[2]);
+
+bool BKE_mesh_has_custom_loop_normals(struct Mesh *me);
+
+void BKE_mesh_normals_loop_split(struct MVert *mverts, const int numVerts, struct MEdge *medges, const int numEdges,
+        struct MLoop *mloops, float (*r_loopnors)[3], const int numLoops,
+        struct MPoly *mpolys, const float (*polynors)[3], const int numPolys,
+        const bool use_split_normals, float split_angle,
+        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2], int *r_loop_to_poly);
+
+void BKE_mesh_normals_loop_custom_set(
+        struct MVert *mverts, const int numVerts, struct MEdge *medges, const int numEdges,
+        struct MLoop *mloops, float (*custom_loopnors)[3], const int numLoops,
+        struct MPoly *mpolys, const float (*polynors)[3], const int numPolys,
+        short (*r_clnors_data)[2]);
+void BKE_mesh_normals_loop_custom_from_vertices_set(
+        struct MVert *mverts, float (*custom_vertnors)[3], const int numVerts,
+        struct MEdge *medges, const int numEdges, struct MLoop *mloops, const int numLoops,
+        struct MPoly *mpolys, const float (*polynors)[3], const int numPolys,
+        short (*r_clnors_data)[2]);
+
 void BKE_mesh_calc_poly_normal(
         struct MPoly *mpoly, struct MLoop *loopstart,
         struct MVert *mvarray, float no[3]);
@@ -287,7 +335,7 @@ void BKE_mesh_calc_relative_deform(
 
 /* *** mesh_validate.c *** */
 
-int BKE_mesh_validate(struct Mesh *me, const int do_verbose);
+int BKE_mesh_validate(struct Mesh *me, const int do_verbose, const int cddata_check_mask);
 void BKE_mesh_cd_validate(struct Mesh *me);
 int BKE_mesh_validate_material_indices(struct Mesh *me);
 
diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index ad316e55d85..51f17f738f0 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -3485,7 +3485,7 @@ bool DM_is_valid(DerivedMesh *dm)
 	        dm->getEdgeDataLayout(dm),
 	        dm->getLoopDataLayout(dm),
 	        dm->getPolyDataLayout(dm),
-	        0,  /* setting mask here isn't useful, gives false positives */
+	        false,  /* setting mask here isn't useful, gives false positives */
 	        do_verbose, do_fixes, &changed);
 
 	is_valid &= BKE_mesh_validate_arrays(
diff --git a/source/blender/blenkernel/intern/blender.c b/source/blender/blenkernel/intern/blender.c
index 78b937c849c..fb02af1be20 100644
--- a/source/blender/blenkernel/intern/blender.c
+++ b/source/blender/blenkernel/intern/blender.c
@@ -573,7 +573,7 @@ int BKE_write_file_userdef(const char *filepath, ReportList *reports)
 
 static void (*blender_test_break_cb)(void) = NULL;
 
-void set_blender_test_break_cb(void (*func)(void) )
+void set_blender_test_break_cb(void (*func)(void))
 {
 	blender_test_break_cb = func;
 }
diff --git a/source/blender/blenkernel/intern/bpath.c b/source/blender/blenkernel/intern/bpath.c
index e6bfd5c113c..fc3c1a20700 100644
--- a/source/blender/blenkernel/intern/bpath.c
+++ b/source/blender/blenkernel/intern/bpath.c
@@ -284,7 +284,7 @@ static bool findMissingFiles_visit_cb(void *userdata, char *path_dst, const char
 	filename_new[0] = '\0';
 
 	found = findFileRecursive(filename_new,
-	                          data->searchdir, BLI_path_basename((char *)path_src),
+	                          data->searchdir, BLI_path_basename(path_src),
 	                          &filesize, &recur_depth);
 
 	if (filesize == -1) { /* could not open dir */
@@ -296,7 +296,7 @@ static bool findMissingFiles_visit_cb(void *userdata, char *path_dst, const char
 	else if (found == false) {
 		BKE_reportf(data->reports, RPT_WARNING,
 		            "Could not find '%s' in '%s'",
-		            BLI_path_basename((char *)path_src), data->searchdir);
+		            BLI_path_basename(path_src), data->searchdir);
 		return false;
 	}
 	else {
diff --git a/source/blender/blenkernel/intern/brush.c b/source/blender/blenkernel/intern/brush.c
index 082a4cf34c2..10d77921515 100644
--- a/source/blender/blenkernel/intern/brush.c
+++ b/source/blender/blenkernel/intern/brush.c
@@ -810,6 +810,9 @@ void BKE_brush_size_set(Scene *scene, Brush *brush, int size)
 	
 	size = (int)((float)size / U.pixelsize);
 	
+	/* make sure range is sane */
+	CLAMP(size, 1, MAX_BRUSH_PIXEL_RADIUS);
+
 	if (ups->flag & UNIFIED_PAINT_SIZE)
 		ups->size = size;
 	else
diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c
index 084376e768e..2554151c99d 100644
--- a/source/blender/blenkernel/intern/cdderivedmesh.c
+++ b/source/blender/blenkernel/intern/cdderivedmesh.c
@@ -1540,6 +1540,7 @@ static CDDerivedMesh *cdDM_create(const char *desc)
 
 	dm->calcNormals = CDDM_calc_normals;
 	dm->calcLoopNormals = CDDM_calc_loop_normals;
+	dm->calcLoopNormalsSpaceArray = CDDM_calc_loop_normals_spacearr;
 	dm->recalcTessellation = CDDM_recalc_tessellation;
 
 	dm->getVertCos = cdDM_getVertCos;
@@ -2158,6 +2159,14 @@ void CDDM_calc_normals(DerivedMesh *dm)
 
 void CDDM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, const float split_angle)
 {
+	CDDM_calc_loop_normals_spacearr(dm, use_split_normals, split_angle, NULL);
+}
+
+/* #define DEBUG_CLNORS */
+
+void CDDM_calc_loop_normals_spacearr(
+        DerivedMesh *dm, const bool use_split_normals, const float split_angle, MLoopNorSpaceArray *r_lnors_spacearr)
+{
 	MVert *mverts = dm->getVertArray(dm);
 	MEdge *medges = dm->getEdgeArray(dm);
 	MLoop *mloops = dm->getLoopArray(dm);
@@ -2166,6 +2175,7 @@ void CDDM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, const
 	CustomData *ldata, *pdata;
 
 	float (*lnors)[3];
+	short (*clnor_data)[2];
 	float (*pnors)[3];
 
 	const int numVerts = dm->getNumVerts(dm);
@@ -2193,8 +2203,37 @@ void CDDM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, const
 
 	dm->dirty &= ~DM_DIRTY_NORMALS;
 
+	clnor_data = CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL);
+
 	BKE_mesh_normals_loop_split(mverts, numVerts, medges, numEdges, mloops, lnors, numLoops,
-	                            mpolys, pnors, numPolys, use_split_normals, split_angle);
+	                            mpolys, (const float (*)[3])pnors, numPolys,
+	                            use_split_normals, split_angle,
+	                            r_lnors_spacearr, clnor_data, NULL);
+#ifdef DEBUG_CLNORS
+	if (r_lnors_spacearr) {
+		int i;
+		for (i = 0; i < numLoops; i++) {
+			if (r_lnors_spacearr->lspacearr[i]->ref_alpha != 0.0f) {
+				LinkNode *loops = r_lnors_spacearr->lspacearr[i]->loops;
+				printf("Loop %d uses lnor space %p:\n", i, r_lnors_spacearr->lspacearr[i]);
+				print_v3("\tfinal lnor", lnors[i]);
+				print_v3("\tauto lnor", r_lnors_spacearr->lspacearr[i]->vec_lnor);
+				print_v3("\tref_vec", r_lnors_spacearr->lspacearr[i]->vec_ref);
+				printf("\talpha: %f\n\tbeta: %f\n\tloops: %p\n", r_lnors_spacearr->lspacearr[i]->ref_alpha,
+				       r_lnors_spacearr->lspacearr[i]->ref_beta, r_lnors_spacearr->lspacearr[i]->loops);
+				printf("\t\t(shared with loops");
+				while (loops) {
+					printf(" %d", GET_INT_FROM_POINTER(loops->link));
+					loops = loops->next;
+				}
+				printf(")\n");
+			}
+			else {
+				printf("Loop %d has no lnor space\n", i);
+			}
+		}
+	}
+#endif
 }
 
 
diff --git a/source/blender/blenkernel/intern/customdata.c b/source/blender/blenkernel/intern/customdata.c
index a259958dc0c..0436ec0ef22 100644
--- a/source/blender/blenkernel/intern/customdata.c
+++ b/source/blender/blenkernel/intern/customdata.c
@@ -300,6 +300,49 @@ static void layerInterp_mdeformvert(void **sources, const float *weights,
 	}
 }
 
+static void layerInterp_normal(void **sources, const float *weights,
+                               const float *UNUSED(sub_weights), int count, void *dest)
+{
+	float no[3] = {0.0f};
+
+	while (count--) {
+		madd_v3_v3fl(no, (float *)sources[count], weights[count]);
+	}
+
+	copy_v3_v3((float *)dest, no);
+}
+
+static void layerCopyValue_normal(const void *source, void *dest, const int mixmode, const float mixfactor)
+{
+	const float *no_src = source;
+	float *no_dst = dest;
+	float no_tmp[3];
+
+	if (ELEM(mixmode, CDT_MIX_NOMIX, CDT_MIX_REPLACE_ABOVE_THRESHOLD, CDT_MIX_REPLACE_BELOW_THRESHOLD)) {
+		/* Above/below threshold modes are not supported here, fallback to nomix (just in case). */
+		copy_v3_v3(no_dst, no_src);
+	}
+	else {  /* Modes that support 'real' mix factor. */
+		/* Since we normalize in the end, MIX and ADD are the same op here. */
+		if (ELEM(mixmode, CDT_MIX_MIX, CDT_MIX_ADD)) {
+			add_v3_v3v3(no_tmp, no_dst, no_src);
+			normalize_v3(no_tmp);
+		}
+		else if (mixmode == CDT_MIX_SUB) {
+			sub_v3_v3v3(no_tmp, no_dst, no_src);
+			normalize_v3(no_tmp);
+		}
+		else if (mixmode == CDT_MIX_MUL) {
+			mul_v3_v3v3(no_tmp, no_dst, no_src);
+			normalize_v3(no_tmp);
+		}
+		else {
+			copy_v3_v3(no_tmp, no_src);
+		}
+		interp_v3_v3v3_slerp_safe(no_dst, no_dst, no_tmp, mixfactor);
+	}
+}
+
 static void layerCopy_tface(const void *source, void *dest, int count)
 {
 	const MTFace *source_tf = (const MTFace *)source;
@@ -1165,7 +1208,8 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
 	{sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, layerDefault_origindex},
 	/* 8: CD_NORMAL */
 	/* 3 floats per normal vector */
-	{sizeof(float) * 3, "vec3f", 1, NULL, NULL, NULL, NULL, NULL, NULL},
+	{sizeof(float) * 3, "vec3f", 1, NULL, NULL, NULL, layerInterp_normal, NULL, NULL,
+	 NULL, NULL, NULL, NULL, NULL, layerCopyValue_normal},
 	/* 9: CD_POLYINDEX (deprecated) */
 	{sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
 	/* 10: CD_PROP_FLT */
@@ -1255,6 +1299,8 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
 	{sizeof(float[4]), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
 	/* 40: CD_TESSLOOPNORMAL */
 	{sizeof(short[4][3]), "", 0, NULL, NULL, NULL, NULL, layerSwap_flnor, NULL},
+	/* 41: CD_CUSTOMLOOPNORMAL */
+	{sizeof(short[2]), "vec2s", 1, NULL, NULL, NULL, NULL, NULL, NULL},
 };
 
 /* note, numbers are from trunk and need updating for bmesh */
@@ -1270,7 +1316,8 @@ static const char *LAYERTYPENAMES[CD_NUMTYPES] = {
 	/* 25-29 */ "CDMPoly", "CDMLoop", "CDShapeKeyIndex", "CDShapeKey", "CDBevelWeight",
 	/* 30-34 */ "CDSubSurfCrease", "CDOrigSpaceLoop", "CDPreviewLoopCol", "CDBMElemPyPtr", "CDPaintMask",
 	/* 35-36 */ "CDGridPaintMask", "CDMVertSkin",
-	/* 37-40 */ "CDFreestyleEdge", "CDFreestyleFace", "CDMLoopTangent", "CDTessLoopNormal",
+	/* 37-38 */ "CDFreestyleEdge", "CDFreestyleFace",
+	/* 39-41 */ "CDMLoopTangent", "CDTessLoopNormal", "CDCustomLoopNormal",
 };
 
 
@@ -1282,26 +1329,29 @@ const CustomDataMask CD_MASK_MESH =
     CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS |
     CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MPOLY | CD_MASK_MLOOP |
     CD_MASK_MTEXPOLY | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
-    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE;
+    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
+    CD_MASK_CUSTOMLOOPNORMAL;
 const CustomDataMask CD_MASK_EDITMESH =
     CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE | CD_MASK_MLOOPUV |
     CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_SHAPE_KEYINDEX |
     CD_MASK_MCOL | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR |
     CD_MASK_MDISPS | CD_MASK_SHAPEKEY | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
-    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN;
+    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_CUSTOMLOOPNORMAL;
 const CustomDataMask CD_MASK_DERIVEDMESH =
     CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE |
     CD_MASK_MCOL | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_CLOTH_ORCO |
     CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_PREVIEW_MLOOPCOL |
     CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORIGSPACE_MLOOP | CD_MASK_ORCO | CD_MASK_TANGENT |
     CD_MASK_PREVIEW_MCOL | CD_MASK_SHAPEKEY | CD_MASK_RECAST |
-    CD_MASK_ORIGINDEX | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE;
+    CD_MASK_ORIGINDEX | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
+    CD_MASK_CUSTOMLOOPNORMAL;
 const CustomDataMask CD_MASK_BMESH =
     CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY |
     CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_PROP_FLT | CD_MASK_PROP_INT |
     CD_MASK_PROP_STR | CD_MASK_SHAPEKEY | CD_MASK_SHAPE_KEYINDEX | CD_MASK_MDISPS |
     CD_MASK_CREASE | CD_MASK_BWEIGHT | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
-    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE;
+    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
+    CD_MASK_CUSTOMLOOPNORMAL;
 const CustomDataMask CD_MASK_FACECORNERS =  /* XXX Not used anywhere! */
     CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV |
     CD_MASK_MLOOPCOL | CD_MASK_NORMAL | CD_MASK_MLOOPTANGENT;
@@ -1316,7 +1366,7 @@ const CustomDataMask CD_MASK_EVERYTHING =
     /* BMESH ONLY END */
     CD_MASK_PAINT_MASK | CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN |
     CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
-    CD_MASK_MLOOPTANGENT | CD_MASK_TESSLOOPNORMAL;
+    CD_MASK_MLOOPTANGENT | CD_MASK_TESSLOOPNORMAL | CD_MASK_CUSTOMLOOPNORMAL;
 
 static const LayerTypeInfo *layerType_getInfo(int type)
 {
diff --git a/source/blender/blenkernel/intern/data_transfer.c b/source/blender/blenkernel/intern/data_transfer.c
index 3704174be6e..5ac7b928d96 100644
--- a/source/blender/blenkernel/intern/data_transfer.c
+++ b/source/blender/blenkernel/intern/data_transfer.c
@@ -47,6 +47,7 @@
 #include "BKE_data_transfer.h"
 #include "BKE_deform.h"
 #include "BKE_DerivedMesh.h"
+#include "BKE_mesh.h"
 #include "BKE_mesh_mapping.h"
 #include "BKE_mesh_remap.h"
 #include "BKE_object.h"
@@ -79,6 +80,9 @@ CustomDataMask BKE_object_data_transfer_dttypes_to_cdmask(const int dtdata_types
 		else if (cddata_type == CD_FAKE_UV) {
 			cddata_mask |= CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV;
 		}
+		else if (cddata_type == CD_FAKE_LNOR) {
+			cddata_mask |= CD_MASK_NORMAL | CD_MASK_CUSTOMLOOPNORMAL;
+		}
 	}
 
 	return cddata_mask;
@@ -143,6 +147,10 @@ bool BKE_object_data_transfer_get_dttypes_capacity(
 				*r_threshold = true;
 				ret = true;
 				break;
+			case DT_TYPE_LNOR:
+				*r_advanced_mixing = true;
+				ret = true;
+				break;
 			case DT_TYPE_SHARP_FACE:
 				*r_threshold = true;
 				ret = true;
@@ -217,6 +225,8 @@ int BKE_object_data_transfer_dttype_to_cdtype(const int dtdata_type)
 
 		case DT_TYPE_VCOL:
 			return CD_MLOOPCOL;
+		case DT_TYPE_LNOR:
+			return CD_FAKE_LNOR;
 
 		default:
 			BLI_assert(0);
@@ -242,6 +252,105 @@ int BKE_object_data_transfer_dttype_to_srcdst_index(const int dtdata_type)
 
 /* ********** */
 
+/* Generic pre/post processing, only used by custom loop normals currently. */
+
+static void data_transfer_dtdata_type_preprocess(
+        Object *UNUSED(ob_src), Object *UNUSED(ob_dst), DerivedMesh *dm_src, DerivedMesh *dm_dst, Mesh *me_dst,
+        const int dtdata_type, const bool dirty_nors_dst, const bool use_split_nors_src, const float split_angle_src)
+{
+	if (dtdata_type == DT_TYPE_LNOR) {
+		/* Compute custom normals into regular loop normals, which will be used for the transfer. */
+		MVert *verts_dst = dm_dst ? dm_dst->getVertArray(dm_dst) : me_dst->mvert;
+		const int num_verts_dst = dm_dst ? dm_dst->getNumVerts(dm_dst) : me_dst->totvert;
+		MEdge *edges_dst = dm_dst ? dm_dst->getEdgeArray(dm_dst) : me_dst->medge;
+		const int num_edges_dst = dm_dst ? dm_dst->getNumEdges(dm_dst) : me_dst->totedge;
+		MPoly *polys_dst = dm_dst ? dm_dst->getPolyArray(dm_dst) : me_dst->mpoly;
+		const int num_polys_dst = dm_dst ? dm_dst->getNumPolys(dm_dst) : me_dst->totpoly;
+		MLoop *loops_dst = dm_dst ? dm_dst->getLoopArray(dm_dst) : me_dst->mloop;
+		const int num_loops_dst = dm_dst ? dm_dst->getNumLoops(dm_dst) : me_dst->totloop;
+		CustomData *pdata_dst = dm_dst ? dm_dst->getPolyDataLayout(dm_dst) : &me_dst->pdata;
+		CustomData *ldata_dst = dm_dst ? dm_dst->getLoopDataLayout(dm_dst) : &me_dst->ldata;
+
+		const bool use_split_nors_dst = (me_dst->flag & ME_AUTOSMOOTH) != 0;
+		const float split_angle_dst = me_dst->smoothresh;
+
+		dm_src->calcLoopNormals(dm_src, use_split_nors_src, split_angle_src);
+
+		if (dm_dst) {
+			dm_dst->calcLoopNormals(dm_dst, use_split_nors_dst, split_angle_dst);
+		}
+		else {
+			float (*poly_nors_dst)[3];
+			float (*loop_nors_dst)[3];
+			short (*custom_nors_dst)[2] = CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL);
+
+			/* Cache poly nors into a temp CDLayer. */
+			poly_nors_dst = CustomData_get_layer(pdata_dst, CD_NORMAL);
+			if (dirty_nors_dst || !poly_nors_dst) {
+				if (!poly_nors_dst) {
+					poly_nors_dst = CustomData_add_layer(pdata_dst, CD_NORMAL, CD_CALLOC, NULL, num_polys_dst);
+					CustomData_set_layer_flag(pdata_dst, CD_NORMAL, CD_FLAG_TEMPORARY);
+				}
+				BKE_mesh_calc_normals_poly(verts_dst, num_verts_dst, loops_dst, polys_dst,
+				                           num_loops_dst, num_polys_dst, poly_nors_dst, true);
+			}
+			/* Cache loop nors into a temp CDLayer. */
+			loop_nors_dst = CustomData_get_layer(ldata_dst, CD_NORMAL);
+			if (dirty_nors_dst || loop_nors_dst) {
+				if (!loop_nors_dst) {
+					loop_nors_dst = CustomData_add_layer(ldata_dst, CD_NORMAL, CD_CALLOC, NULL, num_loops_dst);
+					CustomData_set_layer_flag(ldata_dst, CD_NORMAL, CD_FLAG_TEMPORARY);
+				}
+				BKE_mesh_normals_loop_split(verts_dst, num_verts_dst, edges_dst, num_edges_dst,
+				                            loops_dst, loop_nors_dst, num_loops_dst,
+				                            polys_dst, (const float (*)[3])poly_nors_dst, num_polys_dst,
+				                            use_split_nors_dst, split_angle_dst, NULL, custom_nors_dst, NULL);
+			}
+		}
+	}
+}
+
+static void data_transfer_dtdata_type_postprocess(
+        Object *UNUSED(ob_src), Object *UNUSED(ob_dst), DerivedMesh *UNUSED(dm_src), DerivedMesh *dm_dst, Mesh *me_dst,
+        const int dtdata_type, const bool changed)
+{
+	if (dtdata_type == DT_TYPE_LNOR) {
+		/* Bake edited destination loop normals into custom normals again. */
+		MVert *verts_dst = dm_dst ? dm_dst->getVertArray(dm_dst) : me_dst->mvert;
+		const int num_verts_dst = dm_dst ? dm_dst->getNumVerts(dm_dst) : me_dst->totvert;
+		MEdge *edges_dst = dm_dst ? dm_dst->getEdgeArray(dm_dst) : me_dst->medge;
+		const int num_edges_dst = dm_dst ? dm_dst->getNumEdges(dm_dst) : me_dst->totedge;
+		MPoly *polys_dst = dm_dst ? dm_dst->getPolyArray(dm_dst) : me_dst->mpoly;
+		const int num_polys_dst = dm_dst ? dm_dst->getNumPolys(dm_dst) : me_dst->totpoly;
+		MLoop *loops_dst = dm_dst ? dm_dst->getLoopArray(dm_dst) : me_dst->mloop;
+		const int num_loops_dst = dm_dst ? dm_dst->getNumLoops(dm_dst) : me_dst->totloop;
+		CustomData *pdata_dst = dm_dst ? dm_dst->getPolyDataLayout(dm_dst) : &me_dst->pdata;
+		CustomData *ldata_dst = dm_dst ? dm_dst->getLoopDataLayout(dm_dst) : &me_dst->ldata;
+
+		const float (*poly_nors_dst)[3] = CustomData_get_layer(pdata_dst, CD_NORMAL);
+		float (*loop_nors_dst)[3] = CustomData_get_layer(ldata_dst, CD_NORMAL);
+		short (*custom_nors_dst)[2] = CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL);
+
+		BLI_assert(poly_nors_dst);
+
+		if (!changed) {
+			return;
+		}
+
+		if (!custom_nors_dst) {
+			custom_nors_dst = CustomData_add_layer(ldata_dst, CD_CUSTOMLOOPNORMAL, CD_CALLOC, NULL, num_loops_dst);
+		}
+
+		/* Note loop_nors_dst contains our custom normals as transferred from source... */
+		BKE_mesh_normals_loop_custom_set(verts_dst, num_verts_dst, edges_dst, num_edges_dst,
+		                                 loops_dst, loop_nors_dst, num_loops_dst,
+		                                 polys_dst, poly_nors_dst, num_polys_dst,
+		                                 custom_nors_dst);
+	}
+}
+
+/* ********** */
+
 static MeshRemapIslandsCalc data_transfer_get_loop_islands_generator(const int cddata_type)
 {
 	switch (cddata_type) {
@@ -805,6 +914,10 @@ static bool data_transfer_layersmapping_generate(
 		if (cddata_type == CD_FAKE_UV) {
 			cddata_type = CD_MLOOPUV;
 		}
+		else if (cddata_type == CD_FAKE_LNOR) {
+			/* Preprocess should have generated it, Postprocess will convert it back to CD_CUSTOMLOOPNORMAL. */
+			cddata_type = CD_NORMAL;
+		}
 
 		if (!(cddata_type & CD_FAKE)) {
 			cd_src = dm_src->getLoopDataLayout(dm_src);
@@ -1023,6 +1136,10 @@ bool BKE_object_data_transfer_dm(
 			continue;
 		}
 
+		data_transfer_dtdata_type_preprocess(ob_src, ob_dst, dm_src, dm_dst, me_dst,
+		                                     dtdata_type, dirty_nors_dst,
+		                                     (me_src->flag & ME_AUTOSMOOTH) != 0, me_src->smoothresh);
+
 		cddata_type = BKE_object_data_transfer_dttype_to_cdtype(dtdata_type);
 
 		fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(dtdata_type);
@@ -1217,6 +1334,8 @@ bool BKE_object_data_transfer_dm(
 				BLI_freelistN(&lay_map);
 			}
 		}
+
+		data_transfer_dtdata_type_postprocess(ob_src, ob_dst, dm_src, dm_dst, me_dst, dtdata_type, changed);
 	}
 
 	for (i = 0; i < DATAMAX; i++) {
diff --git a/source/blender/blenkernel/intern/editderivedmesh.c b/source/blender/blenkernel/intern/editderivedmesh.c
index 62d9009a131..082edb01efd 100644
--- a/source/blender/blenkernel/intern/editderivedmesh.c
+++ b/source/blender/blenkernel/intern/editderivedmesh.c
@@ -169,12 +169,25 @@ static void emDM_calcNormals(DerivedMesh *dm)
 	dm->dirty &= ~DM_DIRTY_NORMALS;
 }
 
+static void emDM_calcLoopNormalsSpaceArray(
+        DerivedMesh *dm, const bool use_split_normals, const float split_angle, MLoopNorSpaceArray *r_lnors_spacearr);
+
 static void emDM_calcLoopNormals(DerivedMesh *dm, const bool use_split_normals, const float split_angle)
 {
+	emDM_calcLoopNormalsSpaceArray(dm, use_split_normals, split_angle, NULL);
+}
+
+/* #define DEBUG_CLNORS */
+
+static void emDM_calcLoopNormalsSpaceArray(
+        DerivedMesh *dm, const bool use_split_normals, const float split_angle, MLoopNorSpaceArray *r_lnors_spacearr)
+{
 	EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
 	BMesh *bm = bmdm->em->bm;
 	const float (*vertexCos)[3], (*vertexNos)[3], (*polyNos)[3];
 	float (*loopNos)[3];
+	short (*clnors_data)[2];
+	int cd_loop_clnors_offset;
 
 	/* calculate loop normals from poly and vertex normals */
 	emDM_ensureVertNormals(bmdm);
@@ -191,7 +204,37 @@ static void emDM_calcLoopNormals(DerivedMesh *dm, const bool use_split_normals,
 		loopNos = dm->getLoopDataArray(dm, CD_NORMAL);
 	}
 
-	BM_loops_calc_normal_vcos(bm, vertexCos, vertexNos, polyNos, use_split_normals, split_angle, loopNos);
+	/* We can have both, give priority to dm's data, and fallback to bm's ones. */
+	clnors_data = dm->getLoopDataArray(dm, CD_CUSTOMLOOPNORMAL);
+	cd_loop_clnors_offset = clnors_data ? -1 : CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
+
+	BM_loops_calc_normal_vcos(bm, vertexCos, vertexNos, polyNos, use_split_normals, split_angle, loopNos,
+	                          r_lnors_spacearr, clnors_data, cd_loop_clnors_offset);
+#ifdef DEBUG_CLNORS
+	if (r_lnors_spacearr) {
+		int i;
+		for (i = 0; i < numLoops; i++) {
+			if (r_lnors_spacearr->lspacearr[i]->ref_alpha != 0.0f) {
+				LinkNode *loops = r_lnors_spacearr->lspacearr[i]->loops;
+				printf("Loop %d uses lnor space %p:\n", i, r_lnors_spacearr->lspacearr[i]);
+				print_v3("\tfinal lnor:", loopNos[i]);
+				print_v3("\tauto lnor:", r_lnors_spacearr->lspacearr[i]->vec_lnor);
+				print_v3("\tref_vec:", r_lnors_spacearr->lspacearr[i]->vec_ref);
+				printf("\talpha: %f\n\tbeta: %f\n\tloops: %p\n", r_lnors_spacearr->lspacearr[i]->ref_alpha,
+				       r_lnors_spacearr->lspacearr[i]->ref_beta, r_lnors_spacearr->lspacearr[i]->loops);
+				printf("\t\t(shared with loops");
+				while (loops) {
+					printf(" %d", GET_INT_FROM_POINTER(loops->link));
+					loops = loops->next;
+				}
+				printf(")\n");
+			}
+			else {
+				printf("Loop %d has no lnor space\n", i);
+			}
+		}
+	}
+#endif
 }
 
 static void emDM_recalcTessellation(DerivedMesh *UNUSED(dm))
@@ -1764,6 +1807,7 @@ DerivedMesh *getEditDerivedBMesh(BMEditMesh *em,
 
 	bmdm->dm.calcNormals = emDM_calcNormals;
 	bmdm->dm.calcLoopNormals = emDM_calcLoopNormals;
+	bmdm->dm.calcLoopNormalsSpaceArray = emDM_calcLoopNormalsSpaceArray;
 	bmdm->dm.recalcTessellation = emDM_recalcTessellation;
 
 	bmdm->dm.foreachMappedVert = emDM_foreachMappedVert;
diff --git a/source/blender/blenkernel/intern/group.c b/source/blender/blenkernel/intern/group.c
index 1f9cf2e11b7..ae3ab833a87 100644
--- a/source/blender/blenkernel/intern/group.c
+++ b/source/blender/blenkernel/intern/group.c
@@ -219,6 +219,43 @@ static int group_object_unlink_internal(Group *group, Object *ob)
 	return removed;
 }
 
+static bool group_object_cyclic_check_internal(Object *object, Group *group)
+{
+	if (object->dup_group) {
+		Group *dup_group = object->dup_group;
+		if ((dup_group->id.flag & LIB_DOIT) == 0) {
+			/* Cycle already exists in groups, let's prevent further crappyness */
+			return true;
+		}
+		/* flag the object to identify cyclic dependencies in further dupli groups */
+		dup_group->id.flag &= ~LIB_DOIT;
+
+		if (dup_group == group)
+			return true;
+		else {
+			GroupObject *gob;
+			for (gob = dup_group->gobject.first; gob; gob = gob->next) {
+				if (group_object_cyclic_check_internal(gob->ob, group)) {
+					return true;
+				}
+			}
+		}
+
+		/* un-flag the object, it's allowed to have the same group multiple times in parallel */
+		dup_group->id.flag |= LIB_DOIT;
+	}
+
+	return false;
+}
+
+bool BKE_group_object_cyclic_check(Main *bmain, Object *object, Group *group)
+{
+	/* first flag all groups */
+	BKE_main_id_tag_listbase(&bmain->group, true);
+
+	return group_object_cyclic_check_internal(object, group);
+}
+
 bool BKE_group_object_unlink(Group *group, Object *object, Scene *scene, Base *base)
 {
 	if (group_object_unlink_internal(group, object)) {
diff --git a/source/blender/blenkernel/intern/image.c b/source/blender/blenkernel/intern/image.c
index b405e0a6240..131a19b8108 100644
--- a/source/blender/blenkernel/intern/image.c
+++ b/source/blender/blenkernel/intern/image.c
@@ -803,7 +803,9 @@ Image *BKE_image_add_generated(Main *bmain, unsigned int width, unsigned int hei
 	return ima;
 }
 
-/* creates an image image owns the imbuf passed */
+/* Create an image image from ibuf. The refcount of ibuf is increased,
+ * caller should take care to drop its reference by calling
+ * IMB_freeImBuf if needed. */
 Image *BKE_image_add_from_imbuf(ImBuf *ibuf)
 {
 	/* on save, type is changed to FILE in editsima.c */
@@ -2107,6 +2109,14 @@ void BKE_image_path_from_imtype(
 	image_path_makepicstring(string, base, relbase, frame, imtype, NULL, use_ext, use_frames);
 }
 
+struct anim *openanim_noload(const char *name, int flags, int streamindex, char colorspace[IMA_MAX_SPACE])
+{
+	struct anim *anim;
+
+	anim = IMB_open_anim(name, flags, streamindex, colorspace);
+	return anim;
+}
+
 /* used by sequencer too */
 struct anim *openanim(const char *name, int flags, int streamindex, char colorspace[IMA_MAX_SPACE])
 {
@@ -2172,11 +2182,6 @@ Image *BKE_image_verify_viewer(int type, const char *name)
 	return ima;
 }
 
-void BKE_image_assign_ibuf(Image *ima, ImBuf *ibuf)
-{
-	image_assign_ibuf(ima, ibuf, IMA_NO_INDEX, 0);
-}
-
 void BKE_image_walk_all_users(const Main *mainp, void *customdata,
                               void callback(Image *ima, ImageUser *iuser, void *customdata))
 {
diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c
index 4cb792da179..a5691d6fef3 100644
--- a/source/blender/blenkernel/intern/library.c
+++ b/source/blender/blenkernel/intern/library.c
@@ -1571,7 +1571,7 @@ void test_idbutton(char *name)
 	ID *idtest;
 	
 
-	lb = which_libbase(G.main, GS(name) );
+	lb = which_libbase(G.main, GS(name));
 	if (lb == NULL) return;
 	
 	/* search for id */
@@ -1590,7 +1590,7 @@ void rename_id(ID *id, const char *name)
 	ListBase *lb;
 
 	BLI_strncpy(id->name + 2, name, sizeof(id->name) - 2);
-	lb = which_libbase(G.main, GS(id->name) );
+	lb = which_libbase(G.main, GS(id->name));
 	
 	new_id(lb, id, name);
 }
diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c
index 8ad20df18db..7757babaca2 100644
--- a/source/blender/blenkernel/intern/mesh.c
+++ b/source/blender/blenkernel/intern/mesh.c
@@ -414,6 +414,16 @@ void BKE_mesh_update_customdata_pointers(Mesh *me, const bool do_ensure_tess_cd)
 	me->mloopuv = CustomData_get_layer(&me->ldata, CD_MLOOPUV);
 }
 
+bool BKE_mesh_has_custom_loop_normals(Mesh *me)
+{
+	if (me->edit_btmesh) {
+		return CustomData_has_layer(&me->edit_btmesh->bm->ldata, CD_CUSTOMLOOPNORMAL);
+	}
+	else {
+		return CustomData_has_layer(&me->ldata, CD_CUSTOMLOOPNORMAL);
+	}
+}
+
 /* Note: unlinking is called when me->id.us is 0, question remains how
  * much unlinking of Library data in Mesh should be done... probably
  * we need a more generic method, like the expand() functions in
diff --git a/source/blender/blenkernel/intern/mesh_evaluate.c b/source/blender/blenkernel/intern/mesh_evaluate.c
index af9ac911921..40a09eba658 100644
--- a/source/blender/blenkernel/intern/mesh_evaluate.c
+++ b/source/blender/blenkernel/intern/mesh_evaluate.c
@@ -39,6 +39,7 @@
 
 #include "BLI_utildefines.h"
 #include "BLI_memarena.h"
+#include "BLI_mempool.h"
 #include "BLI_math.h"
 #include "BLI_edgehash.h"
 #include "BLI_bitmap.h"
@@ -46,6 +47,8 @@
 #include "BLI_linklist.h"
 #include "BLI_linklist_stack.h"
 #include "BLI_alloca.h"
+#include "BLI_stack.h"
+#include "BLI_task.h"
 
 #include "BKE_customdata.h"
 #include "BKE_mesh.h"
@@ -58,8 +61,8 @@
 
 // #define DEBUG_TIME
 
+#include "PIL_time.h"
 #ifdef DEBUG_TIME
-#  include "PIL_time.h"
 #  include "PIL_time_utildefines.h"
 #endif
 
@@ -316,37 +319,783 @@ void BKE_mesh_calc_normals_tessface(MVert *mverts, int numVerts, MFace *mfaces,
 		MEM_freeN(fnors);
 }
 
+void BKE_lnor_spacearr_init(MLoopNorSpaceArray *lnors_spacearr, const int numLoops)
+{
+	if (!(lnors_spacearr->lspacearr && lnors_spacearr->loops_pool)) {
+		MemArena *mem;
+
+		if (!lnors_spacearr->mem) {
+			lnors_spacearr->mem = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
+		}
+		mem = lnors_spacearr->mem;
+		lnors_spacearr->lspacearr = BLI_memarena_calloc(mem, sizeof(MLoopNorSpace *) * (size_t)numLoops);
+		lnors_spacearr->loops_pool = BLI_memarena_alloc(mem, sizeof(LinkNode) * (size_t)numLoops);
+	}
+}
+
+void BKE_lnor_spacearr_clear(MLoopNorSpaceArray *lnors_spacearr)
+{
+	BLI_memarena_clear(lnors_spacearr->mem);
+	lnors_spacearr->lspacearr = NULL;
+	lnors_spacearr->loops_pool = NULL;
+}
+
+void BKE_lnor_spacearr_free(MLoopNorSpaceArray *lnors_spacearr)
+{
+	BLI_memarena_free(lnors_spacearr->mem);
+	lnors_spacearr->lspacearr = NULL;
+	lnors_spacearr->loops_pool = NULL;
+	lnors_spacearr->mem = NULL;
+}
+
+MLoopNorSpace *BKE_lnor_space_create(MLoopNorSpaceArray *lnors_spacearr)
+{
+	return BLI_memarena_calloc(lnors_spacearr->mem, sizeof(MLoopNorSpace));
+}
+
+/* This threshold is a bit touchy (usual float precision issue), this value seems OK. */
+#define LNOR_SPACE_TRIGO_THRESHOLD (1.0f - 1e-6f)
+
+/* Should only be called once.
+ * Beware, this modifies ref_vec and other_vec in place!
+ * In case no valid space can be generated, ref_alpha and ref_beta are set to zero (which means 'use auto lnors').
+ */
+void BKE_lnor_space_define(MLoopNorSpace *lnor_space, const float lnor[3],
+                           float vec_ref[3], float vec_other[3], BLI_Stack *edge_vectors)
+{
+	const float pi2 = (float)M_PI * 2.0f;
+	float tvec[3], dtp;
+	const float dtp_ref = dot_v3v3(vec_ref, lnor);
+	const float dtp_other = dot_v3v3(vec_other, lnor);
+
+	if (UNLIKELY(fabsf(dtp_ref) >= LNOR_SPACE_TRIGO_THRESHOLD || fabsf(dtp_other) >= LNOR_SPACE_TRIGO_THRESHOLD)) {
+		/* If vec_ref or vec_other are too much aligned with lnor, we can't build lnor space,
+		 * tag it as invalid and abort. */
+		lnor_space->ref_alpha = lnor_space->ref_beta = 0.0f;
+		return;
+	}
+
+	copy_v3_v3(lnor_space->vec_lnor, lnor);
+
+	/* Compute ref alpha, average angle of all available edge vectors to lnor. */
+	if (edge_vectors) {
+		float alpha = 0.0f;
+		int nbr = 0;
+		while (!BLI_stack_is_empty(edge_vectors)) {
+			const float *vec = BLI_stack_peek(edge_vectors);
+			alpha += saacosf(dot_v3v3(vec, lnor));
+			BLI_stack_discard(edge_vectors);
+			nbr++;
+		}
+		BLI_assert(nbr > 2);  /* This piece of code shall only be called for more than one loop... */
+		lnor_space->ref_alpha = alpha / (float)nbr;
+	}
+	else {
+		lnor_space->ref_alpha = (saacosf(dot_v3v3(vec_ref, lnor)) + saacosf(dot_v3v3(vec_other, lnor))) / 2.0f;
+	}
+
+	/* Project vec_ref on lnor's ortho plane. */
+	mul_v3_v3fl(tvec, lnor, dtp_ref);
+	sub_v3_v3(vec_ref, tvec);
+	normalize_v3_v3(lnor_space->vec_ref, vec_ref);
+
+	cross_v3_v3v3(tvec, lnor, lnor_space->vec_ref);
+	normalize_v3_v3(lnor_space->vec_ortho, tvec);
+
+	/* Project vec_other on lnor's ortho plane. */
+	mul_v3_v3fl(tvec, lnor, dtp_other);
+	sub_v3_v3(vec_other, tvec);
+	normalize_v3(vec_other);
+
+	/* Beta is angle between ref_vec and other_vec, around lnor. */
+	dtp = dot_v3v3(lnor_space->vec_ref, vec_other);
+	if (LIKELY(dtp < LNOR_SPACE_TRIGO_THRESHOLD)) {
+		const float beta = saacos(dtp);
+		lnor_space->ref_beta = (dot_v3v3(lnor_space->vec_ortho, vec_other) < 0.0f) ? pi2 - beta : beta;
+	}
+	else {
+		lnor_space->ref_beta = pi2;
+	}
+}
+
+void BKE_lnor_space_add_loop(MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpace *lnor_space, const int ml_index,
+                             const bool do_add_loop)
+{
+	lnors_spacearr->lspacearr[ml_index] = lnor_space;
+	if (do_add_loop) {
+		BLI_linklist_prepend_nlink(&lnor_space->loops, SET_INT_IN_POINTER(ml_index), &lnors_spacearr->loops_pool[ml_index]);
+	}
+}
+
+MINLINE float unit_short_to_float(const short val)
+{
+	return (float)val / (float)SHRT_MAX;
+}
+
+MINLINE short unit_float_to_short(const float val)
+{
+	/* Rounding... */
+	return (short)floorf(val * (float)SHRT_MAX + 0.5f);
+}
+
+void BKE_lnor_space_custom_data_to_normal(MLoopNorSpace *lnor_space, const short clnor_data[2], float r_custom_lnor[3])
+{
+	/* NOP custom normal data or invalid lnor space, return. */
+	if (clnor_data[0] == 0 || lnor_space->ref_alpha == 0.0f || lnor_space->ref_beta == 0.0f) {
+		copy_v3_v3(r_custom_lnor, lnor_space->vec_lnor);
+		return;
+	}
+
+	{
+		/* TODO Check whether using sincosf() gives any noticeable benefit
+		 *      (could not even get it working under linux though)! */
+		const float pi2 = (float)(M_PI * 2.0);
+		const float alphafac = unit_short_to_float(clnor_data[0]);
+		const float alpha = (alphafac > 0.0f ? lnor_space->ref_alpha : pi2 - lnor_space->ref_alpha) * alphafac;
+		const float betafac = unit_short_to_float(clnor_data[1]);
+
+		mul_v3_v3fl(r_custom_lnor, lnor_space->vec_lnor, cosf(alpha));
+
+		if (betafac == 0.0f) {
+			madd_v3_v3fl(r_custom_lnor, lnor_space->vec_ref, sinf(alpha));
+		}
+		else {
+			const float sinalpha = sinf(alpha);
+			const float beta = (betafac > 0.0f ? lnor_space->ref_beta : pi2 - lnor_space->ref_beta) * betafac;
+			madd_v3_v3fl(r_custom_lnor, lnor_space->vec_ref, sinalpha * cosf(beta));
+			madd_v3_v3fl(r_custom_lnor, lnor_space->vec_ortho, sinalpha * sinf(beta));
+		}
+	}
+}
+
+void BKE_lnor_space_custom_normal_to_data(MLoopNorSpace *lnor_space, const float custom_lnor[3], short r_clnor_data[2])
+{
+	/* We use null vector as NOP custom normal (can be simpler than giving autocomputed lnor...). */
+	if (is_zero_v3(custom_lnor) || compare_v3v3(lnor_space->vec_lnor, custom_lnor, 1e-4f)) {
+		r_clnor_data[0] = r_clnor_data[1] = 0;
+		return;
+	}
+
+	{
+		const float pi2 = (float)(M_PI * 2.0);
+		const float cos_alpha = dot_v3v3(lnor_space->vec_lnor, custom_lnor);
+		float vec[3], cos_beta;
+		float alpha;
+
+		alpha = saacosf(cos_alpha);
+		if (alpha > lnor_space->ref_alpha) {
+			/* Note we could stick to [0, pi] range here, but makes decoding more complex, not worth it. */
+			r_clnor_data[0] = unit_float_to_short(-(pi2 - alpha) / (pi2 - lnor_space->ref_alpha));
+		}
+		else {
+			r_clnor_data[0] = unit_float_to_short(alpha / lnor_space->ref_alpha);
+		}
+
+		/* Project custom lnor on (vec_ref, vec_ortho) plane. */
+		mul_v3_v3fl(vec, lnor_space->vec_lnor, -cos_alpha);
+		add_v3_v3(vec, custom_lnor);
+		normalize_v3(vec);
+
+		cos_beta = dot_v3v3(lnor_space->vec_ref, vec);
+
+		if (cos_beta < LNOR_SPACE_TRIGO_THRESHOLD) {
+			float beta = saacosf(cos_beta);
+			if (dot_v3v3(lnor_space->vec_ortho, vec) < 0.0f) {
+				beta = pi2 - beta;
+			}
+
+			if (beta > lnor_space->ref_beta) {
+				r_clnor_data[1] = unit_float_to_short(-(pi2 - beta) / (pi2 - lnor_space->ref_beta));
+			}
+			else {
+				r_clnor_data[1] = unit_float_to_short(beta / lnor_space->ref_beta);
+			}
+		}
+		else {
+			r_clnor_data[1] = 0;
+		}
+	}
+}
+
+#define LOOP_SPLIT_TASK_BLOCK_SIZE 1024
+
+typedef struct LoopSplitTaskData {
+	/* Specific to each instance (each task). */
+	MLoopNorSpace *lnor_space;  /* We have to create those outside of tasks, since afaik memarena is not threadsafe. */
+	float (*lnor)[3];
+	const MLoop *ml_curr;
+	const MLoop *ml_prev;
+	int ml_curr_index;
+	int ml_prev_index;
+	const int *e2l_prev;  /* Also used a flag to switch between single or fan process! */
+	int mp_index;
+
+	/* This one is special, it's owned and managed by worker tasks, avoid to have to create it for each fan! */
+	BLI_Stack *edge_vectors;
+
+	char pad_c;
+} LoopSplitTaskData;
+
+typedef struct LoopSplitTaskDataCommon {
+	/* Read/write.
+	 * Note we do not need to protect it, though, since two different tasks will *always* affect different
+	 * elements in the arrays. */
+	MLoopNorSpaceArray *lnors_spacearr;
+	BLI_bitmap *sharp_verts;
+	float (*loopnors)[3];
+	short (*clnors_data)[2];
+
+	/* Read-only. */
+	const MVert *mverts;
+	const MEdge *medges;
+	const MLoop *mloops;
+	const MPoly *mpolys;
+	const int (*edge_to_loops)[2];
+	const int *loop_to_poly;
+	const float (*polynors)[3];
+
+	int numPolys;
+
+	/* ***** Workers communication. ***** */
+	ThreadQueue *task_queue;
+
+} LoopSplitTaskDataCommon;
+
+#define INDEX_UNSET INT_MIN
+#define INDEX_INVALID -1
+/* See comment about edge_to_loops below. */
+#define IS_EDGE_SHARP(_e2l) (ELEM((_e2l)[1], INDEX_UNSET, INDEX_INVALID))
+
+static void split_loop_nor_single_do(LoopSplitTaskDataCommon *common_data, LoopSplitTaskData *data)
+{
+	MLoopNorSpaceArray *lnors_spacearr = common_data->lnors_spacearr;
+	short (*clnors_data)[2] = common_data->clnors_data;
+
+	const MVert *mverts = common_data->mverts;
+	const MEdge *medges = common_data->medges;
+	const float (*polynors)[3] = common_data->polynors;
+
+	MLoopNorSpace *lnor_space = data->lnor_space;
+	float (*lnor)[3] = data->lnor;
+	const MLoop *ml_curr = data->ml_curr;
+	const MLoop *ml_prev = data->ml_prev;
+	const int ml_curr_index = data->ml_curr_index;
+#if 0  /* Not needed for 'single' loop. */
+	const int ml_prev_index = data->ml_prev_index;
+	const int *e2l_prev = data->e2l_prev;
+#endif
+	const int mp_index = data->mp_index;
+
+	/* Simple case (both edges around that vertex are sharp in current polygon),
+	 * this loop just takes its poly normal.
+	 */
+	copy_v3_v3(*lnor, polynors[mp_index]);
+
+	/* printf("BASIC: handling loop %d / edge %d / vert %d\n", ml_curr_index, ml_curr->e, ml_curr->v); */
+
+	/* If needed, generate this (simple!) lnor space. */
+	if (lnors_spacearr) {
+		float vec_curr[3], vec_prev[3];
+
+		const unsigned int mv_pivot_index = ml_curr->v;  /* The vertex we are "fanning" around! */
+		const MVert *mv_pivot = &mverts[mv_pivot_index];
+		const MEdge *me_curr = &medges[ml_curr->e];
+		const MVert *mv_2 = (me_curr->v1 == mv_pivot_index) ? &mverts[me_curr->v2] : &mverts[me_curr->v1];
+		const MEdge *me_prev = &medges[ml_prev->e];
+		const MVert *mv_3 = (me_prev->v1 == mv_pivot_index) ? &mverts[me_prev->v2] : &mverts[me_prev->v1];
+
+		sub_v3_v3v3(vec_curr, mv_2->co, mv_pivot->co);
+		normalize_v3(vec_curr);
+		sub_v3_v3v3(vec_prev, mv_3->co, mv_pivot->co);
+		normalize_v3(vec_prev);
+
+		BKE_lnor_space_define(lnor_space, *lnor, vec_curr, vec_prev, NULL);
+		/* We know there is only one loop in this space, no need to create a linklist in this case... */
+		BKE_lnor_space_add_loop(lnors_spacearr, lnor_space, ml_curr_index, false);
+
+		if (clnors_data) {
+			BKE_lnor_space_custom_data_to_normal(lnor_space, clnors_data[ml_curr_index], *lnor);
+		}
+	}
+}
+
+static void split_loop_nor_fan_do(LoopSplitTaskDataCommon *common_data, LoopSplitTaskData *data)
+{
+	MLoopNorSpaceArray *lnors_spacearr = common_data->lnors_spacearr;
+	float (*loopnors)[3] = common_data->loopnors;
+	short (*clnors_data)[2] = common_data->clnors_data;
+
+	const MVert *mverts = common_data->mverts;
+	const MEdge *medges = common_data->medges;
+	const MLoop *mloops = common_data->mloops;
+	const MPoly *mpolys = common_data->mpolys;
+	const int (*edge_to_loops)[2] = common_data->edge_to_loops;
+	const int *loop_to_poly = common_data->loop_to_poly;
+	const float (*polynors)[3] = common_data->polynors;
+
+	MLoopNorSpace *lnor_space = data->lnor_space;
+#if 0  /* Not needed for 'fan' loops. */
+	float (*lnor)[3] = data->lnor;
+#endif
+	const MLoop *ml_curr = data->ml_curr;
+	const MLoop *ml_prev = data->ml_prev;
+	const int ml_curr_index = data->ml_curr_index;
+	const int ml_prev_index = data->ml_prev_index;
+	const int mp_index = data->mp_index;
+	const int *e2l_prev = data->e2l_prev;
+
+	BLI_Stack *edge_vectors = data->edge_vectors;
+
+	/* Gah... We have to fan around current vertex, until we find the other non-smooth edge,
+	 * and accumulate face normals into the vertex!
+	 * Note in case this vertex has only one sharp edges, this is a waste because the normal is the same as
+	 * the vertex normal, but I do not see any easy way to detect that (would need to count number
+	 * of sharp edges per vertex, I doubt the additional memory usage would be worth it, especially as
+	 * it should not be a common case in real-life meshes anyway).
+	 */
+	const unsigned int mv_pivot_index = ml_curr->v;  /* The vertex we are "fanning" around! */
+	const MVert *mv_pivot = &mverts[mv_pivot_index];
+	const MEdge *me_org = &medges[ml_curr->e];  /* ml_curr would be mlfan_prev if we needed that one */
+	const int *e2lfan_curr;
+	float vec_curr[3], vec_prev[3], vec_org[3];
+	const MLoop *mlfan_curr, *mlfan_next;
+	const MPoly *mpfan_next;
+	float lnor[3] = {0.0f, 0.0f, 0.0f};
+	/* mlfan_vert_index: the loop of our current edge might not be the loop of our current vertex! */
+	int mlfan_curr_index, mlfan_vert_index, mpfan_curr_index;
+
+	/* We validate clnors data on the fly - cheapest way to do! */
+	int clnors_avg[2] = {0, 0};
+	short (*clnor_ref)[2] = NULL;
+	int clnors_nbr = 0;
+	bool clnors_invalid = false;
+
+	/* Temp loop normal stack. */
+	BLI_SMALLSTACK_DECLARE(normal, float *);
+	/* Temp clnors stack. */
+	BLI_SMALLSTACK_DECLARE(clnors, short *);
+
+	e2lfan_curr = e2l_prev;
+	mlfan_curr = ml_prev;
+	mlfan_curr_index = ml_prev_index;
+	mlfan_vert_index = ml_curr_index;
+	mpfan_curr_index = mp_index;
+
+	BLI_assert(mlfan_curr_index >= 0);
+	BLI_assert(mlfan_vert_index >= 0);
+	BLI_assert(mpfan_curr_index >= 0);
+
+	/* Only need to compute previous edge's vector once, then we can just reuse old current one! */
+	{
+		const MVert *mv_2 = (me_org->v1 == mv_pivot_index) ? &mverts[me_org->v2] : &mverts[me_org->v1];
+
+		sub_v3_v3v3(vec_org, mv_2->co, mv_pivot->co);
+		normalize_v3(vec_org);
+		copy_v3_v3(vec_prev, vec_org);
+
+		if (lnors_spacearr) {
+			BLI_stack_push(edge_vectors, vec_org);
+		}
+	}
+
+	/* printf("FAN: vert %d, start edge %d\n", mv_pivot_index, ml_curr->e); */
+
+	while (true) {
+		const MEdge *me_curr = &medges[mlfan_curr->e];
+		/* Compute edge vectors.
+		 * NOTE: We could pre-compute those into an array, in the first iteration, instead of computing them
+		 *       twice (or more) here. However, time gained is not worth memory and time lost,
+		 *       given the fact that this code should not be called that much in real-life meshes...
+		 */
+		{
+			const MVert *mv_2 = (me_curr->v1 == mv_pivot_index) ? &mverts[me_curr->v2] : &mverts[me_curr->v1];
+
+			sub_v3_v3v3(vec_curr, mv_2->co, mv_pivot->co);
+			normalize_v3(vec_curr);
+		}
+
+		/* printf("\thandling edge %d / loop %d\n", mlfan_curr->e, mlfan_curr_index); */
+
+		{
+			/* Code similar to accumulate_vertex_normals_poly. */
+			/* Calculate angle between the two poly edges incident on this vertex. */
+			const float fac = saacos(dot_v3v3(vec_curr, vec_prev));
+			/* Accumulate */
+			madd_v3_v3fl(lnor, polynors[mpfan_curr_index], fac);
+
+			if (clnors_data) {
+				/* Accumulate all clnors, if they are not all equal we have to fix that! */
+				short (*clnor)[2] = &clnors_data[mlfan_vert_index];
+				if (clnors_nbr) {
+					clnors_invalid |= ((*clnor_ref)[0] != (*clnor)[0] || (*clnor_ref)[1] != (*clnor)[1]);
+				}
+				else {
+					clnor_ref = clnor;
+				}
+				clnors_avg[0] += (*clnor)[0];
+				clnors_avg[1] += (*clnor)[1];
+				clnors_nbr++;
+				/* We store here a pointer to all custom lnors processed. */
+				BLI_SMALLSTACK_PUSH(clnors, (short *)*clnor);
+			}
+		}
+
+		/* We store here a pointer to all loop-normals processed. */
+		BLI_SMALLSTACK_PUSH(normal, (float *)(loopnors[mlfan_vert_index]));
+
+		if (lnors_spacearr) {
+			/* Assign current lnor space to current 'vertex' loop. */
+			BKE_lnor_space_add_loop(lnors_spacearr, lnor_space, mlfan_vert_index, true);
+			if (me_curr != me_org) {
+				/* We store here all edges-normalized vectors processed. */
+				BLI_stack_push(edge_vectors, vec_curr);
+			}
+		}
+
+		if (IS_EDGE_SHARP(e2lfan_curr) || (me_curr == me_org)) {
+			/* Current edge is sharp and we have finished with this fan of faces around this vert,
+			 * or this vert is smooth, and we have completed a full turn around it.
+			 */
+			/* printf("FAN: Finished!\n"); */
+			break;
+		}
+
+		copy_v3_v3(vec_prev, vec_curr);
+
+		/* Warning! This is rather complex!
+		 * We have to find our next edge around the vertex (fan mode).
+		 * First we find the next loop, which is either previous or next to mlfan_curr_index, depending
+		 * whether both loops using current edge are in the same direction or not, and whether
+		 * mlfan_curr_index actually uses the vertex we are fanning around!
+		 * mlfan_curr_index is the index of mlfan_next here, and mlfan_next is not the real next one
+		 * (i.e. not the future mlfan_curr)...
+		 */
+		mlfan_curr_index = (e2lfan_curr[0] == mlfan_curr_index) ? e2lfan_curr[1] : e2lfan_curr[0];
+		mpfan_curr_index = loop_to_poly[mlfan_curr_index];
+
+		BLI_assert(mlfan_curr_index >= 0);
+		BLI_assert(mpfan_curr_index >= 0);
+
+		mlfan_next = &mloops[mlfan_curr_index];
+		mpfan_next = &mpolys[mpfan_curr_index];
+		if ((mlfan_curr->v == mlfan_next->v && mlfan_curr->v == mv_pivot_index) ||
+		    (mlfan_curr->v != mlfan_next->v && mlfan_curr->v != mv_pivot_index))
+		{
+			/* We need the previous loop, but current one is our vertex's loop. */
+			mlfan_vert_index = mlfan_curr_index;
+			if (--mlfan_curr_index < mpfan_next->loopstart) {
+				mlfan_curr_index = mpfan_next->loopstart + mpfan_next->totloop - 1;
+			}
+		}
+		else {
+			/* We need the next loop, which is also our vertex's loop. */
+			if (++mlfan_curr_index >= mpfan_next->loopstart + mpfan_next->totloop) {
+				mlfan_curr_index = mpfan_next->loopstart;
+			}
+			mlfan_vert_index = mlfan_curr_index;
+		}
+		mlfan_curr = &mloops[mlfan_curr_index];
+		/* And now we are back in sync, mlfan_curr_index is the index of mlfan_curr! Pff! */
+
+		e2lfan_curr = edge_to_loops[mlfan_curr->e];
+	}
+
+	{
+		float lnor_len = normalize_v3(lnor);
+
+		/* If we are generating lnor spacearr, we can now define the one for this fan,
+		 * and optionally compute final lnor from custom data too!
+		 */
+		if (lnors_spacearr) {
+			if (UNLIKELY(lnor_len == 0.0f)) {
+				/* Use vertex normal as fallback! */
+				copy_v3_v3(lnor, loopnors[mlfan_vert_index]);
+				lnor_len = 1.0f;
+			}
+
+			BKE_lnor_space_define(lnor_space, lnor, vec_org, vec_curr, edge_vectors);
+
+			if (clnors_data) {
+				if (clnors_invalid) {
+					short *clnor;
+
+					clnors_avg[0] /= clnors_nbr;
+					clnors_avg[1] /= clnors_nbr;
+					/* Fix/update all clnors of this fan with computed average value. */
+					printf("Invalid clnors in this fan!\n");
+					while ((clnor = BLI_SMALLSTACK_POP(clnors))) {
+						//print_v2("org clnor", clnor);
+						clnor[0] = (short)clnors_avg[0];
+						clnor[1] = (short)clnors_avg[1];
+					}
+					//print_v2("new clnors", clnors_avg);
+				}
+				/* Extra bonus: since smallstack is local to this func, no more need to empty it at all cost! */
+
+				BKE_lnor_space_custom_data_to_normal(lnor_space, *clnor_ref, lnor);
+			}
+		}
+
+		/* In case we get a zero normal here, just use vertex normal already set! */
+		if (LIKELY(lnor_len != 0.0f)) {
+			/* Copy back the final computed normal into all related loop-normals. */
+			float *nor;
+
+			while ((nor = BLI_SMALLSTACK_POP(normal))) {
+				copy_v3_v3(nor, lnor);
+			}
+		}
+		/* Extra bonus: since smallstack is local to this func, no more need to empty it at all cost! */
+	}
+}
+
+static void loop_split_worker_do(
+        LoopSplitTaskDataCommon *common_data, LoopSplitTaskData *data, BLI_Stack *edge_vectors)
+{
+	BLI_assert(data->ml_curr);
+	if (data->e2l_prev) {
+		BLI_assert((edge_vectors == NULL) || BLI_stack_is_empty(edge_vectors));
+		data->edge_vectors = edge_vectors;
+		split_loop_nor_fan_do(common_data, data);
+	}
+	else {
+		/* No need for edge_vectors for 'single' case! */
+		split_loop_nor_single_do(common_data, data);
+	}
+}
+
+static void loop_split_worker(TaskPool *UNUSED(pool), void *taskdata, int UNUSED(threadid))
+{
+	LoopSplitTaskDataCommon *common_data = taskdata;
+	LoopSplitTaskData *data_buff;
+
+	/* Temp edge vectors stack, only used when computing lnor spacearr. */
+	BLI_Stack *edge_vectors = common_data->lnors_spacearr ? BLI_stack_new(sizeof(float[3]), __func__) : NULL;
+
+#ifdef DEBUG_TIME
+	TIMEIT_START(loop_split_worker);
+#endif
+
+	while ((data_buff = BLI_thread_queue_pop(common_data->task_queue))) {
+		LoopSplitTaskData *data = data_buff;
+		int i;
+
+		for (i = 0; i < LOOP_SPLIT_TASK_BLOCK_SIZE; i++, data++) {
+			/* A NULL ml_curr is used to tag ended data! */
+			if (data->ml_curr == NULL) {
+				break;
+			}
+			loop_split_worker_do(common_data, data, edge_vectors);
+		}
+
+		MEM_freeN(data_buff);
+	}
+
+	if (edge_vectors) {
+		BLI_stack_free(edge_vectors);
+	}
+
+#ifdef DEBUG_TIME
+	TIMEIT_END(loop_split_worker);
+#endif
+}
+
+/* Note we use data_buff to detect whether we are in threaded context or not, in later case it is NULL. */
+static void loop_split_generator_do(LoopSplitTaskDataCommon *common_data, const bool threaded)
+{
+	MLoopNorSpaceArray *lnors_spacearr = common_data->lnors_spacearr;
+	BLI_bitmap *sharp_verts = common_data->sharp_verts;
+	float (*loopnors)[3] = common_data->loopnors;
+
+	const MLoop *mloops = common_data->mloops;
+	const MPoly *mpolys = common_data->mpolys;
+	const int (*edge_to_loops)[2] = common_data->edge_to_loops;
+	const int numPolys = common_data->numPolys;
+
+	const MPoly *mp;
+	int mp_index;
+
+	LoopSplitTaskData *data, *data_buff = NULL, data_mem;
+	int data_idx = 0;
+
+	/* Temp edge vectors stack, only used when computing lnor spacearr (and we are not multi-threading). */
+	BLI_Stack *edge_vectors = (lnors_spacearr && !data_buff) ? BLI_stack_new(sizeof(float[3]), __func__) : NULL;
+
+#ifdef DEBUG_TIME
+	TIMEIT_START(loop_split_generator);
+#endif
+
+	if (!threaded) {
+		memset(&data_mem, 0, sizeof(data_mem));
+		data = &data_mem;
+	}
+
+	/* We now know edges that can be smoothed (with their vector, and their two loops), and edges that will be hard!
+	 * Now, time to generate the normals.
+	 */
+	for (mp = mpolys, mp_index = 0; mp_index < numPolys; mp++, mp_index++) {
+		const MLoop *ml_curr, *ml_prev;
+		float (*lnors)[3];
+		const int ml_last_index = (mp->loopstart + mp->totloop) - 1;
+		int ml_curr_index = mp->loopstart;
+		int ml_prev_index = ml_last_index;
+
+		ml_curr = &mloops[ml_curr_index];
+		ml_prev = &mloops[ml_prev_index];
+		lnors = &loopnors[ml_curr_index];
+
+		for (; ml_curr_index <= ml_last_index; ml_curr++, ml_curr_index++, lnors++) {
+			const int *e2l_curr = edge_to_loops[ml_curr->e];
+			const int *e2l_prev = edge_to_loops[ml_prev->e];
+
+			if (!IS_EDGE_SHARP(e2l_curr) && (!lnors_spacearr || BLI_BITMAP_TEST_BOOL(sharp_verts, ml_curr->v))) {
+				/* A smooth edge, and we are not generating lnor_spacearr, or the related vertex is sharp.
+				 * We skip it because it is either:
+				 * - in the middle of a 'smooth fan' already computed (or that will be as soon as we hit
+				 *   one of its ends, i.e. one of its two sharp edges), or...
+				 * - the related vertex is a "full smooth" one, in which case pre-populated normals from vertex
+				 *   are just fine (or it has already be handled in a previous loop in case of needed lnors spacearr)!
+				 */
+				/* printf("Skipping loop %d / edge %d / vert %d(%d)\n", ml_curr_index, ml_curr->e, ml_curr->v, sharp_verts[ml_curr->v]); */
+			}
+			else {
+				if (threaded) {
+					if (data_idx == 0) {
+						data_buff = MEM_callocN(sizeof(*data_buff) * LOOP_SPLIT_TASK_BLOCK_SIZE, __func__);
+					}
+					data = &data_buff[data_idx];
+				}
+
+				if (IS_EDGE_SHARP(e2l_curr) && IS_EDGE_SHARP(e2l_prev)) {
+					data->lnor = lnors;
+					data->ml_curr = ml_curr;
+					data->ml_prev = ml_prev;
+					data->ml_curr_index = ml_curr_index;
+#if 0  /* Not needed for 'single' loop. */
+					data->ml_prev_index = ml_prev_index;
+					data->e2l_prev = NULL;  /* Tag as 'single' task. */
+#endif
+					data->mp_index = mp_index;
+					if (lnors_spacearr) {
+						data->lnor_space = BKE_lnor_space_create(lnors_spacearr);
+					}
+				}
+				/* We *do not need* to check/tag loops as already computed!
+				 * Due to the fact a loop only links to one of its two edges, a same fan *will never be walked
+				 * more than once!*
+				 * Since we consider edges having neighbor polys with inverted (flipped) normals as sharp, we are sure
+				 * that no fan will be skipped, even only considering the case (sharp curr_edge, smooth prev_edge),
+				 * and not the alternative (smooth curr_edge, sharp prev_edge).
+				 * All this due/thanks to link between normals and loop ordering (i.e. winding).
+				 */
+				else {
+#if 0  /* Not needed for 'fan' loops. */
+					data->lnor = lnors;
+#endif
+					data->ml_curr = ml_curr;
+					data->ml_prev = ml_prev;
+					data->ml_curr_index = ml_curr_index;
+					data->ml_prev_index = ml_prev_index;
+					data->e2l_prev = e2l_prev;  /* Also tag as 'fan' task. */
+					data->mp_index = mp_index;
+					if (lnors_spacearr) {
+						data->lnor_space = BKE_lnor_space_create(lnors_spacearr);
+						/* Tag related vertex as sharp, to avoid fanning around it again (in case it was a smooth one).
+						 * This *has* to be done outside of workers tasks! */
+						BLI_BITMAP_ENABLE(sharp_verts, ml_curr->v);
+					}
+				}
+
+				if (threaded) {
+					data_idx++;
+					if (data_idx == LOOP_SPLIT_TASK_BLOCK_SIZE) {
+						BLI_thread_queue_push(common_data->task_queue, data_buff);
+						data_idx = 0;
+					}
+				}
+				else {
+					loop_split_worker_do(common_data, data, edge_vectors);
+					memset(data, 0, sizeof(data_mem));
+				}
+			}
+
+			ml_prev = ml_curr;
+			ml_prev_index = ml_curr_index;
+		}
+	}
+
+	if (threaded) {
+		/* Last block of data... Since it is calloc'ed and we use first NULL item as stopper, everything is fine. */
+		if (LIKELY(data_idx)) {
+			BLI_thread_queue_push(common_data->task_queue, data_buff);
+		}
+
+		/* This will signal all other worker threads to wake up and finish! */
+		BLI_thread_queue_nowait(common_data->task_queue);
+	}
+
+	if (edge_vectors) {
+		BLI_stack_free(edge_vectors);
+	}
+
+#ifdef DEBUG_TIME
+	TIMEIT_END(loop_split_generator);
+#endif
+}
+
+static void loop_split_generator(TaskPool *UNUSED(pool), void *taskdata, int UNUSED(threadid))
+{
+	LoopSplitTaskDataCommon *common_data = taskdata;
+
+	loop_split_generator_do(common_data, true);
+}
+
 /**
  * Compute split normals, i.e. vertex normals associated with each poly (hence 'loop normals').
  * Useful to materialize sharp edges (or non-smooth faces) without actually modifying the geometry (splitting edges).
  */
 void BKE_mesh_normals_loop_split(
-        MVert *mverts, const int UNUSED(numVerts), MEdge *medges, const int numEdges,
+        MVert *mverts, const int numVerts, MEdge *medges, const int numEdges,
         MLoop *mloops, float (*r_loopnors)[3], const int numLoops,
-        MPoly *mpolys, float (*polynors)[3], const int numPolys,
-        const bool use_split_normals, float split_angle)
+        MPoly *mpolys, const float (*polynors)[3], const int numPolys,
+        const bool use_split_normals, float split_angle,
+        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2], int *r_loop_to_poly)
 {
+
+	/* For now this is not supported. If we do not use split normals, we do not generate anything fancy! */
+	BLI_assert(use_split_normals || !(r_lnors_spacearr));
+
 	if (!use_split_normals) {
-		/* In this case, we simply fill lnors with vnors, quite simple!
+		/* In this case, we simply fill lnors with vnors (or fnors for flat faces), quite simple!
 		 * Note this is done here to keep some logic and consistency in this quite complex code,
 		 * since we may want to use lnors even when mesh's 'autosmooth' is disabled (see e.g. mesh mapping code).
 		 * As usual, we could handle that on case-by-case basis, but simpler to keep it well confined here.
 		 */
-		int i;
+		int mp_index;
 
-		for (i = 0; i < numLoops; i++) {
-			normal_short_to_float_v3(r_loopnors[i], mverts[mloops[i].v].no);
+		for (mp_index = 0; mp_index < numPolys; mp_index++) {
+			MPoly *mp = &mpolys[mp_index];
+			int ml_index = mp->loopstart;
+			const int ml_index_end = ml_index + mp->totloop;
+			const bool is_poly_flat = ((mp->flag & ME_SMOOTH) == 0);
+
+			for (; ml_index < ml_index_end; ml_index++) {
+				if (r_loop_to_poly) {
+					r_loop_to_poly[ml_index] = mp_index;
+				}
+				if (is_poly_flat) {
+					copy_v3_v3(r_loopnors[ml_index], polynors[mp_index]);
+				}
+				else {
+					normal_short_to_float_v3(r_loopnors[ml_index], mverts[mloops[ml_index].v].no);
+				}
+			}
 		}
 		return;
 	}
 
 	{
 
-#define INDEX_UNSET INT_MIN
-#define INDEX_INVALID -1
-/* See comment about edge_to_loops below. */
-#define IS_EDGE_SHARP(_e2l) (ELEM((_e2l)[1], INDEX_UNSET, INDEX_INVALID))
-
 	/* Mapping edge -> loops.
 	 * If that edge is used by more than two loops (polys), it is always sharp (and tagged as such, see below).
 	 * We also use the second loop index as a kind of flag: smooth edge: > 0,
@@ -359,21 +1108,39 @@ void BKE_mesh_normals_loop_split(
 	int (*edge_to_loops)[2] = MEM_callocN(sizeof(int[2]) * (size_t)numEdges, __func__);
 
 	/* Simple mapping from a loop to its polygon index. */
-	int *loop_to_poly = MEM_mallocN(sizeof(int) * (size_t)numLoops, __func__);
+	int *loop_to_poly = r_loop_to_poly ? r_loop_to_poly : MEM_mallocN(sizeof(int) * (size_t)numLoops, __func__);
 
 	MPoly *mp;
-	int mp_index;
-	const bool check_angle = (split_angle < (float)M_PI);
+	int mp_index, me_index;
+	bool check_angle = (split_angle < (float)M_PI);
+	int i;
 
-	/* Temp normal stack. */
-	BLI_SMALLSTACK_DECLARE(normal, float *);
+	BLI_bitmap *sharp_verts = NULL;
+	MLoopNorSpaceArray _lnors_spacearr = {NULL};
+
+	LoopSplitTaskDataCommon common_data = {NULL};
 
 #ifdef DEBUG_TIME
 	TIMEIT_START(BKE_mesh_normals_loop_split);
 #endif
 
 	if (check_angle) {
-		split_angle = cosf(split_angle);
+		/* When using custom loop normals, disable the angle feature! */
+		if (clnors_data) {
+			check_angle = false;
+		}
+		else {
+			split_angle = cosf(split_angle);
+		}
+	}
+
+	if (!r_lnors_spacearr && clnors_data) {
+		/* We need to compute lnor spacearr if some custom lnor data are given to us! */
+		r_lnors_spacearr = &_lnors_spacearr;
+	}
+	if (r_lnors_spacearr) {
+		BKE_lnor_spacearr_init(r_lnors_spacearr, numLoops);
+		sharp_verts = BLI_BITMAP_NEW((size_t)numVerts, __func__);
 	}
 
 	/* This first loop check which edges are actually smooth, and compute edge vectors. */
@@ -427,189 +1194,271 @@ void BKE_mesh_normals_loop_split(
 		}
 	}
 
-	/* We now know edges that can be smoothed (with their vector, and their two loops), and edges that will be hard!
-	 * Now, time to generate the normals.
-	 */
-	for (mp = mpolys, mp_index = 0; mp_index < numPolys; mp++, mp_index++) {
-		MLoop *ml_curr, *ml_prev;
-		float (*lnors)[3];
-		const int ml_last_index = (mp->loopstart + mp->totloop) - 1;
-		int ml_curr_index = mp->loopstart;
-		int ml_prev_index = ml_last_index;
+	if (r_lnors_spacearr) {
+		/* Tag vertices that have at least one sharp edge as 'sharp' (used for the lnor spacearr computation).
+		 * XXX This third loop over edges is a bit disappointing, could not find any other way yet.
+		 *     Not really performance-critical anyway.
+		 */
+		for (me_index = 0; me_index < numEdges; me_index++) {
+			const int *e2l = edge_to_loops[me_index];
+			const MEdge *me = &medges[me_index];
+			if (IS_EDGE_SHARP(e2l)) {
+				BLI_BITMAP_ENABLE(sharp_verts, me->v1);
+				BLI_BITMAP_ENABLE(sharp_verts, me->v2);
+			}
+		}
+	}
 
-		ml_curr = &mloops[ml_curr_index];
-		ml_prev = &mloops[ml_prev_index];
-		lnors = &r_loopnors[ml_curr_index];
+	/* Init data common to all tasks. */
+	common_data.lnors_spacearr = r_lnors_spacearr;
+	common_data.loopnors = r_loopnors;
+	common_data.clnors_data = clnors_data;
 
-		for (; ml_curr_index <= ml_last_index; ml_curr++, ml_curr_index++, lnors++) {
-			const int *e2l_curr = edge_to_loops[ml_curr->e];
-			const int *e2l_prev = edge_to_loops[ml_prev->e];
+	common_data.mverts = mverts;
+	common_data.medges = medges;
+	common_data.mloops = mloops;
+	common_data.mpolys = mpolys;
+	common_data.sharp_verts = sharp_verts;
+	common_data.edge_to_loops = (const int(*)[2])edge_to_loops;
+	common_data.loop_to_poly = loop_to_poly;
+	common_data.polynors = polynors;
+	common_data.numPolys = numPolys;
 
-			if (!IS_EDGE_SHARP(e2l_curr)) {
-				/* A smooth edge.
-				 * We skip it because it is either:
-				 * - in the middle of a 'smooth fan' already computed (or that will be as soon as we hit
-				 *   one of its ends, i.e. one of its two sharp edges), or...
-				 * - the related vertex is a "full smooth" one, in which case pre-populated normals from vertex
-				 *   are just fine!
-				 */
-			}
-			else if (IS_EDGE_SHARP(e2l_prev)) {
-				/* Simple case (both edges around that vertex are sharp in current polygon),
-				 * this vertex just takes its poly normal.
-				 */
-				copy_v3_v3(*lnors, polynors[mp_index]);
-				/* No need to mark loop as done here, we won't run into it again anyway! */
-			}
-			/* We *do not need* to check/tag loops as already computed!
-			 * Due to the fact a loop only links to one of its two edges, a same fan *will never be walked more than
-			 * once!*
-			 * Since we consider edges having neighbor polys with inverted (flipped) normals as sharp, we are sure that
-			 * no fan will be skipped, even only considering the case (sharp curr_edge, smooth prev_edge), and not the
-			 * alternative (smooth curr_edge, sharp prev_edge).
-			 * All this due/thanks to link between normals and loop ordering.
-			 */
-			else {
-				/* Gah... We have to fan around current vertex, until we find the other non-smooth edge,
-				 * and accumulate face normals into the vertex!
-				 * Note in case this vertex has only one sharp edges, this is a waste because the normal is the same as
-				 * the vertex normal, but I do not see any easy way to detect that (would need to count number
-				 * of sharp edges per vertex, I doubt the additional memory usage would be worth it, especially as
-				 * it should not be a common case in real-life meshes anyway).
-				 */
-				const unsigned int mv_pivot_index = ml_curr->v;  /* The vertex we are "fanning" around! */
-				const MVert *mv_pivot = &mverts[mv_pivot_index];
-				const int *e2lfan_curr;
-				float vec_curr[3], vec_prev[3];
-				MLoop *mlfan_curr, *mlfan_next;
-				MPoly *mpfan_next;
-				float lnor[3] = {0.0f, 0.0f, 0.0f};
-				/* mlfan_vert_index: the loop of our current edge might not be the loop of our current vertex! */
-				int mlfan_curr_index, mlfan_vert_index, mpfan_curr_index;
-
-				e2lfan_curr = e2l_prev;
-				mlfan_curr = ml_prev;
-				mlfan_curr_index = ml_prev_index;
-				mlfan_vert_index = ml_curr_index;
-				mpfan_curr_index = mp_index;
-
-				BLI_assert(mlfan_curr_index >= 0);
-				BLI_assert(mlfan_vert_index >= 0);
-				BLI_assert(mpfan_curr_index >= 0);
-
-				/* Only need to compute previous edge's vector once, then we can just reuse old current one! */
-				{
-					const MEdge *me_prev = &medges[ml_curr->e];  /* ml_curr would be mlfan_prev if we needed that one */
-					const MVert *mv_2 = (me_prev->v1 == mv_pivot_index) ? &mverts[me_prev->v2] : &mverts[me_prev->v1];
+	if (numLoops < LOOP_SPLIT_TASK_BLOCK_SIZE * 8) {
+		/* Not enough loops to be worth the whole threading overhead... */
+		loop_split_generator_do(&common_data, false);
+	}
+	else {
+		TaskScheduler *task_scheduler;
+		TaskPool *task_pool;
+		int nbr_workers;
 
-					sub_v3_v3v3(vec_prev, mv_2->co, mv_pivot->co);
-					normalize_v3(vec_prev);
-				}
+		common_data.task_queue = BLI_thread_queue_init();
 
-				while (true) {
-					/* Compute edge vectors.
-					 * NOTE: We could pre-compute those into an array, in the first iteration, instead of computing them
-					 *       twice (or more) here. However, time gained is not worth memory and time lost,
-					 *       given the fact that this code should not be called that much in real-life meshes...
-					 */
-					{
-						const MEdge *me_curr = &medges[mlfan_curr->e];
-						const MVert *mv_2 = (me_curr->v1 == mv_pivot_index) ? &mverts[me_curr->v2] :
-						                                                      &mverts[me_curr->v1];
-
-						sub_v3_v3v3(vec_curr, mv_2->co, mv_pivot->co);
-						normalize_v3(vec_curr);
-					}
+		task_scheduler = BLI_task_scheduler_get();
+		task_pool = BLI_task_pool_create(task_scheduler, NULL);
 
-					{
-						/* Code similar to accumulate_vertex_normals_poly. */
-						/* Calculate angle between the two poly edges incident on this vertex. */
-						const float fac = saacos(dot_v3v3(vec_curr, vec_prev));
-						/* Accumulate */
-						madd_v3_v3fl(lnor, polynors[mpfan_curr_index], fac);
-					}
+		nbr_workers = max_ii(2, BLI_task_scheduler_num_threads(task_scheduler));
+		for (i = 1; i < nbr_workers; i++) {
+			BLI_task_pool_push(task_pool, loop_split_worker, &common_data, false, TASK_PRIORITY_HIGH);
+		}
+		BLI_task_pool_push(task_pool, loop_split_generator, &common_data, false, TASK_PRIORITY_HIGH);
+		BLI_task_pool_work_and_wait(task_pool);
 
-					/* We store here a pointer to all loop-normals processed. */
-					BLI_SMALLSTACK_PUSH(normal, &(r_loopnors[mlfan_vert_index][0]));
+		BLI_task_pool_free(task_pool);
 
-					if (IS_EDGE_SHARP(e2lfan_curr)) {
-						/* Current edge is sharp, we have finished with this fan of faces around this vert! */
-						break;
-					}
+		BLI_thread_queue_free(common_data.task_queue);
+	}
+
+	MEM_freeN(edge_to_loops);
+	if (!r_loop_to_poly) {
+		MEM_freeN(loop_to_poly);
+	}
+
+	if (r_lnors_spacearr) {
+		MEM_freeN(sharp_verts);
+		if (r_lnors_spacearr == &_lnors_spacearr) {
+			BKE_lnor_spacearr_free(r_lnors_spacearr);
+		}
+	}
+
+#ifdef DEBUG_TIME
+	TIMEIT_END(BKE_mesh_normals_loop_split);
+#endif
+
+	}
+}
 
-					copy_v3_v3(vec_prev, vec_curr);
-
-					/* Warning! This is rather complex!
-					 * We have to find our next edge around the vertex (fan mode).
-					 * First we find the next loop, which is either previous or next to mlfan_curr_index, depending
-					 * whether both loops using current edge are in the same direction or not, and whether
-					 * mlfan_curr_index actually uses the vertex we are fanning around!
-					 * mlfan_curr_index is the index of mlfan_next here, and mlfan_next is not the real next one
-					 * (i.e. not the future mlfan_curr)...
-					 */
-					mlfan_curr_index = (e2lfan_curr[0] == mlfan_curr_index) ? e2lfan_curr[1] : e2lfan_curr[0];
-					mpfan_curr_index = loop_to_poly[mlfan_curr_index];
-
-					BLI_assert(mlfan_curr_index >= 0);
-					BLI_assert(mpfan_curr_index >= 0);
-
-					mlfan_next = &mloops[mlfan_curr_index];
-					mpfan_next = &mpolys[mpfan_curr_index];
-					if ((mlfan_curr->v == mlfan_next->v && mlfan_curr->v == mv_pivot_index) ||
-					    (mlfan_curr->v != mlfan_next->v && mlfan_curr->v != mv_pivot_index))
-					{
-						/* We need the previous loop, but current one is our vertex's loop. */
-						mlfan_vert_index = mlfan_curr_index;
-						if (--mlfan_curr_index < mpfan_next->loopstart) {
-							mlfan_curr_index = mpfan_next->loopstart + mpfan_next->totloop - 1;
-						}
+#undef INDEX_UNSET
+#undef INDEX_INVALID
+#undef IS_EDGE_SHARP
+
+/**
+ * Compute internal representation of given custom normals (as an array of float[2]).
+ * It also makes sure the mesh matches those custom normals, by setting sharp edges flag as needed to get a
+ * same custom lnor for all loops sharing a same smooth fan.
+ * If use_vertices if true, custom_loopnors is assumed to be per-vertex, not per-loop
+ * (this allows to set whole vert's normals at once, useful in some cases).
+ */
+static void mesh_normals_loop_custom_set(
+        MVert *mverts, const int numVerts, MEdge *medges, const int numEdges,
+        MLoop *mloops, float (*custom_loopnors)[3], const int numLoops,
+        MPoly *mpolys, const float (*polynors)[3], const int numPolys,
+        short (*r_clnors_data)[2], const bool use_vertices)
+{
+	/* We *may* make that poor BKE_mesh_normals_loop_split() even more complex by making it handling that
+	 * feature too, would probably be more efficient in absolute.
+	 * However, this function *is not* performance-critical, since it is mostly expected to be called
+	 * by io addons when importing custom normals, and modifier (and perhaps from some editing tools later?).
+	 * So better to keep some simplicity here, and just call BKE_mesh_normals_loop_split() twice!
+	 */
+	MLoopNorSpaceArray lnors_spacearr = {NULL};
+	BLI_bitmap *done_loops = BLI_BITMAP_NEW((size_t)numLoops, __func__);
+	float (*lnors)[3] = MEM_callocN(sizeof(*lnors) * (size_t)numLoops, __func__);
+	int *loop_to_poly = MEM_mallocN(sizeof(int) * (size_t)numLoops, __func__);
+	/* In this case we always consider split nors as ON, and do not want to use angle to define smooth fans! */
+	const bool use_split_normals = true;
+	const float split_angle = (float)M_PI;
+	int i;
+
+	BLI_SMALLSTACK_DECLARE(clnors_data, short *);
+
+	/* Compute current lnor spacearr. */
+	BKE_mesh_normals_loop_split(mverts, numVerts, medges, numEdges, mloops, lnors, numLoops,
+	                            mpolys, polynors, numPolys, use_split_normals, split_angle,
+	                            &lnors_spacearr, NULL, loop_to_poly);
+
+	/* Now, check each current smooth fan (one lnor space per smooth fan!), and if all its matching custom lnors
+	 * are not (enough) equal, add sharp edges as needed.
+	 * This way, next time we run BKE_mesh_normals_loop_split(), we'll get lnor spacearr/smooth fans matching
+	 * given custom lnors.
+	 * Note this code *will never* unsharp edges!
+	 * And quite obviously, when we set custom normals per vertices, running this is absolutely useless.
+	 */
+	if (!use_vertices) {
+		for (i = 0; i < numLoops; i++) {
+			if (!lnors_spacearr.lspacearr[i]) {
+				/* This should not happen in theory, but in some rare case (probably ugly geometry)
+				 * we can get some NULL loopspacearr at this point. :/
+				 * Maybe we should set those loops' edges as sharp?
+				 */
+				BLI_BITMAP_ENABLE(done_loops, i);
+				printf("WARNING! Getting invalid NULL loop space for loop %d!\n", i);
+				continue;
+			}
+
+			if (!BLI_BITMAP_TEST(done_loops, i)) {
+				/* Notes:
+				 *     * In case of mono-loop smooth fan, loops is NULL, so everything is fine (we have nothing to do).
+				 *     * Loops in this linklist are ordered (in reversed order compared to how they were discovered by
+				 *       BKE_mesh_normals_loop_split(), but this is not a problem). Which means if we find a
+				 *       mismatching clnor, we know all remaining loops will have to be in a new, different smooth fan/
+				 *       lnor space.
+				 *     * In smooth fan case, we compare each clnor against a ref one, to avoid small differences adding
+				 *       up into a real big one in the end!
+				 */
+				LinkNode *loops = lnors_spacearr.lspacearr[i]->loops;
+				MLoop *prev_ml = NULL;
+				const float *org_nor = NULL;
+
+				while (loops) {
+					const int lidx = GET_INT_FROM_POINTER(loops->link);
+					MLoop *ml = &mloops[lidx];
+					const int nidx = lidx;
+					float *nor = custom_loopnors[nidx];
+
+					if (!org_nor) {
+						org_nor = nor;
 					}
-					else {
-						/* We need the next loop, which is also our vertex's loop. */
-						if (++mlfan_curr_index >= mpfan_next->loopstart + mpfan_next->totloop) {
-							mlfan_curr_index = mpfan_next->loopstart;
-						}
-						mlfan_vert_index = mlfan_curr_index;
+					else if (dot_v3v3(org_nor, nor) < LNOR_SPACE_TRIGO_THRESHOLD) {
+						/* Current normal differs too much from org one, we have to tag the edge between
+						 * previous loop's face and current's one as sharp.
+						 * We know those two loops do not point to the same edge, since we do not allow reversed winding
+						 * in a same smooth fan.
+						 */
+						const MPoly *mp = &mpolys[loop_to_poly[lidx]];
+						const MLoop *mlp = &mloops[(lidx == mp->loopstart) ? mp->loopstart + mp->totloop - 1 : lidx - 1];
+						medges[(prev_ml->e == mlp->e) ? prev_ml->e : ml->e].flag |= ME_SHARP;
+
+						org_nor = nor;
 					}
-					mlfan_curr = &mloops[mlfan_curr_index];
-					/* And now we are back in sync, mlfan_curr_index is the index of mlfan_curr! Pff! */
 
-					e2lfan_curr = edge_to_loops[mlfan_curr->e];
+					prev_ml = ml;
+					loops = loops->next;
+					BLI_BITMAP_ENABLE(done_loops, lidx);
 				}
+				BLI_BITMAP_ENABLE(done_loops, i);  /* For single loops, where lnors_spacearr.lspacearr[i]->loops is NULL. */
+			}
+		}
 
-				/* In case we get a zero normal here, just use vertex normal already set! */
-				if (LIKELY(normalize_v3(lnor) != 0.0f)) {
-					/* Copy back the final computed normal into all related loop-normals. */
-					float *nor;
-					while ((nor = BLI_SMALLSTACK_POP(normal))) {
-						copy_v3_v3(nor, lnor);
-					}
+		/* And now, recompute our new auto lnors and lnor spacearr! */
+		BKE_lnor_spacearr_clear(&lnors_spacearr);
+		BKE_mesh_normals_loop_split(mverts, numVerts, medges, numEdges, mloops, lnors, numLoops,
+		                            mpolys, polynors, numPolys, use_split_normals, split_angle,
+		                            &lnors_spacearr, NULL, loop_to_poly);
+	}
+	else {
+		BLI_BITMAP_SET_ALL(done_loops, true, (size_t)numLoops);
+	}
+
+	/* And we just have to convert plain object-space custom normals to our lnor space-encoded ones. */
+	for (i = 0; i < numLoops; i++) {
+		if (!lnors_spacearr.lspacearr[i]) {
+			BLI_BITMAP_DISABLE(done_loops, i);
+			printf("WARNING! Still getting invalid NULL loop space in second loop for loop %d!\n", i);
+			continue;
+		}
+
+		if (BLI_BITMAP_TEST_BOOL(done_loops, i)) {
+			/* Note we accumulate and average all custom normals in current smooth fan, to avoid getting different
+			 * clnors data (tiny differences in plain custom normals can give rather huge differences in
+			 * computed 2D factors).
+			 */
+			LinkNode *loops = lnors_spacearr.lspacearr[i]->loops;
+			if (loops) {
+				int nbr_nors = 0;
+				float avg_nor[3];
+				short clnor_data_tmp[2], *clnor_data;
+
+				zero_v3(avg_nor);
+				while (loops) {
+					const int lidx = GET_INT_FROM_POINTER(loops->link);
+					const int nidx = use_vertices ? (int)mloops[lidx].v : lidx;
+					float *nor = custom_loopnors[nidx];
+
+					nbr_nors++;
+					add_v3_v3(avg_nor, nor);
+					BLI_SMALLSTACK_PUSH(clnors_data, (short *)r_clnors_data[lidx]);
+
+					loops = loops->next;
+					BLI_BITMAP_DISABLE(done_loops, lidx);
 				}
-				else {
-					/* We still have to clear the stack! */
-					while (BLI_SMALLSTACK_POP(normal));
+
+				mul_v3_fl(avg_nor, 1.0f / (float)nbr_nors);
+				BKE_lnor_space_custom_normal_to_data(lnors_spacearr.lspacearr[i], avg_nor, clnor_data_tmp);
+
+				while ((clnor_data = BLI_SMALLSTACK_POP(clnors_data))) {
+					clnor_data[0] = clnor_data_tmp[0];
+					clnor_data[1] = clnor_data_tmp[1];
 				}
 			}
+			else {
+				const int nidx = use_vertices ? (int)mloops[i].v : i;
+				float *nor = custom_loopnors[nidx];
 
-			ml_prev = ml_curr;
-			ml_prev_index = ml_curr_index;
+				BKE_lnor_space_custom_normal_to_data(lnors_spacearr.lspacearr[i], nor, r_clnors_data[i]);
+				BLI_BITMAP_DISABLE(done_loops, i);
+			}
 		}
 	}
 
-	MEM_freeN(edge_to_loops);
+	MEM_freeN(lnors);
 	MEM_freeN(loop_to_poly);
+	MEM_freeN(done_loops);
+	BKE_lnor_spacearr_free(&lnors_spacearr);
+}
 
-#ifdef DEBUG_TIME
-	TIMEIT_END(BKE_mesh_normals_loop_split);
-#endif
-
-#undef INDEX_UNSET
-#undef INDEX_INVALID
-#undef IS_EDGE_SHARP
+void BKE_mesh_normals_loop_custom_set(
+        MVert *mverts, const int numVerts, MEdge *medges, const int numEdges,
+        MLoop *mloops, float (*custom_loopnors)[3], const int numLoops,
+        MPoly *mpolys, const float (*polynors)[3], const int numPolys,
+        short (*r_clnors_data)[2])
+{
+	mesh_normals_loop_custom_set(mverts, numVerts, medges, numEdges, mloops, custom_loopnors, numLoops,
+	                             mpolys, polynors, numPolys, r_clnors_data, false);
+}
 
-	}
+void BKE_mesh_normals_loop_custom_from_vertices_set(
+        MVert *mverts, float (*custom_vertnors)[3], const int numVerts,
+        MEdge *medges, const int numEdges, MLoop *mloops, const int numLoops,
+        MPoly *mpolys, const float (*polynors)[3], const int numPolys,
+        short (*r_clnors_data)[2])
+{
+	mesh_normals_loop_custom_set(mverts, numVerts, medges, numEdges, mloops, custom_vertnors, numLoops,
+	                             mpolys, polynors, numPolys, r_clnors_data, true);
 }
 
+#undef LNOR_SPACE_TRIGO_THRESHOLD
 
 /** \} */
 
diff --git a/source/blender/blenkernel/intern/mesh_remap.c b/source/blender/blenkernel/intern/mesh_remap.c
index 7e94e17d1ff..aca72614094 100644
--- a/source/blender/blenkernel/intern/mesh_remap.c
+++ b/source/blender/blenkernel/intern/mesh_remap.c
@@ -1047,6 +1047,8 @@ void BKE_mesh_remap_calc_loops_from_dm(
 				}
 			}
 			if (need_lnors_dst) {
+				short (*custom_nors_dst)[2] = CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL);
+
 				/* Cache poly nors into a temp CDLayer. */
 				loop_nors_dst = CustomData_get_layer(ldata_dst, CD_NORMAL);
 				if (dirty_nors_dst || !loop_nors_dst) {
@@ -1056,8 +1058,8 @@ void BKE_mesh_remap_calc_loops_from_dm(
 					}
 					BKE_mesh_normals_loop_split(verts_dst, numverts_dst, edges_dst, numedges_dst,
 					                            loops_dst, loop_nors_dst, numloops_dst,
-					                            polys_dst, poly_nors_dst, numpolys_dst,
-					                            use_split_nors_dst, split_angle_dst);
+					                            polys_dst, (const float (*)[3])poly_nors_dst, numpolys_dst,
+					                            use_split_nors_dst, split_angle_dst, NULL, custom_nors_dst, NULL);
 				}
 			}
 			if (need_pnors_src || need_lnors_src) {
diff --git a/source/blender/blenkernel/intern/mesh_validate.c b/source/blender/blenkernel/intern/mesh_validate.c
index 3a6c949fe9c..4b2c2aba691 100644
--- a/source/blender/blenkernel/intern/mesh_validate.c
+++ b/source/blender/blenkernel/intern/mesh_validate.c
@@ -963,7 +963,7 @@ bool BKE_mesh_validate_all_customdata(CustomData *vdata, CustomData *edata,
  *
  * \returns true if a change is made.
  */
-int BKE_mesh_validate(Mesh *me, const int do_verbose)
+int BKE_mesh_validate(Mesh *me, const int do_verbose, const int cddata_check_mask)
 {
 	bool is_valid = true;
 	bool changed;
@@ -974,7 +974,7 @@ int BKE_mesh_validate(Mesh *me, const int do_verbose)
 
 	is_valid &= BKE_mesh_validate_all_customdata(
 	        &me->vdata, &me->edata, &me->ldata, &me->pdata,
-	        true,
+	        cddata_check_mask,
 	        do_verbose, true,
 	        &changed);
 
diff --git a/source/blender/blenkernel/intern/multires.c b/source/blender/blenkernel/intern/multires.c
index 0adc65bd806..220d0f7c604 100644
--- a/source/blender/blenkernel/intern/multires.c
+++ b/source/blender/blenkernel/intern/multires.c
@@ -1641,7 +1641,8 @@ void multires_free(Multires *mr)
 			lvl = lvl->next;
 		}
 
-		MEM_freeN(mr->verts);
+		/* mr->verts may be NULL when loading old files, see direct_link_mesh() in readfile.c, and T43560. */
+		MEM_SAFE_FREE(mr->verts);
 
 		BLI_freelistN(&mr->levels);
 
diff --git a/source/blender/blenkernel/intern/pbvh.c b/source/blender/blenkernel/intern/pbvh.c
index bd953890443..5e07437d426 100644
--- a/source/blender/blenkernel/intern/pbvh.c
+++ b/source/blender/blenkernel/intern/pbvh.c
@@ -281,7 +281,7 @@ static int map_insert_vert(PBVH *bvh, GHash *map,
 /* Find vertices used by the faces in this node and update the draw buffers */
 static void build_mesh_leaf_node(PBVH *bvh, PBVHNode *node)
 {
-	GHashIterator *iter;
+	GHashIterator gh_iter;
 	GHash *map;
 	int i, j, totface;
 	bool has_visible = false;
@@ -314,22 +314,17 @@ static void build_mesh_leaf_node(PBVH *bvh, PBVHNode *node)
 	                                 "bvh node vert indices");
 
 	/* Build the vertex list, unique verts first */
-	for (iter = BLI_ghashIterator_new(map), i = 0;
-	     BLI_ghashIterator_done(iter) == false;
-	     BLI_ghashIterator_step(iter), ++i)
-	{
-		void *value = BLI_ghashIterator_getValue(iter);
+	GHASH_ITER (gh_iter, map) {
+		void *value = BLI_ghashIterator_getValue(&gh_iter);
 		int ndx = GET_INT_FROM_POINTER(value);
 
 		if (ndx < 0)
 			ndx = -ndx + node->uniq_verts - 1;
 
 		node->vert_indices[ndx] =
-		    GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(iter));
+		        GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(&gh_iter));
 	}
 
-	BLI_ghashIterator_free(iter);
-
 	for (i = 0; i < totface; ++i) {
 		MFace *f = bvh->faces + node->prim_indices[i];
 		int sides = f->v4 ? 4 : 3;
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index 45036369269..83287fe7725 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -1330,7 +1330,7 @@ static double seq_rendersize_to_scale_factor(int size)
 	return 0.25;
 }
 
-static void seq_open_anim_file(Sequence *seq)
+static void seq_open_anim_file(Sequence *seq, bool openfile)
 {
 	char name[FILE_MAX];
 	StripProxy *proxy;
@@ -1343,8 +1343,14 @@ static void seq_open_anim_file(Sequence *seq)
 	                 seq->strip->dir, seq->strip->stripdata->name);
 	BLI_path_abs(name, G.main->name);
 	
-	seq->anim = openanim(name, IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
-	                     seq->streamindex, seq->strip->colorspace_settings.name);
+	if (openfile) {
+		seq->anim = openanim(name, IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
+		                     seq->streamindex, seq->strip->colorspace_settings.name);
+	}
+	else {
+		seq->anim = openanim_noload(name, IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
+		                            seq->streamindex, seq->strip->colorspace_settings.name);
+	}
 
 	if (seq->anim == NULL) {
 		return;
@@ -1458,7 +1464,7 @@ static ImBuf *seq_proxy_fetch(const SeqRenderData *context, Sequence *seq, int c
 			return NULL;
 		}
  
-		seq_open_anim_file(seq);
+		seq_open_anim_file(seq, true);
 
 		frameno = IMB_anim_index_get_frame_index(seq->anim, seq->strip->proxy->tc, frameno);
 
@@ -1560,7 +1566,7 @@ SeqIndexBuildContext *BKE_sequencer_proxy_rebuild_context(Main *bmain, Scene *sc
 	context->seq = nseq;
 
 	if (nseq->type == SEQ_TYPE_MOVIE) {
-		seq_open_anim_file(nseq);
+		seq_open_anim_file(nseq, true);
 
 		if (nseq->anim) {
 			context->index_context = IMB_anim_index_rebuild_context(nseq->anim,
@@ -2780,7 +2786,7 @@ static ImBuf *do_render_strip_uncached(const SeqRenderData *context, Sequence *s
 
 		case SEQ_TYPE_MOVIE:
 		{
-			seq_open_anim_file(seq);
+			seq_open_anim_file(seq, false);
 
 			if (seq->anim) {
 				IMB_Proxy_Size proxy_size = seq_rendersize_to_proxysize(context->preview_render_size);
@@ -2790,7 +2796,7 @@ static ImBuf *do_render_strip_uncached(const SeqRenderData *context, Sequence *s
 				                         seq->strip->proxy ? seq->strip->proxy->tc : IMB_TC_RECORD_RUN,
 				                         proxy_size);
 
-				/* fetching for requested proxy sze failed, try fetching the original isntead */
+				/* fetching for requested proxy size failed, try fetching the original instead */
 				if (!ibuf && proxy_size != IMB_PROXY_NONE) {
 					ibuf = IMB_anim_absolute(seq->anim, nr + seq->anim_startofs,
 					                         seq->strip->proxy ? seq->strip->proxy->tc : IMB_TC_RECORD_RUN,
diff --git a/source/blender/blenkernel/intern/shrinkwrap.c b/source/blender/blenkernel/intern/shrinkwrap.c
index d91818615f3..2ff81cd5394 100644
--- a/source/blender/blenkernel/intern/shrinkwrap.c
+++ b/source/blender/blenkernel/intern/shrinkwrap.c
@@ -89,7 +89,7 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
 	nearest.index = -1;
 	nearest.dist_sq = FLT_MAX;
 #ifndef __APPLE__
-#pragma omp parallel for default(none) private(i) firstprivate(nearest) shared(treeData, calc) schedule(static) if(calc->numVerts > BKE_MESH_OMP_LIMIT)
+#pragma omp parallel for default(none) private(i) firstprivate(nearest) shared(treeData, calc) schedule(static) if (calc->numVerts > BKE_MESH_OMP_LIMIT)
 #endif
 	for (i = 0; i < calc->numVerts; ++i) {
 		float *co = calc->vertexCos[i];
@@ -394,7 +394,7 @@ static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
 
 	/* Find the nearest vertex */
 #ifndef __APPLE__
-#pragma omp parallel for default(none) private(i) firstprivate(nearest) shared(calc, treeData) schedule(static) if(calc->numVerts > BKE_MESH_OMP_LIMIT)
+#pragma omp parallel for default(none) private(i) firstprivate(nearest) shared(calc, treeData) schedule(static) if (calc->numVerts > BKE_MESH_OMP_LIMIT)
 #endif
 	for (i = 0; i < calc->numVerts; ++i) {
 		float *co = calc->vertexCos[i];
diff --git a/source/blender/blenkernel/intern/smoke.c b/source/blender/blenkernel/intern/smoke.c
index 4c46875bd48..a34aa5009e6 100644
--- a/source/blender/blenkernel/intern/smoke.c
+++ b/source/blender/blenkernel/intern/smoke.c
@@ -2131,6 +2131,9 @@ static void update_flowsfluids(Scene *scene, Object *ob, SmokeDomainSettings *sd
 					if (sfs->source == MOD_SMOKE_FLOW_SOURCE_PARTICLES) {
 						/* emit_from_particles() updates timestep internally */
 						emit_from_particles(collob, sds, sfs, &em_temp, scene, sdt);
+						if (!(sfs->flags & MOD_SMOKE_FLOW_USE_PART_SIZE)) {
+							hires_multiplier = 1;
+						}
 					}
 					else { /* MOD_SMOKE_FLOW_SOURCE_MESH */
 						/* update flow object frame */
diff --git a/source/blender/blenkernel/intern/subsurf_ccg.c b/source/blender/blenkernel/intern/subsurf_ccg.c
index 45ec3370672..9519c7b25a1 100644
--- a/source/blender/blenkernel/intern/subsurf_ccg.c
+++ b/source/blender/blenkernel/intern/subsurf_ccg.c
@@ -3465,6 +3465,7 @@ static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
 
 	ccgdm->dm.calcNormals = ccgDM_calcNormals;
 	ccgdm->dm.calcLoopNormals = CDDM_calc_loop_normals;
+	ccgdm->dm.calcLoopNormalsSpaceArray = CDDM_calc_loop_normals_spacearr;
 	ccgdm->dm.recalcTessellation = ccgDM_recalcTessellation;
 
 	ccgdm->dm.getVertCos = ccgdm_getVertCos;
diff --git a/source/blender/blenkernel/intern/text.c b/source/blender/blenkernel/intern/text.c
index 111a4cac56a..c5a8cbe68b2 100644
--- a/source/blender/blenkernel/intern/text.c
+++ b/source/blender/blenkernel/intern/text.c
@@ -685,7 +685,7 @@ void BKE_text_clear(Text *text) /* called directly from rna */
 {
 	int oldstate;
 
-	oldstate = txt_get_undostate(  );
+	oldstate = txt_get_undostate();
 	txt_set_undostate(1);
 	txt_sel_all(text);
 	txt_delete_sel(text);
diff --git a/source/blender/blenlib/BLI_math_vector.h b/source/blender/blenlib/BLI_math_vector.h
index 4455e72cf45..0f437b7fc38 100644
--- a/source/blender/blenlib/BLI_math_vector.h
+++ b/source/blender/blenlib/BLI_math_vector.h
@@ -290,6 +290,8 @@ MINLINE void normal_float_to_short_v3(short r[3], const float n[3]);
 void minmax_v3v3_v3(float min[3], float max[3], const float vec[3]);
 void minmax_v2v2_v2(float min[2], float max[2], const float vec[2]);
 
+void minmax_v3v3_v3_array(float r_min[3], float r_max[3], float (*vec_arr)[3], int nbr);
+
 void dist_ensure_v3_v3fl(float v1[3], const float v2[3], const float dist);
 void dist_ensure_v2_v2fl(float v1[2], const float v2[2], const float dist);
 
diff --git a/source/blender/blenlib/intern/boxpack2d.c b/source/blender/blenlib/intern/boxpack2d.c
index bae56444f37..2db52cbda60 100644
--- a/source/blender/blenlib/intern/boxpack2d.c
+++ b/source/blender/blenlib/intern/boxpack2d.c
@@ -32,6 +32,9 @@
 #include "BLI_utildefines.h"
 #include "BLI_boxpack2d.h"  /* own include */
 
+#include "BLI_sort.h"  /* qsort_r */
+#define qsort_r  BLI_qsort_r
+
 #include "BLI_strict_flags.h"
 
 #ifdef __GNUC__
@@ -226,18 +229,20 @@ static int box_areasort(const void *p1, const void *p2)
  * sorts from lower left to top right It uses the current box's width and height
  * as offsets when sorting, this has the result of not placing boxes outside
  * the bounds of the existing backed area where possible
- * */
-static float box_width;
-static float box_height;
-static BoxVert *vertarray;
+ */
+struct VertSortContext {
+	BoxVert *vertarray;
+	float box_width, box_height;
+};
 
-static int vertex_sort(const void *p1, const void *p2)
+static int vertex_sort(const void *p1, const void *p2, void *vs_ctx_p)
 {
-	BoxVert *v1, *v2;
+	const struct VertSortContext *vs_ctx = vs_ctx_p;
+	const BoxVert *v1, *v2;
 	float a1, a2;
 
-	v1 = vertarray + ((const int *)p1)[0];
-	v2 = vertarray + ((const int *)p2)[0];
+	v1 = &vs_ctx->vertarray[*((const unsigned int *)p1)];
+	v2 = &vs_ctx->vertarray[*((const unsigned int *)p2)];
 
 #ifdef USE_FREE_STRIP
 	/* push free verts to the end so we can strip */
@@ -246,8 +251,8 @@ static int vertex_sort(const void *p1, const void *p2)
 	else if (UNLIKELY(v2->free == 0))                  return -1;
 #endif
 
-	a1 = max_ff(v1->x + box_width, v1->y + box_height);
-	a2 = max_ff(v2->x + box_width, v2->y + box_height);
+	a1 = max_ff(v1->x + vs_ctx->box_width, v1->y + vs_ctx->box_height);
+	a2 = max_ff(v2->x + vs_ctx->box_width, v2->y + vs_ctx->box_height);
 
 #ifdef USE_PACK_BIAS
 	a1 += v1->bias;
@@ -285,6 +290,8 @@ void BLI_box_pack_2d(BoxPack *boxarray, const unsigned int len, float *r_tot_x,
 	BoxPack *box, *box_test; /*current box and another for intersection tests*/
 	BoxVert *vert; /* the current vert */
 
+	struct VertSortContext vs_ctx;
+
 	if (!len) {
 		*r_tot_x = tot_x;
 		*r_tot_y = tot_y;
@@ -295,9 +302,11 @@ void BLI_box_pack_2d(BoxPack *boxarray, const unsigned int len, float *r_tot_x,
 	qsort(boxarray, (size_t)len, sizeof(BoxPack), box_areasort);
 
 	/* add verts to the boxes, these are only used internally  */
-	vert = vertarray = MEM_mallocN((size_t)len * 4 * sizeof(BoxVert), "BoxPack Verts");
+	vert = MEM_mallocN((size_t)len * 4 * sizeof(BoxVert), "BoxPack Verts");
 	vertex_pack_indices = MEM_mallocN((size_t)len * 3 * sizeof(int), "BoxPack Indices");
 
+	vs_ctx.vertarray = vert;
+
 	for (box = boxarray, box_index = 0, i = 0; box_index < len; box_index++, box++) {
 
 		vert->blb = vert->brb = vert->tlb =
@@ -371,16 +380,16 @@ void BLI_box_pack_2d(BoxPack *boxarray, const unsigned int len, float *r_tot_x,
 	/* Main boxpacking loop */
 	for (box_index = 1; box_index < len; box_index++, box++) {
 
-		/* These static floatds are used for sorting */
-		box_width = box->w;
-		box_height = box->h;
+		/* These floats are used for sorting re-sorting */
+		vs_ctx.box_width = box->w;
+		vs_ctx.box_height = box->h;
 
-		qsort(vertex_pack_indices, (size_t)verts_pack_len, sizeof(int), vertex_sort);
+		qsort_r(vertex_pack_indices, (size_t)verts_pack_len, sizeof(int), vertex_sort, &vs_ctx);
 
 #ifdef USE_FREE_STRIP
 		/* strip free vertices */
 		i = verts_pack_len - 1;
-		while ((i != 0) && vertarray[vertex_pack_indices[i]].free == 0) {
+		while ((i != 0) && vs_ctx.vertarray[vertex_pack_indices[i]].free == 0) {
 			i--;
 		}
 		verts_pack_len = i + 1;
@@ -391,7 +400,7 @@ void BLI_box_pack_2d(BoxPack *boxarray, const unsigned int len, float *r_tot_x,
 		isect = true;
 
 		for (i = 0; i < verts_pack_len && isect; i++) {
-			vert = vertarray + vertex_pack_indices[i];
+			vert = &vs_ctx.vertarray[vertex_pack_indices[i]];
 			/* printf("\ttesting vert %i %i %i %f %f\n", i,
 			 *        vert->free, verts_pack_len, vert->x, vert->y); */
 
@@ -661,5 +670,5 @@ void BLI_box_pack_2d(BoxPack *boxarray, const unsigned int len, float *r_tot_x,
 		box->v[0] = box->v[1] = box->v[2] = box->v[3] = NULL;
 	}
 	MEM_freeN(vertex_pack_indices);
-	MEM_freeN(vertarray);
+	MEM_freeN(vs_ctx.vertarray);
 }
diff --git a/source/blender/blenlib/intern/dynlib.c b/source/blender/blenlib/intern/dynlib.c
index b66eda4f141..e916b01e859 100644
--- a/source/blender/blenlib/intern/dynlib.c
+++ b/source/blender/blenlib/intern/dynlib.c
@@ -43,6 +43,8 @@ struct DynamicLibrary {
 
 #ifdef WIN32
 
+#define _WIN32_WINNT 0x501 /* Windows XP or newer */
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include "utf_winfunc.h"
 #include "utfconv.h"
diff --git a/source/blender/blenlib/intern/math_vector.c b/source/blender/blenlib/intern/math_vector.c
index 887ec7d4d2c..d065fa7e5a7 100644
--- a/source/blender/blenlib/intern/math_vector.c
+++ b/source/blender/blenlib/intern/math_vector.c
@@ -757,6 +757,13 @@ void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
 	if (max[1] < vec[1]) max[1] = vec[1];
 }
 
+void minmax_v3v3_v3_array(float r_min[3], float r_max[3], float (*vec_arr)[3], int nbr)
+{
+	while (nbr--) {
+		minmax_v3v3_v3(r_min, r_max, *vec_arr++);
+	}
+}
+
 /** ensure \a v1 is \a dist from \a v2 */
 void dist_ensure_v3_v3fl(float v1[3], const float v2[3], const float dist)
 {
diff --git a/source/blender/blenlib/intern/path_util.c b/source/blender/blenlib/intern/path_util.c
index cc9fbc85a09..fb4c31d5cdf 100644
--- a/source/blender/blenlib/intern/path_util.c
+++ b/source/blender/blenlib/intern/path_util.c
@@ -346,7 +346,7 @@ void BLI_cleanup_path(const char *relabase, char *path)
 	/* Note
 	 *   memmove(start, eind, strlen(eind) + 1);
 	 * is the same as
-	 *   strcpy( start, eind ); 
+	 *   strcpy(start, eind);
 	 * except strcpy should not be used because there is overlap,
 	 * so use memmove's slightly more obscure syntax - Campbell
 	 */
diff --git a/source/blender/blenlib/intern/polyfill2d_beautify.c b/source/blender/blenlib/intern/polyfill2d_beautify.c
index 7914b7cb39b..ba71f52b530 100644
--- a/source/blender/blenlib/intern/polyfill2d_beautify.c
+++ b/source/blender/blenlib/intern/polyfill2d_beautify.c
@@ -237,7 +237,10 @@ static void polyedge_beauty_cost_update_single(
 	{
 		/* recalculate edge */
 		const float cost = polyedge_rotate_beauty_calc(coords, tris, e);
-		if (cost < 0.0f) {
+		/* We can get cases where both choices generate very small negative costs, which leads to infinite loop.
+		 * Anyway, costs above that are not worth recomputing, maybe we could even optimize it to a smaller limit?
+		 * See T43578. */
+		if (cost < -FLT_EPSILON) {
 			eheap_table[i] = BLI_heap_insert(eheap, cost, e);
 		}
 		else {
diff --git a/source/blender/blenlib/intern/system.c b/source/blender/blenlib/intern/system.c
index 51b8efbb79f..d83077e0e78 100644
--- a/source/blender/blenlib/intern/system.c
+++ b/source/blender/blenlib/intern/system.c
@@ -115,7 +115,7 @@ void BLI_system_backtrace(FILE *fp)
 	symbolinfo->SizeOfStruct = sizeof(SYMBOL_INFO);
 
 	for (i = 0; i < nframes; i++) {
-		SymFromAddr(process, ( DWORD64 )( stack[ i ] ), 0, symbolinfo);
+		SymFromAddr(process, (DWORD64)(stack[i]), 0, symbolinfo);
 
 		fprintf(fp, "%u: %s - 0x%0X\n", nframes - i - 1, symbolinfo->Name, symbolinfo->Address);
 	}
diff --git a/source/blender/blenlib/intern/time.c b/source/blender/blenlib/intern/time.c
index 3a20d3ee920..a0fb78cd193 100644
--- a/source/blender/blenlib/intern/time.c
+++ b/source/blender/blenlib/intern/time.c
@@ -33,6 +33,9 @@
 #include "PIL_time.h"
 
 #ifdef WIN32
+
+#define _WIN32_WINNT 0x501 /* Windows XP or newer */
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
 double PIL_check_seconds_timer(void) 
diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c
index e2aa5c0b28d..a04e8c8db6d 100644
--- a/source/blender/blenloader/intern/readfile.c
+++ b/source/blender/blenloader/intern/readfile.c
@@ -4840,6 +4840,11 @@ static void direct_link_modifiers(FileData *fd, ListBase *lb)
 			if (fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
 				BLI_endian_switch_int32_array(hmd->indexar, hmd->totindex);
 			}
+
+			hmd->curfalloff = newdataadr(fd, hmd->curfalloff);
+			if (hmd->curfalloff) {
+				direct_link_curvemapping(fd, hmd->curfalloff);
+			}
 		}
 		else if (md->type == eModifierType_ParticleSystem) {
 			ParticleSystemModifierData *psmd = (ParticleSystemModifierData *)md;
diff --git a/source/blender/blenloader/intern/versioning_250.c b/source/blender/blenloader/intern/versioning_250.c
index b71a4029690..4125451ead9 100644
--- a/source/blender/blenloader/intern/versioning_250.c
+++ b/source/blender/blenloader/intern/versioning_250.c
@@ -323,7 +323,7 @@ static void area_add_window_regions(ScrArea *sa, SpaceLink *sl, ListBase *lb)
 					SpaceNla *snla = (SpaceNla *)sl;
 					memcpy(&ar->v2d, &snla->v2d, sizeof(View2D));
 
-					ar->v2d.tot.ymin = (float)(-sa->winy)/3.0f;
+					ar->v2d.tot.ymin = (float)(-sa->winy) / 3.0f;
 					ar->v2d.tot.ymax = 0.0f;
 
 					ar->v2d.scroll |= (V2D_SCROLL_BOTTOM|V2D_SCROLL_SCALE_HORIZONTAL);
@@ -338,8 +338,8 @@ static void area_add_window_regions(ScrArea *sa, SpaceLink *sl, ListBase *lb)
 
 					/* we totally reinit the view for the Action Editor, as some old instances had some weird cruft set */
 					ar->v2d.tot.xmin = -20.0f;
-					ar->v2d.tot.ymin = (float)(-sa->winy)/3.0f;
-					ar->v2d.tot.xmax = (float)((sa->winx > 120)? (sa->winx) : 120);
+					ar->v2d.tot.ymin = (float)(-sa->winy) / 3.0f;
+					ar->v2d.tot.xmax = (float)((sa->winx > 120) ? (sa->winx) : 120);
 					ar->v2d.tot.ymax = 0.0f;
 
 					ar->v2d.cur = ar->v2d.tot;
diff --git a/source/blender/blenloader/intern/versioning_270.c b/source/blender/blenloader/intern/versioning_270.c
index 6f33cab203e..4ca1a44d64e 100644
--- a/source/blender/blenloader/intern/versioning_270.c
+++ b/source/blender/blenloader/intern/versioning_270.c
@@ -473,59 +473,92 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *main)
 		}
 	}
 	
-	if (!DNA_struct_elem_find(fd->filesdna, "ClothSimSettings", "float", "bending_damping")) {
-		Object *ob;
-		ModifierData *md;
-		for (ob = main->object.first; ob; ob = ob->id.next) {
-			for (md = ob->modifiers.first; md; md = md->next) {
-				if (md->type == eModifierType_Cloth) {
-					ClothModifierData *clmd = (ClothModifierData *)md;
-					clmd->sim_parms->bending_damping = 0.5f;
-				}
-				else if (md->type == eModifierType_ParticleSystem) {
-					ParticleSystemModifierData *pmd = (ParticleSystemModifierData *)md;
-					if (pmd->psys->clmd) {
-						pmd->psys->clmd->sim_parms->bending_damping = 0.5f;
+	if (!MAIN_VERSION_ATLEAST(main, 273, 3)) {
+		ParticleSettings *part;
+		for (part = main->particle.first; part; part = part->id.next) {
+			if (part->clumpcurve)
+				part->child_flag |= PART_CHILD_USE_CLUMP_CURVE;
+			if (part->roughcurve)
+				part->child_flag |= PART_CHILD_USE_ROUGH_CURVE;
+		}
+	}
+
+	if (!MAIN_VERSION_ATLEAST(main, 273, 6)) {
+		if (!DNA_struct_elem_find(fd->filesdna, "ClothSimSettings", "float", "bending_damping")) {
+			Object *ob;
+			ModifierData *md;
+			for (ob = main->object.first; ob; ob = ob->id.next) {
+				for (md = ob->modifiers.first; md; md = md->next) {
+					if (md->type == eModifierType_Cloth) {
+						ClothModifierData *clmd = (ClothModifierData *)md;
+						clmd->sim_parms->bending_damping = 0.5f;
+					}
+					else if (md->type == eModifierType_ParticleSystem) {
+						ParticleSystemModifierData *pmd = (ParticleSystemModifierData *)md;
+						if (pmd->psys->clmd) {
+							pmd->psys->clmd->sim_parms->bending_damping = 0.5f;
+						}
 					}
 				}
 			}
 		}
-	}
 
-	if (!DNA_struct_elem_find(fd->filesdna, "ParticleSettings", "float", "clump_noise_size")) {
-		ParticleSettings *part;
-		for (part = main->particle.first; part; part = part->id.next) {
-			part->clump_noise_size = 1.0f;
+		if (!DNA_struct_elem_find(fd->filesdna, "ParticleSettings", "float", "clump_noise_size")) {
+			ParticleSettings *part;
+			for (part = main->particle.first; part; part = part->id.next) {
+				part->clump_noise_size = 1.0f;
+			}
 		}
-	}
 
-	if (!DNA_struct_elem_find(fd->filesdna, "ParticleSettings", "int", "kink_extra_steps")) {
-		ParticleSettings *part;
-		for (part = main->particle.first; part; part = part->id.next) {
-			part->kink_extra_steps = 4;
+		if (!DNA_struct_elem_find(fd->filesdna, "ParticleSettings", "int", "kink_extra_steps")) {
+			ParticleSettings *part;
+			for (part = main->particle.first; part; part = part->id.next) {
+				part->kink_extra_steps = 4;
+			}
 		}
-	}
 
-	if (!DNA_struct_elem_find(fd->filesdna, "MTex", "float", "kinkampfac")) {
-		ParticleSettings *part;
-		for (part = main->particle.first; part; part = part->id.next) {
-			int a;
-			for (a = 0; a < MAX_MTEX; a++) {
-				MTex *mtex = part->mtex[a];
-				if (mtex) {
-					mtex->kinkampfac = 1.0f;
+		if (!DNA_struct_elem_find(fd->filesdna, "MTex", "float", "kinkampfac")) {
+			ParticleSettings *part;
+			for (part = main->particle.first; part; part = part->id.next) {
+				int a;
+				for (a = 0; a < MAX_MTEX; a++) {
+					MTex *mtex = part->mtex[a];
+					if (mtex) {
+						mtex->kinkampfac = 1.0f;
+					}
 				}
 			}
 		}
-	}
 
-	if (!MAIN_VERSION_ATLEAST(main, 273, 3)) {
-		ParticleSettings *part;
-		for (part = main->particle.first; part; part = part->id.next) {
-			if (part->clumpcurve)
-				part->child_flag |= PART_CHILD_USE_CLUMP_CURVE;
-			if (part->roughcurve)
-				part->child_flag |= PART_CHILD_USE_ROUGH_CURVE;
+		if (!DNA_struct_elem_find(fd->filesdna, "HookModifierData", "char", "flag")) {
+			Object *ob;
+
+			for (ob = main->object.first; ob; ob = ob->id.next) {
+				ModifierData *md;
+				for (md = ob->modifiers.first; md; md = md->next) {
+					if (md->type == eModifierType_Hook) {
+						HookModifierData *hmd = (HookModifierData *)md;
+						hmd->falloff_type = eHook_Falloff_InvSquare;
+					}
+				}
+			}
+		}
+
+		if (!DNA_struct_elem_find(fd->filesdna, "NodePlaneTrackDeformData", "char", "flag")) {
+			FOREACH_NODETREE(main, ntree, id) {
+				if (ntree->type == NTREE_COMPOSIT) {
+					bNode *node;
+					for (node = ntree->nodes.first; node; node = node->next) {
+						if (ELEM(node->type, CMP_NODE_PLANETRACKDEFORM)) {
+							NodePlaneTrackDeformData *data = node->storage;
+							data->flag = 0;
+							data->motion_blur_samples = 16;
+							data->motion_blur_shutter = 0.5f;
+						}
+					}
+				}
+			}
+			FOREACH_NODETREE_END
 		}
 	}
 }
diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c
index eff38d3565f..6a7c97f0ae7 100644
--- a/source/blender/blenloader/intern/writefile.c
+++ b/source/blender/blenloader/intern/writefile.c
@@ -1485,6 +1485,10 @@ static void write_modifiers(WriteData *wd, ListBase *modbase)
 		if (md->type==eModifierType_Hook) {
 			HookModifierData *hmd = (HookModifierData*) md;
 			
+			if (hmd->curfalloff) {
+				write_curvemapping(wd, hmd->curfalloff);
+			}
+
 			writedata(wd, DATA, sizeof(int)*hmd->totindex, hmd->indexar);
 		}
 		else if (md->type==eModifierType_Cloth) {
diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c
index 95d40bfc0c6..9a2869b64ef 100644
--- a/source/blender/bmesh/intern/bmesh_mesh.c
+++ b/source/blender/bmesh/intern/bmesh_mesh.c
@@ -34,10 +34,12 @@
 #include "BLI_linklist_stack.h"
 #include "BLI_listbase.h"
 #include "BLI_math.h"
+#include "BLI_stack.h"
 #include "BLI_utildefines.h"
 
 #include "BKE_cdderivedmesh.h"
 #include "BKE_editmesh.h"
+#include "BKE_mesh.h"
 #include "BKE_multires.h"
 
 #include "intern/bmesh_private.h"
@@ -438,7 +440,8 @@ void BM_verts_calc_normal_vcos(BMesh *bm, const float (*fnos)[3], const float (*
 static void bm_mesh_edges_sharp_tag(BMesh *bm, const float (*vnos)[3], const float (*fnos)[3], float split_angle,
                                     float (*r_lnos)[3])
 {
-	BMIter eiter;
+	BMIter eiter, viter;
+	BMVert *v;
 	BMEdge *e;
 	int i;
 
@@ -450,15 +453,18 @@ static void bm_mesh_edges_sharp_tag(BMesh *bm, const float (*vnos)[3], const flo
 
 	{
 		char htype = BM_LOOP;
-		if (vnos) {
-			htype |= BM_VERT;
-		}
 		if (fnos) {
 			htype |= BM_FACE;
 		}
 		BM_mesh_elem_index_ensure(bm, htype);
 	}
 
+	/* Clear all vertices' tags (means they are all smooth for now). */
+	BM_ITER_MESH_INDEX (v, &viter, bm, BM_VERTS_OF_MESH, i) {
+		BM_elem_index_set(v, i); /* set_inline */
+		BM_elem_flag_disable(v, BM_ELEM_TAG);
+	}
+
 	/* This first loop checks which edges are actually smooth, and pre-populate lnos with vnos (as if they were
 	 * all smooth).
 	 */
@@ -481,13 +487,13 @@ static void bm_mesh_edges_sharp_tag(BMesh *bm, const float (*vnos)[3], const flo
 			 * If the angle between both its polys' normals is below split_angle value,
 			 * and it is tagged as such,
 			 * and both its faces are smooth,
-			 * and both its faces have compatible (non-flipped) normals, i.e. both loops on the same edge do not share
-			 *     the same vertex.
+			 * and both its faces have compatible (non-flipped) normals,
+			 * i.e. both loops on the same edge do not share the same vertex.
 			 */
 			if (is_angle_smooth &&
-			    BM_elem_flag_test_bool(e, BM_ELEM_SMOOTH) &&
-			    BM_elem_flag_test_bool(l_a->f, BM_ELEM_SMOOTH) &&
-			    BM_elem_flag_test_bool(l_b->f, BM_ELEM_SMOOTH) &&
+			    BM_elem_flag_test(e, BM_ELEM_SMOOTH) &&
+			    BM_elem_flag_test(l_a->f, BM_ELEM_SMOOTH) &&
+			    BM_elem_flag_test(l_b->f, BM_ELEM_SMOOTH) &&
 			    l_a->v != l_b->v)
 			{
 				const float *no;
@@ -499,20 +505,40 @@ static void bm_mesh_edges_sharp_tag(BMesh *bm, const float (*vnos)[3], const flo
 				no = vnos ? vnos[BM_elem_index_get(l_b->v)] : l_b->v->no;
 				copy_v3_v3(r_lnos[BM_elem_index_get(l_b)], no);
 			}
+			else {
+				/* Sharp edge, tag its verts as such. */
+				BM_elem_flag_enable(e->v1, BM_ELEM_TAG);
+				BM_elem_flag_enable(e->v2, BM_ELEM_TAG);
+			}
+		}
+		else {
+			/* Sharp edge, tag its verts as such. */
+			BM_elem_flag_enable(e->v1, BM_ELEM_TAG);
+			BM_elem_flag_enable(e->v2, BM_ELEM_TAG);
 		}
 	}
 
-	bm->elem_index_dirty &= ~BM_EDGE;
+	bm->elem_index_dirty &= ~(BM_EDGE | BM_VERT);
 }
 
-/* BMesh version of BKE_mesh_normals_loop_split() in mesh_evaluate.c */
-static void bm_mesh_loops_calc_normals(BMesh *bm, const float (*vcos)[3], const float (*fnos)[3], float (*r_lnos)[3])
+/* BMesh version of BKE_mesh_normals_loop_split() in mesh_evaluate.c
+ * Will use first clnors_data array, and fallback to cd_loop_clnors_offset (use NULL and -1 to not use clnors). */
+static void bm_mesh_loops_calc_normals(
+        BMesh *bm, const float (*vcos)[3], const float (*fnos)[3], float (*r_lnos)[3],
+        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2], const int cd_loop_clnors_offset)
 {
 	BMIter fiter;
 	BMFace *f_curr;
+	const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
+
+	MLoopNorSpaceArray _lnors_spacearr = {NULL};
 
 	/* Temp normal stack. */
 	BLI_SMALLSTACK_DECLARE(normal, float *);
+	/* Temp clnors stack. */
+	BLI_SMALLSTACK_DECLARE(clnors, short *);
+	/* Temp edge vectors stack, only used when computing lnor spacearr. */
+	BLI_Stack *edge_vectors = NULL;
 
 	{
 		char htype = BM_LOOP;
@@ -525,6 +551,15 @@ static void bm_mesh_loops_calc_normals(BMesh *bm, const float (*vcos)[3], const
 		BM_mesh_elem_index_ensure(bm, htype);
 	}
 
+	if (!r_lnors_spacearr && has_clnors) {
+		/* We need to compute lnor spacearr if some custom lnor data are given to us! */
+		r_lnors_spacearr = &_lnors_spacearr;
+	}
+	if (r_lnors_spacearr) {
+		BKE_lnor_spacearr_init(r_lnors_spacearr, bm->totloop);
+		edge_vectors = BLI_stack_new(sizeof(float[3]), __func__);
+	}
+
 	/* We now know edges that can be smoothed (they are tagged), and edges that will be hard (they aren't).
 	 * Now, time to generate the normals.
 	 */
@@ -533,8 +568,10 @@ static void bm_mesh_loops_calc_normals(BMesh *bm, const float (*vcos)[3], const
 
 		l_curr = l_first = BM_FACE_FIRST_LOOP(f_curr);
 		do {
-			if (BM_elem_flag_test_bool(l_curr->e, BM_ELEM_TAG)) {
-				/* A smooth edge.
+			if (BM_elem_flag_test(l_curr->e, BM_ELEM_TAG) &&
+			    (!r_lnors_spacearr || BM_elem_flag_test(l_curr->v, BM_ELEM_TAG)))
+			{
+				/* A smooth edge, and we are not generating lnors_spacearr, or the related vertex is sharp.
 				 * We skip it because it is either:
 				 * - in the middle of a 'smooth fan' already computed (or that will be as soon as we hit
 				 *   one of its ends, i.e. one of its two sharp edges), or...
@@ -542,12 +579,45 @@ static void bm_mesh_loops_calc_normals(BMesh *bm, const float (*vcos)[3], const
 				 *   are just fine!
 				 */
 			}
-			else if (!BM_elem_flag_test_bool(l_curr->prev->e, BM_ELEM_TAG)) {
+			else if (!BM_elem_flag_test(l_curr->e, BM_ELEM_TAG) &&
+			         !BM_elem_flag_test(l_curr->prev->e, BM_ELEM_TAG))
+			{
 				/* Simple case (both edges around that vertex are sharp in related polygon),
 				 * this vertex just takes its poly normal.
 				 */
+				const int l_curr_index = BM_elem_index_get(l_curr);
 				const float *no = fnos ? fnos[BM_elem_index_get(f_curr)] : f_curr->no;
-				copy_v3_v3(r_lnos[BM_elem_index_get(l_curr)], no);
+				copy_v3_v3(r_lnos[l_curr_index], no);
+
+				/* If needed, generate this (simple!) lnor space. */
+				if (r_lnors_spacearr) {
+					float vec_curr[3], vec_prev[3];
+					MLoopNorSpace *lnor_space = BKE_lnor_space_create(r_lnors_spacearr);
+
+					{
+						const BMVert *v_pivot = l_curr->v;
+						const float *co_pivot = vcos ? vcos[BM_elem_index_get(v_pivot)] : v_pivot->co;
+						const BMVert *v_1 = BM_edge_other_vert(l_curr->e, v_pivot);
+						const float *co_1 = vcos ? vcos[BM_elem_index_get(v_1)] : v_1->co;
+						const BMVert *v_2 = BM_edge_other_vert(l_curr->prev->e, v_pivot);
+						const float *co_2 = vcos ? vcos[BM_elem_index_get(v_2)] : v_2->co;
+
+						sub_v3_v3v3(vec_curr, co_1, co_pivot);
+						normalize_v3(vec_curr);
+						sub_v3_v3v3(vec_prev, co_2, co_pivot);
+						normalize_v3(vec_prev);
+					}
+
+					BKE_lnor_space_define(lnor_space, r_lnos[l_curr_index], vec_curr, vec_prev, NULL);
+					/* We know there is only one loop in this space, no need to create a linklist in this case... */
+					BKE_lnor_space_add_loop(r_lnors_spacearr, lnor_space, l_curr_index, false);
+
+					if (has_clnors) {
+						short (*clnor)[2] = clnors_data ? &clnors_data[l_curr_index] :
+						                                  BM_ELEM_CD_GET_VOID_P(l_curr, cd_loop_clnors_offset);
+						BKE_lnor_space_custom_data_to_normal(lnor_space, *clnor, r_lnos[l_curr_index]);
+					}
+				}
 			}
 			/* We *do not need* to check/tag loops as already computed!
 			 * Due to the fact a loop only links to one of its two edges, a same fan *will never be walked more than
@@ -567,13 +637,26 @@ static void bm_mesh_loops_calc_normals(BMesh *bm, const float (*vcos)[3], const
 				 */
 				BMVert *v_pivot = l_curr->v;
 				BMEdge *e_next;
+				const BMEdge *e_org = l_curr->e;
 				BMLoop *lfan_pivot, *lfan_pivot_next;
+				int lfan_pivot_index;
 				float lnor[3] = {0.0f, 0.0f, 0.0f};
-				float vec_curr[3], vec_next[3];
+				float vec_curr[3], vec_next[3], vec_org[3];
+
+				/* We validate clnors data on the fly - cheapest way to do! */
+				int clnors_avg[2] = {0, 0};
+				short (*clnor_ref)[2] = NULL;
+				int clnors_nbr = 0;
+				bool clnors_invalid = false;
 
 				const float *co_pivot = vcos ? vcos[BM_elem_index_get(v_pivot)] : v_pivot->co;
 
+				MLoopNorSpace *lnor_space = r_lnors_spacearr ? BKE_lnor_space_create(r_lnors_spacearr) : NULL;
+
+				BLI_assert((edge_vectors == NULL) || BLI_stack_is_empty(edge_vectors));
+
 				lfan_pivot = l_curr;
+				lfan_pivot_index = BM_elem_index_get(lfan_pivot);
 				e_next = lfan_pivot->e;  /* Current edge here, actually! */
 
 				/* Only need to compute previous edge's vector once, then we can just reuse old current one! */
@@ -581,8 +664,13 @@ static void bm_mesh_loops_calc_normals(BMesh *bm, const float (*vcos)[3], const
 					const BMVert *v_2 = BM_edge_other_vert(e_next, v_pivot);
 					const float *co_2 = vcos ? vcos[BM_elem_index_get(v_2)] : v_2->co;
 
-					sub_v3_v3v3(vec_curr, co_2, co_pivot);
-					normalize_v3(vec_curr);
+					sub_v3_v3v3(vec_org, co_2, co_pivot);
+					normalize_v3(vec_org);
+					copy_v3_v3(vec_curr, vec_org);
+
+					if (r_lnors_spacearr) {
+						BLI_stack_push(edge_vectors, vec_org);
+					}
 				}
 
 				while (true) {
@@ -617,12 +705,38 @@ static void bm_mesh_loops_calc_normals(BMesh *bm, const float (*vcos)[3], const
 						const float *no = fnos ? fnos[BM_elem_index_get(f)] : f->no;
 						/* Accumulate */
 						madd_v3_v3fl(lnor, no, fac);
+
+						if (has_clnors) {
+							/* Accumulate all clnors, if they are not all equal we have to fix that! */
+							short (*clnor)[2] = clnors_data ? &clnors_data[lfan_pivot_index] :
+							                                  BM_ELEM_CD_GET_VOID_P(lfan_pivot, cd_loop_clnors_offset);
+							if (clnors_nbr) {
+								clnors_invalid |= ((*clnor_ref)[0] != (*clnor)[0] || (*clnor_ref)[1] != (*clnor)[1]);
+							}
+							else {
+								clnor_ref = clnor;
+							}
+							clnors_avg[0] += (*clnor)[0];
+							clnors_avg[1] += (*clnor)[1];
+							clnors_nbr++;
+							/* We store here a pointer to all custom lnors processed. */
+							BLI_SMALLSTACK_PUSH(clnors, (short *)*clnor);
+						}
 					}
 
 					/* We store here a pointer to all loop-normals processed. */
-					BLI_SMALLSTACK_PUSH(normal, (float *)r_lnos[BM_elem_index_get(lfan_pivot)]);
+					BLI_SMALLSTACK_PUSH(normal, (float *)r_lnos[lfan_pivot_index]);
+
+					if (r_lnors_spacearr) {
+						/* Assign current lnor space to current 'vertex' loop. */
+						BKE_lnor_space_add_loop(r_lnors_spacearr, lnor_space, lfan_pivot_index, true);
+						if (e_next != e_org) {
+							/* We store here all edges-normalized vectors processed. */
+							BLI_stack_push(edge_vectors, vec_next);
+						}
+					}
 
-					if (!BM_elem_flag_test_bool(e_next, BM_ELEM_TAG)) {
+					if (!BM_elem_flag_test(e_next, BM_ELEM_TAG) || (e_next == e_org)) {
 						/* Next edge is sharp, we have finished with this fan of faces around this vert! */
 						break;
 					}
@@ -631,26 +745,78 @@ static void bm_mesh_loops_calc_normals(BMesh *bm, const float (*vcos)[3], const
 					copy_v3_v3(vec_curr, vec_next);
 					/* Next pivot loop to current one. */
 					lfan_pivot = lfan_pivot_next;
+					lfan_pivot_index = BM_elem_index_get(lfan_pivot);
 				}
 
-				/* In case we get a zero normal here, just use vertex normal already set! */
-				if (LIKELY(normalize_v3(lnor) != 0.0f)) {
-					/* Copy back the final computed normal into all related loop-normals. */
-					float *nor;
-					while ((nor = BLI_SMALLSTACK_POP(normal))) {
-						copy_v3_v3(nor, lnor);
+				{
+					float lnor_len = normalize_v3(lnor);
+
+					/* If we are generating lnor spacearr, we can now define the one for this fan. */
+					if (r_lnors_spacearr) {
+						if (UNLIKELY(lnor_len == 0.0f)) {
+							/* Use vertex normal as fallback! */
+							copy_v3_v3(lnor, r_lnos[lfan_pivot_index]);
+							lnor_len = 1.0f;
+						}
+
+						BKE_lnor_space_define(lnor_space, lnor, vec_org, vec_next, edge_vectors);
+
+						if (has_clnors) {
+							if (clnors_invalid) {
+								short *clnor;
+
+								clnors_avg[0] /= clnors_nbr;
+								clnors_avg[1] /= clnors_nbr;
+								/* Fix/update all clnors of this fan with computed average value. */
+								printf("Invalid clnors in this fan!\n");
+								while ((clnor = BLI_SMALLSTACK_POP(clnors))) {
+									//print_v2("org clnor", clnor);
+									clnor[0] = (short)clnors_avg[0];
+									clnor[1] = (short)clnors_avg[1];
+								}
+								//print_v2("new clnors", clnors_avg);
+							}
+							else {
+								/* We still have to consume the stack! */
+								while (BLI_SMALLSTACK_POP(clnors));
+							}
+							BKE_lnor_space_custom_data_to_normal(lnor_space, *clnor_ref, lnor);
+						}
+					}
+
+					/* In case we get a zero normal here, just use vertex normal already set! */
+					if (LIKELY(lnor_len != 0.0f)) {
+						/* Copy back the final computed normal into all related loop-normals. */
+						float *nor;
+
+						while ((nor = BLI_SMALLSTACK_POP(normal))) {
+							copy_v3_v3(nor, lnor);
+						}
+					}
+					else {
+						/* We still have to consume the stack! */
+						while (BLI_SMALLSTACK_POP(normal));
 					}
 				}
-				else {
-					/* We still have to clear the stack! */
-					while (BLI_SMALLSTACK_POP(normal));
+
+				/* Tag related vertex as sharp, to avoid fanning around it again (in case it was a smooth one). */
+				if (r_lnors_spacearr) {
+					BM_elem_flag_enable(l_curr->v, BM_ELEM_TAG);
 				}
 			}
 		} while ((l_curr = l_curr->next) != l_first);
 	}
+
+	if (r_lnors_spacearr) {
+		BLI_stack_free(edge_vectors);
+		if (r_lnors_spacearr == &_lnors_spacearr) {
+			BKE_lnor_spacearr_free(r_lnors_spacearr);
+		}
+	}
 }
 
-static void bm_mesh_loops_from_vert_normals(BMesh *bm, const float (*vnos)[3], float (*r_lnos)[3])
+static void bm_mesh_loops_calc_normals_no_autosmooth(
+        BMesh *bm, const float (*vnos)[3], const float (*fnos)[3], float (*r_lnos)[3])
 {
 	BMIter fiter;
 	BMFace *f_curr;
@@ -660,15 +826,20 @@ static void bm_mesh_loops_from_vert_normals(BMesh *bm, const float (*vnos)[3], f
 		if (vnos) {
 			htype |= BM_VERT;
 		}
+		if (fnos) {
+			htype |= BM_FACE;
+		}
 		BM_mesh_elem_index_ensure(bm, htype);
 	}
 
 	BM_ITER_MESH (f_curr, &fiter, bm, BM_FACES_OF_MESH) {
 		BMLoop *l_curr, *l_first;
+		const bool is_face_flat = !BM_elem_flag_test(f_curr, BM_ELEM_SMOOTH);
 
 		l_curr = l_first = BM_FACE_FIRST_LOOP(f_curr);
 		do {
-			const float *no = vnos ? vnos[BM_elem_index_get(l_curr->v)] : l_curr->v->no;
+			const float *no = is_face_flat ? (fnos ? fnos[BM_elem_index_get(f_curr)] : f_curr->no) :
+			                                 (vnos ? vnos[BM_elem_index_get(l_curr->v)] : l_curr->v->no);
 			copy_v3_v3(r_lnos[BM_elem_index_get(l_curr)], no);
 
 		} while ((l_curr = l_curr->next) != l_first);
@@ -682,17 +853,23 @@ static void bm_mesh_loops_from_vert_normals(BMesh *bm, const float (*vnos)[3], f
  * Updates the loop normals of a mesh. Assumes vertex and face normals are valid (else call BM_mesh_normals_update()
  * first)!
  */
-void BM_mesh_loop_normals_update(BMesh *bm, const bool use_split_normals, const float split_angle, float (*r_lnos)[3])
+void BM_mesh_loop_normals_update(
+        BMesh *bm, const bool use_split_normals, const float split_angle, float (*r_lnos)[3],
+        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2], const int cd_loop_clnors_offset)
 {
+	const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
+
 	if (use_split_normals) {
-		/* Tag smooth edges and set lnos from vnos when they might be completely smooth... */
-		bm_mesh_edges_sharp_tag(bm, NULL, NULL, split_angle, r_lnos);
+	        /* Tag smooth edges and set lnos from vnos when they might be completely smooth...
+	         * When using custom loop normals, disable the angle feature! */
+	        bm_mesh_edges_sharp_tag(bm, NULL, NULL, has_clnors ? (float)M_PI : split_angle, r_lnos);
 
-		/* Finish computing lnos by accumulating face normals in each fan of faces defined by sharp edges. */
-		bm_mesh_loops_calc_normals(bm, NULL, NULL, r_lnos);
+	        /* Finish computing lnos by accumulating face normals in each fan of faces defined by sharp edges. */
+	        bm_mesh_loops_calc_normals(bm, NULL, NULL, r_lnos, r_lnors_spacearr, clnors_data, cd_loop_clnors_offset);
 	}
 	else {
-		bm_mesh_loops_from_vert_normals(bm, NULL, r_lnos);
+		BLI_assert(!r_lnors_spacearr);
+		bm_mesh_loops_calc_normals_no_autosmooth(bm, NULL, NULL, r_lnos);
 	}
 }
 #endif
@@ -703,18 +880,24 @@ void BM_mesh_loop_normals_update(BMesh *bm, const bool use_split_normals, const
  * Compute split normals, i.e. vertex normals associated with each poly (hence 'loop normals').
  * Useful to materialize sharp edges (or non-smooth faces) without actually modifying the geometry (splitting edges).
  */
-void BM_loops_calc_normal_vcos(BMesh *bm, const float (*vcos)[3], const float (*vnos)[3], const float (*fnos)[3],
-                               const bool use_split_normals, const float split_angle, float (*r_lnos)[3])
+void BM_loops_calc_normal_vcos(
+        BMesh *bm, const float (*vcos)[3], const float (*vnos)[3], const float (*fnos)[3],
+        const bool use_split_normals, const float split_angle, float (*r_lnos)[3],
+        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2], const int cd_loop_clnors_offset)
 {
+	const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
+
 	if (use_split_normals) {
-		/* Tag smooth edges and set lnos from vnos when they might be completely smooth... */
-		bm_mesh_edges_sharp_tag(bm, vnos, fnos, split_angle, r_lnos);
+		/* Tag smooth edges and set lnos from vnos when they might be completely smooth...
+		 * When using custom loop normals, disable the angle feature! */
+		bm_mesh_edges_sharp_tag(bm, vnos, fnos, has_clnors ? (float)M_PI : split_angle, r_lnos);
 
 		/* Finish computing lnos by accumulating face normals in each fan of faces defined by sharp edges. */
-		bm_mesh_loops_calc_normals(bm, vcos, fnos, r_lnos);
+		bm_mesh_loops_calc_normals(bm, vcos, fnos, r_lnos, r_lnors_spacearr, clnors_data, cd_loop_clnors_offset);
 	}
 	else {
-		bm_mesh_loops_from_vert_normals(bm, vnos, r_lnos);
+		BLI_assert(!r_lnors_spacearr);
+		bm_mesh_loops_calc_normals_no_autosmooth(bm, vnos, fnos, r_lnos);
 	}
 }
 
diff --git a/source/blender/bmesh/intern/bmesh_mesh.h b/source/blender/bmesh/intern/bmesh_mesh.h
index c2ac2c40534..bac5da8347e 100644
--- a/source/blender/bmesh/intern/bmesh_mesh.h
+++ b/source/blender/bmesh/intern/bmesh_mesh.h
@@ -28,6 +28,7 @@
  */
 
 struct BMAllocTemplate;
+struct MLoopNorSpaceArray;
 
 void   BM_mesh_elem_toolflags_ensure(BMesh *bm);
 void   BM_mesh_elem_toolflags_clear(BMesh *bm);
@@ -39,8 +40,10 @@ void   BM_mesh_clear(BMesh *bm);
 
 void BM_mesh_normals_update(BMesh *bm);
 void BM_verts_calc_normal_vcos(BMesh *bm, const float (*fnos)[3], const float (*vcos)[3], float (*vnos)[3]);
-void BM_loops_calc_normal_vcos(BMesh *bm, const float (*vcos)[3], const float (*vnos)[3], const float (*pnos)[3],
-                               const bool use_split_normals, const float split_angle, float (*r_lnos)[3]);
+void BM_loops_calc_normal_vcos(
+        BMesh *bm, const float (*vcos)[3], const float (*vnos)[3], const float (*pnos)[3],
+        const bool use_split_normals, const float split_angle, float (*r_lnos)[3],
+        struct MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2], const int cd_loop_clnors_offset);
 
 void bmesh_edit_begin(BMesh *bm, const BMOpTypeFlag type_flag);
 void bmesh_edit_end(BMesh *bm, const BMOpTypeFlag type_flag);
diff --git a/source/blender/collada/ControllerExporter.cpp b/source/blender/collada/ControllerExporter.cpp
index 25fd9c81535..16c3f68bca4 100644
--- a/source/blender/collada/ControllerExporter.cpp
+++ b/source/blender/collada/ControllerExporter.cpp
@@ -473,7 +473,7 @@ static float get_property(Bone *bone, const char *key, float def)
 	if (bone->prop) {
 		IDProperty *property = IDP_GetPropertyFromGroup(bone->prop, key);
 		if (property) {
-			switch(property->type) {
+			switch (property->type) {
 				case IDP_INT:
 					result = (float)(IDP_Int(property));
 					break;
diff --git a/source/blender/collada/EffectExporter.cpp b/source/blender/collada/EffectExporter.cpp
index 1f0e00b3bd6..13dc1eda580 100644
--- a/source/blender/collada/EffectExporter.cpp
+++ b/source/blender/collada/EffectExporter.cpp
@@ -133,7 +133,7 @@ void EffectsExporter::writeTextures(COLLADASW::EffectProfile &ep,
 	if (!ima) return;
 
 	// color
-	if (t->mapto & (MAP_COL | MAP_COLSPEC)) {
+	if (t->mapto & MAP_COL) {
 		ep.setDiffuse(createTexture(ima, uvname, sampler), false, "diffuse");
 	}
 	// ambient
@@ -141,7 +141,7 @@ void EffectsExporter::writeTextures(COLLADASW::EffectProfile &ep,
 		ep.setAmbient(createTexture(ima, uvname, sampler), false, "ambient");
 	}
 	// specular
-	if (t->mapto & MAP_SPEC) {
+	if (t->mapto & (MAP_SPEC | MAP_COLSPEC)) {
 		ep.setSpecular(createTexture(ima, uvname, sampler), false, "specular");
 	}
 	// emission
@@ -263,7 +263,7 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
 	COLLADASW::Sampler samplers[MAX_MTEX];
 	//COLLADASW::Surface surfaces[MAX_MTEX];
 	//void *samp_surf[MAX_MTEX][2];
-	void *samp_surf[MAX_MTEX][1];
+	void *samp_surf[MAX_MTEX];
 	
 	// image to index to samp_surf map
 	// samp_surf[index] stores 2 pointers, sampler and surface
@@ -302,7 +302,7 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
 			//surfaces[a] = surface;
 			
 			// store pointers so they can be used later when we create <texture>s
-			samp_surf[b][0] = &samplers[a];
+			samp_surf[b] = &samplers[a];
 			//samp_surf[b][1] = &surfaces[a];
 			
 			im_samp_map[key] = b;
@@ -349,7 +349,7 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
 														   key + COLLADASW::Sampler::SURFACE_SID_SUFFIX);
 								sampler.setImageId(key);
 								samplers[a] = sampler;
-								samp_surf[b][0] = &samplers[a];
+								samp_surf[b] = &samplers[a];
 								im_samp_map[key] = b;
 								b++;
 								a++;
@@ -380,7 +380,7 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
 		key = translate_id(key);
 		int i = im_samp_map[key];
 		std::string uvname = strlen(t->uvname) ? t->uvname : active_uv;
-		COLLADASW::Sampler *sampler = (COLLADASW::Sampler *)samp_surf[i][0];
+		COLLADASW::Sampler *sampler = (COLLADASW::Sampler *)samp_surf[i];
 		writeTextures(ep, key, sampler, t, ima, uvname);
 	}
 
@@ -392,7 +392,7 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
 			std::string key(id_name(ima));
 			key = translate_id(key);
 			int i = im_samp_map[key];
-			COLLADASW::Sampler *sampler = (COLLADASW::Sampler *)samp_surf[i][0];
+			COLLADASW::Sampler *sampler = (COLLADASW::Sampler *)samp_surf[i];
 			ep.setDiffuse(createTexture(ima, active_uv, sampler), false, "diffuse");
 		}
 	}
diff --git a/source/blender/collada/MeshImporter.cpp b/source/blender/collada/MeshImporter.cpp
index 3c6c90068de..02e78b9bc45 100644
--- a/source/blender/collada/MeshImporter.cpp
+++ b/source/blender/collada/MeshImporter.cpp
@@ -818,7 +818,7 @@ void MeshImporter::bmeshConversion()
 			Mesh *me = (*m).second;
 			BKE_mesh_tessface_clear(me);
 			BKE_mesh_calc_normals(me);
-			//BKE_mesh_validate(me, 1);
+			/* BKE_mesh_validate(me, true, true); */
 		}
 	}
 }
diff --git a/source/blender/compositor/nodes/COM_PlaneTrackDeformNode.cpp b/source/blender/compositor/nodes/COM_PlaneTrackDeformNode.cpp
index 9b69bc5a46e..379b9f193e8 100644
--- a/source/blender/compositor/nodes/COM_PlaneTrackDeformNode.cpp
+++ b/source/blender/compositor/nodes/COM_PlaneTrackDeformNode.cpp
@@ -54,6 +54,10 @@ void PlaneTrackDeformNode::convertToOperations(NodeConverter &converter, const C
 	warp_image_operation->setTrackingObject(data->tracking_object);
 	warp_image_operation->setPlaneTrackName(data->plane_track_name);
 	warp_image_operation->setFramenumber(frame_number);
+	if (data->flag & CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR) {
+		warp_image_operation->setMotionBlurSamples(data->motion_blur_samples);
+		warp_image_operation->setMotionBlurShutter(data->motion_blur_shutter);
+	}
 	converter.addOperation(warp_image_operation);
 	
 	converter.mapInputSocket(input_image, warp_image_operation->getInputSocket(0));
@@ -64,6 +68,10 @@ void PlaneTrackDeformNode::convertToOperations(NodeConverter &converter, const C
 	plane_mask_operation->setTrackingObject(data->tracking_object);
 	plane_mask_operation->setPlaneTrackName(data->plane_track_name);
 	plane_mask_operation->setFramenumber(frame_number);
+	if (data->flag & CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR) {
+		plane_mask_operation->setMotionBlurSamples(data->motion_blur_samples);
+		plane_mask_operation->setMotionBlurShutter(data->motion_blur_shutter);
+	}
 	converter.addOperation(plane_mask_operation);
 	
 	converter.mapOutputSocket(output_plane, plane_mask_operation->getOutputSocket());
diff --git a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cpp b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cpp
index fe272000b6e..fb8730c9fa0 100644
--- a/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cpp
+++ b/source/blender/compositor/operations/COM_PlaneCornerPinOperation.cpp
@@ -135,7 +135,7 @@ void *PlaneCornerPinMaskOperation::initializeTileData(rcti *rect)
 		                             getInputSocketReader(3) };
 		float corners[4][2];
 		readCornersFromSockets(rect, readers, corners);
-		calculateCorners(corners, true);
+		calculateCorners(corners, true, 0);
 		
 		m_corners_ready = true;
 	}
@@ -194,8 +194,7 @@ void *PlaneCornerPinWarpImageOperation::initializeTileData(rcti *rect)
 		                             getInputSocketReader(4) };
 		float corners[4][2];
 		readCornersFromSockets(rect, readers, corners);
-		calculateCorners(corners, true);
-		calculatePerspectiveMatrix();
+		calculateCorners(corners, true, 0);
 		
 		m_corners_ready = true;
 	}
diff --git a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cpp b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cpp
index c507b4cfa98..8133f392ac6 100644
--- a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cpp
+++ b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.cpp
@@ -56,36 +56,38 @@ PlaneDistortWarpImageOperation::PlaneDistortWarpImageOperation() :
 	this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE);
 	this->addOutputSocket(COM_DT_COLOR);
 	this->m_pixelReader = NULL;
+	this->m_motion_blur_samples = 1;
+	this->m_motion_blur_shutter = 0.5f;
 	this->setComplex(true);
 }
 
-void PlaneDistortWarpImageOperation::calculateCorners(const float corners[4][2], bool normalized)
+void PlaneDistortWarpImageOperation::calculateCorners(const float corners[4][2],
+                                                      bool normalized,
+                                                      int sample)
 {
+	BLI_assert(sample < this->m_motion_blur_samples);
+	const int width = this->m_pixelReader->getWidth();
+	const int height = this->m_pixelReader->getHeight();
+	float frame_corners[4][2] = {{0.0f, 0.0f},
+	                             {(float) width, 0.0f},
+	                             {(float) width, (float) height},
+	                             {0.0f, (float) height}};
+	MotionSample *sample_data = &this->m_samples[sample];
 	if (normalized) {
 		for (int i = 0; i < 4; i++) {
-			this->m_frameSpaceCorners[i][0] = corners[i][0] * this->getWidth();
-			this->m_frameSpaceCorners[i][1] = corners[i][1] * this->getHeight();
+			sample_data->frameSpaceCorners[i][0] = corners[i][0] * this->getWidth();
+			sample_data->frameSpaceCorners[i][1] = corners[i][1] * this->getHeight();
 		}
 	}
 	else {
 		for (int i = 0; i < 4; i++) {
-			this->m_frameSpaceCorners[i][0] = corners[i][0];
-			this->m_frameSpaceCorners[i][1] = corners[i][1];
+			sample_data->frameSpaceCorners[i][0] = corners[i][0];
+			sample_data->frameSpaceCorners[i][1] = corners[i][1];
 		}
 	}
-}
-
-void PlaneDistortWarpImageOperation::calculatePerspectiveMatrix()
-{
-	const int width = this->m_pixelReader->getWidth();
-	const int height = this->m_pixelReader->getHeight();
-	float frame_corners[4][2] = {{0.0f, 0.0f},
-	                             {(float) width, 0.0f},
-	                             {(float) width, (float) height},
-	                             {0.0f, (float) height}};
-	BKE_tracking_homography_between_two_quads(this->m_frameSpaceCorners,
+	BKE_tracking_homography_between_two_quads(sample_data->frameSpaceCorners,
 	                                          frame_corners,
-	                                          this->m_perspectiveMatrix);
+	                                          sample_data->perspectiveMatrix);
 }
 
 void PlaneDistortWarpImageOperation::initExecution()
@@ -100,35 +102,47 @@ void PlaneDistortWarpImageOperation::deinitExecution()
 
 void PlaneDistortWarpImageOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-	float xy[2] = {x, y};
 	float uv[2];
 	float deriv[2][2];
-
-	pixelTransform(xy, uv, deriv);
-
-	m_pixelReader->readFiltered(output, uv[0], uv[1], deriv[0], deriv[1], COM_PS_BILINEAR);
-}
-
-void PlaneDistortWarpImageOperation::pixelTransform(const float xy[2], float r_uv[2], float r_deriv[2][2])
-{
-	warpCoord(xy[0], xy[1], m_perspectiveMatrix, r_uv, r_deriv);
+	if (this->m_motion_blur_samples == 1) {
+		warpCoord(x, y, this->m_samples[0].perspectiveMatrix, uv, deriv);
+		m_pixelReader->readFiltered(output,
+		                            uv[0], uv[1],
+		                            deriv[0], deriv[1],
+		                            COM_PS_BILINEAR);
+	}
+	else {
+		zero_v4(output);
+		for (int sample = 0; sample < this->m_motion_blur_samples; ++sample) {
+			float color[4];
+			warpCoord(x, y, this->m_samples[sample].perspectiveMatrix, uv, deriv);
+			m_pixelReader->readFiltered(color,
+			                            uv[0], uv[1],
+			                            deriv[0], deriv[1],
+			                            COM_PS_BILINEAR);
+			add_v4_v4(output, color);
+		}
+		mul_v4_fl(output, 1.0f / (float)this->m_motion_blur_samples);
+	}
 }
 
 bool PlaneDistortWarpImageOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
 {
-	float UVs[4][2];
-	float deriv[2][2];
-
-	/* TODO(sergey): figure out proper way to do this. */
-	warpCoord(input->xmin - 2, input->ymin - 2, this->m_perspectiveMatrix, UVs[0], deriv);
-	warpCoord(input->xmax + 2, input->ymin - 2, this->m_perspectiveMatrix, UVs[1], deriv);
-	warpCoord(input->xmax + 2, input->ymax + 2, this->m_perspectiveMatrix, UVs[2], deriv);
-	warpCoord(input->xmin - 2, input->ymax + 2, this->m_perspectiveMatrix, UVs[3], deriv);
-
 	float min[2], max[2];
 	INIT_MINMAX2(min, max);
-	for (int i = 0; i < 4; i++) {
-		minmax_v2v2_v2(min, max, UVs[i]);
+
+	for (int sample = 0; sample < this->m_motion_blur_samples; ++sample) {
+		float UVs[4][2];
+		float deriv[2][2];
+		MotionSample *sample_data = &this->m_samples[sample];
+		/* TODO(sergey): figure out proper way to do this. */
+		warpCoord(input->xmin - 2, input->ymin - 2, sample_data->perspectiveMatrix, UVs[0], deriv);
+		warpCoord(input->xmax + 2, input->ymin - 2, sample_data->perspectiveMatrix, UVs[1], deriv);
+		warpCoord(input->xmax + 2, input->ymax + 2, sample_data->perspectiveMatrix, UVs[2], deriv);
+		warpCoord(input->xmin - 2, input->ymax + 2, sample_data->perspectiveMatrix, UVs[3], deriv);
+		for (int i = 0; i < 4; i++) {
+			minmax_v2v2_v2(min, max, UVs[i]);
+		}
 	}
 
 	rcti newInput;
@@ -151,20 +165,26 @@ PlaneDistortMaskOperation::PlaneDistortMaskOperation() :
 
 	/* Currently hardcoded to 8 samples. */
 	m_osa = 8;
+	this->m_motion_blur_samples = 1;
+	this->m_motion_blur_shutter = 0.5f;
 }
 
-void PlaneDistortMaskOperation::calculateCorners(const float corners[4][2], bool normalized)
+void PlaneDistortMaskOperation::calculateCorners(const float corners[4][2],
+                                                 bool normalized,
+                                                 int sample)
 {
+	BLI_assert(sample < this->m_motion_blur_samples);
+	MotionSample *sample_data = &this->m_samples[sample];
 	if (normalized) {
 		for (int i = 0; i < 4; i++) {
-			this->m_frameSpaceCorners[i][0] = corners[i][0] * this->getWidth();
-			this->m_frameSpaceCorners[i][1] = corners[i][1] * this->getHeight();
+			sample_data->frameSpaceCorners[i][0] = corners[i][0] * this->getWidth();
+			sample_data->frameSpaceCorners[i][1] = corners[i][1] * this->getHeight();
 		}
 	}
 	else {
 		for (int i = 0; i < 4; i++) {
-			this->m_frameSpaceCorners[i][0] = corners[i][0];
-			this->m_frameSpaceCorners[i][1] = corners[i][1];
+			sample_data->frameSpaceCorners[i][0] = corners[i][0];
+			sample_data->frameSpaceCorners[i][1] = corners[i][1];
 		}
 	}
 }
@@ -177,18 +197,44 @@ void PlaneDistortMaskOperation::initExecution()
 void PlaneDistortMaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
 	float point[2];
-
 	int inside_counter = 0;
-	for (int sample = 0; sample < this->m_osa; sample++) {
-		point[0] = x + this->m_jitter[sample][0];
-		point[1] = y + this->m_jitter[sample][1];
-
-		if (isect_point_tri_v2(point, this->m_frameSpaceCorners[0], this->m_frameSpaceCorners[1], this->m_frameSpaceCorners[2]) ||
-		    isect_point_tri_v2(point, this->m_frameSpaceCorners[0], this->m_frameSpaceCorners[2], this->m_frameSpaceCorners[3]))
+	if (this->m_motion_blur_samples == 1) {
+		MotionSample *sample_data = &this->m_samples[0];
+		for (int sample = 0; sample < this->m_osa; sample++) {
+			point[0] = x + this->m_jitter[sample][0];
+			point[1] = y + this->m_jitter[sample][1];
+			if (isect_point_tri_v2(point, sample_data->frameSpaceCorners[0],
+			                              sample_data->frameSpaceCorners[1],
+			                              sample_data->frameSpaceCorners[2]) ||
+			    isect_point_tri_v2(point, sample_data->frameSpaceCorners[0],
+			                              sample_data->frameSpaceCorners[2],
+			                              sample_data->frameSpaceCorners[3]))
+			{
+				inside_counter++;
+			}
+		}
+		output[0] = (float)inside_counter / this->m_osa;
+	}
+	else {
+		for (int motion_sample = 0;
+		     motion_sample < this->m_motion_blur_samples;
+		     ++motion_sample)
 		{
-			inside_counter++;
+			MotionSample *sample_data = &this->m_samples[motion_sample];
+			for (int osa_sample = 0; osa_sample < this->m_osa; ++osa_sample) {
+				point[0] = x + this->m_jitter[osa_sample][0];
+				point[1] = y + this->m_jitter[osa_sample][1];
+				if (isect_point_tri_v2(point, sample_data->frameSpaceCorners[0],
+				                              sample_data->frameSpaceCorners[1],
+				                              sample_data->frameSpaceCorners[2]) ||
+				    isect_point_tri_v2(point, sample_data->frameSpaceCorners[0],
+				                              sample_data->frameSpaceCorners[2],
+				                              sample_data->frameSpaceCorners[3]))
+				{
+					inside_counter++;
+				}
+			}
 		}
+		output[0] = (float)inside_counter / (this->m_osa * this->m_motion_blur_samples);
 	}
-
-	output[0] = (float) inside_counter / this->m_osa;
 }
diff --git a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h
index ee2874c6b46..fc5dd1ff7d8 100644
--- a/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h
+++ b/source/blender/compositor/operations/COM_PlaneDistortCommonOperation.h
@@ -33,43 +33,72 @@
 #include "BLI_listbase.h"
 #include "BLI_string.h"
 
+#define PLANE_DISTORT_MAX_SAMPLES 64
 
 class PlaneDistortWarpImageOperation : public NodeOperation {
 protected:
+	struct MotionSample {
+		float frameSpaceCorners[4][2];  /* Corners coordinates in pixel space. */
+		float perspectiveMatrix[3][3];
+	};
 	SocketReader *m_pixelReader;
-	float m_frameSpaceCorners[4][2];  /* Corners coordinates in pixel space. */
-	float m_perspectiveMatrix[3][3];
+	MotionSample m_samples[PLANE_DISTORT_MAX_SAMPLES];
+	int m_motion_blur_samples;
+	float m_motion_blur_shutter;
 
 public:
 	PlaneDistortWarpImageOperation();
 
-	void calculateCorners(const float corners[4][2], bool normalized);
-	void calculatePerspectiveMatrix();
+	void calculateCorners(const float corners[4][2],
+	                      bool normalized,
+	                      int sample);
 
 	void initExecution();
 	void deinitExecution();
 
 	void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
-	void pixelTransform(const float xy[2], float r_uv[2], float r_deriv[2][2]);
 
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
+
+	void setMotionBlurSamples(int samples) {
+		BLI_assert(samples <= PLANE_DISTORT_MAX_SAMPLES);
+		this->m_motion_blur_samples = samples;
+	}
+	void setMotionBlurShutter(float shutter) {
+		this->m_motion_blur_shutter = shutter;
+	}
 };
 
 
 class PlaneDistortMaskOperation : public NodeOperation {
 protected:
+	struct MotionSample {
+		float frameSpaceCorners[4][2];  /* Corners coordinates in pixel space. */
+	};
 	int m_osa;
+	MotionSample m_samples[PLANE_DISTORT_MAX_SAMPLES];
 	float m_jitter[32][2];
-	float m_frameSpaceCorners[4][2];  /* Corners coordinates in pixel space. */
+	int m_motion_blur_samples;
+	float m_motion_blur_shutter;
 
 public:
 	PlaneDistortMaskOperation();
-	
-	void calculateCorners(const float corners[4][2], bool normalized);
-	
+
+	void calculateCorners(const float corners[4][2],
+	                      bool normalized,
+	                      int sample);
+
 	void initExecution();
-	
+
 	void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
+
+	void setMotionBlurSamples(int samples) {
+		BLI_assert(samples <= PLANE_DISTORT_MAX_SAMPLES);
+		this->m_motion_blur_samples = samples;
+	}
+	void setMotionBlurShutter(float shutter) {
+		this->m_motion_blur_shutter = shutter;
+	}
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_PlaneTrackOperation.cpp b/source/blender/compositor/operations/COM_PlaneTrackOperation.cpp
index fec39cbfde0..20a8fa95200 100644
--- a/source/blender/compositor/operations/COM_PlaneTrackOperation.cpp
+++ b/source/blender/compositor/operations/COM_PlaneTrackOperation.cpp
@@ -46,31 +46,29 @@ PlaneTrackCommon::PlaneTrackCommon()
 	this->m_planeTrackName[0] = '\0';
 }
 
-void PlaneTrackCommon::readCornersFromTrack(float corners[4][2])
+void PlaneTrackCommon::readCornersFromTrack(float corners[4][2], float frame)
 {
 	MovieTracking *tracking;
 	MovieTrackingObject *object;
 
 	if (!this->m_movieClip)
 		return;
-	
+
 	tracking = &this->m_movieClip->tracking;
-	
+
 	object = BKE_tracking_object_get_named(tracking, this->m_trackingObjectName);
 	if (object) {
 		MovieTrackingPlaneTrack *plane_track;
-		
 		plane_track = BKE_tracking_plane_track_get_named(tracking, object, this->m_planeTrackName);
-		
 		if (plane_track) {
 			MovieTrackingPlaneMarker *plane_marker;
-			int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(this->m_movieClip, this->m_framenumber);
-			
+			float clip_framenr =
+				BKE_movieclip_remap_scene_to_clip_frame(this->m_movieClip,
+				                                        frame);
 			plane_marker = BKE_tracking_plane_marker_get(plane_track, clip_framenr);
-			copy_v2_v2(corners[0], plane_marker->corners[0]);
-			copy_v2_v2(corners[1], plane_marker->corners[1]);
-			copy_v2_v2(corners[2], plane_marker->corners[2]);
-			copy_v2_v2(corners[3], plane_marker->corners[3]);
+			BKE_tracking_plane_marker_get_subframe_corners(plane_track,
+			                                               clip_framenr,
+			                                               corners);
 		}
 	}
 }
@@ -79,14 +77,12 @@ void PlaneTrackCommon::determineResolution(unsigned int resolution[2], unsigned
 {
 	resolution[0] = 0;
 	resolution[1] = 0;
-	
+
 	if (this->m_movieClip) {
 		int width, height;
 		MovieClipUser user = {0};
-		
 		BKE_movieclip_user_set_frame(&user, this->m_framenumber);
 		BKE_movieclip_get_size(this->m_movieClip, &user, &width, &height);
-		
 		resolution[0] = width;
 		resolution[1] = height;
 	}
@@ -98,10 +94,21 @@ void PlaneTrackCommon::determineResolution(unsigned int resolution[2], unsigned
 void PlaneTrackMaskOperation::initExecution()
 {
 	PlaneDistortMaskOperation::initExecution();
-	
 	float corners[4][2];
-	readCornersFromTrack(corners);
-	calculateCorners(corners, true);
+	if (this->m_motion_blur_samples == 1) {
+		readCornersFromTrack(corners, this->m_framenumber);
+		calculateCorners(corners, true, 0);
+	}
+	else {
+		const float frame = (float)this->m_framenumber - this->m_motion_blur_shutter;
+		const float frame_step = (this->m_motion_blur_shutter * 2.0f) / this->m_motion_blur_samples;
+		float frame_iter = frame;
+		for (int sample = 0; sample < this->m_motion_blur_samples; ++sample) {
+			readCornersFromTrack(corners, frame_iter);
+			calculateCorners(corners, true, sample);
+			frame_iter += frame_step;
+		}
+	}
 }
 
 /* ******** PlaneTrackWarpImageOperation ******** */
@@ -109,9 +116,20 @@ void PlaneTrackMaskOperation::initExecution()
 void PlaneTrackWarpImageOperation::initExecution()
 {
 	PlaneDistortWarpImageOperation::initExecution();
-	
+	/* TODO(sergey): De-duplicate with mask operation. */
 	float corners[4][2];
-	readCornersFromTrack(corners);
-	calculateCorners(corners, true);
-	calculatePerspectiveMatrix();
+	if (this->m_motion_blur_samples == 1) {
+		readCornersFromTrack(corners, this->m_framenumber);
+		calculateCorners(corners, true, 0);
+	}
+	else {
+		const float frame = (float)this->m_framenumber - this->m_motion_blur_shutter;
+		const float frame_step = (this->m_motion_blur_shutter * 2.0f) / this->m_motion_blur_samples;
+		float frame_iter = frame;
+		for (int sample = 0; sample < this->m_motion_blur_samples; ++sample) {
+			readCornersFromTrack(corners, frame_iter);
+			calculateCorners(corners, true, sample);
+			frame_iter += frame_step;
+		}
+	}
 }
diff --git a/source/blender/compositor/operations/COM_PlaneTrackOperation.h b/source/blender/compositor/operations/COM_PlaneTrackOperation.h
index 3c5dd783542..41761493e12 100644
--- a/source/blender/compositor/operations/COM_PlaneTrackOperation.h
+++ b/source/blender/compositor/operations/COM_PlaneTrackOperation.h
@@ -43,7 +43,7 @@ protected:
 	/* note: this class is not an operation itself (to prevent virtual inheritance issues)
 	 * implementation classes must make wrappers to use these methods, see below.
 	 */
-	void readCornersFromTrack(float corners[4][2]);
+	void readCornersFromTrack(float corners[4][2], float frame);
 	void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
 public:
@@ -68,7 +68,7 @@ public:
 	void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2])
 	{
 		PlaneTrackCommon::determineResolution(resolution, preferredResolution);
-		
+
 		unsigned int temp[2];
 		NodeOperation::determineResolution(temp, resolution);
 	}
@@ -81,13 +81,12 @@ public:
 	    PlaneDistortWarpImageOperation(),
 	    PlaneTrackCommon()
 	{}
-	
+
 	void initExecution();
-	
+
 	void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2])
 	{
 		PlaneTrackCommon::determineResolution(resolution, preferredResolution);
-		
 		unsigned int temp[2];
 		NodeOperation::determineResolution(temp, resolution);
 	}
diff --git a/source/blender/editors/animation/keyframes_general.c b/source/blender/editors/animation/keyframes_general.c
index 3784cd5621e..932a00d1687 100644
--- a/source/blender/editors/animation/keyframes_general.c
+++ b/source/blender/editors/animation/keyframes_general.c
@@ -641,7 +641,7 @@ static void flip_names(tAnimCopybufItem *aci, char **name)
 			str_iter = *name = MEM_mallocN(sizeof(char) * (prefix_l + postfix_l + length + 1), "flipped_path");
 			
 			BLI_strncpy(str_iter, aci->rna_path, prefix_l + 1);
-			str_iter += prefix_l ;
+			str_iter += prefix_l;
 			BLI_strncpy(str_iter, bname_new, length + 1);
 			str_iter += length;
 			BLI_strncpy(str_iter, str_end, postfix_l + 1);
diff --git a/source/blender/editors/armature/armature_select.c b/source/blender/editors/armature/armature_select.c
index c6ef76c570c..307e6c076f2 100644
--- a/source/blender/editors/armature/armature_select.c
+++ b/source/blender/editors/armature/armature_select.c
@@ -254,7 +254,7 @@ static int armature_select_linked_invoke(bContext *C, wmOperator *op, const wmEv
 
 static int armature_select_linked_poll(bContext *C)
 {
-	return (ED_operator_view3d_active(C) && ED_operator_editarmature(C) );
+	return (ED_operator_view3d_active(C) && ED_operator_editarmature(C));
 }
 
 void ARMATURE_OT_select_linked(wmOperatorType *ot)
diff --git a/source/blender/editors/curve/editcurve.c b/source/blender/editors/curve/editcurve.c
index 51c621cbf19..4aeeaa87269 100644
--- a/source/blender/editors/curve/editcurve.c
+++ b/source/blender/editors/curve/editcurve.c
@@ -643,25 +643,20 @@ static void keyData_switchDirectionNurb(Curve *cu, Nurb *nu)
 static GHash *dupli_keyIndexHash(GHash *keyindex)
 {
 	GHash *gh;
-	GHashIterator *hashIter;
+	GHashIterator gh_iter;
 
 	gh = BLI_ghash_ptr_new_ex("dupli_keyIndex gh", BLI_ghash_size(keyindex));
 
-	for (hashIter = BLI_ghashIterator_new(keyindex);
-	     BLI_ghashIterator_done(hashIter) == false;
-	     BLI_ghashIterator_step(hashIter))
-	{
-		void *cv = BLI_ghashIterator_getKey(hashIter);
-		CVKeyIndex *index = BLI_ghashIterator_getValue(hashIter);
-		CVKeyIndex *newIndex = MEM_callocN(sizeof(CVKeyIndex), "dupli_keyIndexHash index");
+	GHASH_ITER (gh_iter, keyindex) {
+		void *cv = BLI_ghashIterator_getKey(&gh_iter);
+		CVKeyIndex *index = BLI_ghashIterator_getValue(&gh_iter);
+		CVKeyIndex *newIndex = MEM_mallocN(sizeof(CVKeyIndex), "dupli_keyIndexHash index");
 
 		memcpy(newIndex, index, sizeof(CVKeyIndex));
 
 		BLI_ghash_insert(gh, cv, newIndex);
 	}
 
-	BLI_ghashIterator_free(hashIter);
-
 	return gh;
 }
 
diff --git a/source/blender/editors/curve/editcurve_add.c b/source/blender/editors/curve/editcurve_add.c
index c9a961d1a4d..7c53896b969 100644
--- a/source/blender/editors/curve/editcurve_add.c
+++ b/source/blender/editors/curve/editcurve_add.c
@@ -529,11 +529,9 @@ static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf)
 	if (newob && enter_editmode)
 		ED_undo_push(C, "Enter Editmode");
 
-	ED_object_new_primitive_matrix(C, obedit, loc, rot, mat, false);
+	ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
 	dia = RNA_float_get(op->ptr, "radius");
-	mat[0][0] *= dia;
-	mat[1][1] *= dia;
-	mat[2][2] *= dia;
+	mul_mat3_m4_fl(mat, dia);
 
 	nu = add_nurbs_primitive(C, obedit, mat, type, newob);
 	editnurb = object_editcurve_get(obedit);
diff --git a/source/blender/editors/gpencil/gpencil_edit.c b/source/blender/editors/gpencil/gpencil_edit.c
index 0f1be590e9c..a830253f634 100644
--- a/source/blender/editors/gpencil/gpencil_edit.c
+++ b/source/blender/editors/gpencil/gpencil_edit.c
@@ -100,7 +100,8 @@ bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, Scene *scene, ScrAr
 		
 		switch (sa->spacetype) {
 			case SPACE_VIEW3D: /* 3D-View */
-			case SPACE_TIME: /* Timeline - XXX: this is a hack to get it to show GP keyframes for 3D view */
+			case SPACE_TIME:   /* Timeline - XXX: this is a hack to get it to show GP keyframes for 3D view */
+			case SPACE_ACTION: /* DepeSheet - XXX: this is a hack to get the keyframe jump operator to take GP Keyframes into account */
 			{
 				BLI_assert(scene && ELEM(scene->toolsettings->gpencil_src,
 				                         GP_TOOL_SOURCE_SCENE, GP_TOOL_SOURCE_OBJECT));
diff --git a/source/blender/editors/include/ED_object.h b/source/blender/editors/include/ED_object.h
index 900da3ee07c..ccdde39f263 100644
--- a/source/blender/editors/include/ED_object.h
+++ b/source/blender/editors/include/ED_object.h
@@ -141,9 +141,9 @@ bool ED_object_editmode_load(struct Object *obedit);
 void ED_object_location_from_view(struct bContext *C, float loc[3]);
 void ED_object_rotation_from_view(struct bContext *C, float rot[3], const char align_axis);
 void ED_object_base_init_transform(struct bContext *C, struct Base *base, const float loc[3], const float rot[3]);
-float ED_object_new_primitive_matrix(struct bContext *C, struct Object *editob,
-                                     const float loc[3], const float rot[3], float primmat[4][4],
-                                     bool apply_diameter);
+float ED_object_new_primitive_matrix(
+        struct bContext *C, struct Object *editob,
+        const float loc[3], const float rot[3], float primmat[4][4]);
 
 void ED_object_add_unit_props(struct wmOperatorType *ot);
 void ED_object_add_generic_props(struct wmOperatorType *ot, bool do_editmode);
diff --git a/source/blender/editors/include/UI_icons.h b/source/blender/editors/include/UI_icons.h
index 7c60933a1a3..bfb7a3420c9 100644
--- a/source/blender/editors/include/UI_icons.h
+++ b/source/blender/editors/include/UI_icons.h
@@ -590,8 +590,8 @@ DEF_ICON(MOD_SKIN)
 DEF_ICON(MOD_TRIANGULATE)
 DEF_ICON(MOD_WIREFRAME)
 DEF_ICON(MOD_DATA_TRANSFER)
+DEF_ICON(MOD_NORMALEDIT)
 #ifndef DEF_ICON_BLANK_SKIP
-	DEF_ICON(BLANK168)
 	DEF_ICON(BLANK169)
 	DEF_ICON(BLANK170)
 	DEF_ICON(BLANK171)
diff --git a/source/blender/editors/interface/interface_layout.c b/source/blender/editors/interface/interface_layout.c
index 9d1b312dc24..fb73b8ec34c 100644
--- a/source/blender/editors/interface/interface_layout.c
+++ b/source/blender/editors/interface/interface_layout.c
@@ -1004,7 +1004,7 @@ void uiItemEnumO_value(uiLayout *layout, const char *name, int icon, const char
 	PointerRNA ptr;
 	PropertyRNA *prop;
 
-	UI_OPERATOR_ERROR_RET(ot, opname, return );
+	UI_OPERATOR_ERROR_RET(ot, opname, return);
 
 	WM_operator_properties_create_ptr(&ptr, ot);
 
@@ -1036,7 +1036,7 @@ void uiItemEnumO_string(uiLayout *layout, const char *name, int icon, const char
 	int value;
 	bool free;
 
-	UI_OPERATOR_ERROR_RET(ot, opname, return );
+	UI_OPERATOR_ERROR_RET(ot, opname, return);
 
 	WM_operator_properties_create_ptr(&ptr, ot);
 
@@ -1075,7 +1075,7 @@ void uiItemBooleanO(uiLayout *layout, const char *name, int icon, const char *op
 	wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
 	PointerRNA ptr;
 
-	UI_OPERATOR_ERROR_RET(ot, opname, return );
+	UI_OPERATOR_ERROR_RET(ot, opname, return);
 
 	WM_operator_properties_create_ptr(&ptr, ot);
 	RNA_boolean_set(&ptr, propname, value);
@@ -1088,7 +1088,7 @@ void uiItemIntO(uiLayout *layout, const char *name, int icon, const char *opname
 	wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
 	PointerRNA ptr;
 
-	UI_OPERATOR_ERROR_RET(ot, opname, return );
+	UI_OPERATOR_ERROR_RET(ot, opname, return);
 
 	WM_operator_properties_create_ptr(&ptr, ot);
 	RNA_int_set(&ptr, propname, value);
@@ -1101,7 +1101,7 @@ void uiItemFloatO(uiLayout *layout, const char *name, int icon, const char *opna
 	wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
 	PointerRNA ptr;
 
-	UI_OPERATOR_ERROR_RET(ot, opname, return );
+	UI_OPERATOR_ERROR_RET(ot, opname, return);
 
 	WM_operator_properties_create_ptr(&ptr, ot);
 	RNA_float_set(&ptr, propname, value);
@@ -1114,7 +1114,7 @@ void uiItemStringO(uiLayout *layout, const char *name, int icon, const char *opn
 	wmOperatorType *ot = WM_operatortype_find(opname, 0); /* print error next */
 	PointerRNA ptr;
 
-	UI_OPERATOR_ERROR_RET(ot, opname, return );
+	UI_OPERATOR_ERROR_RET(ot, opname, return);
 
 	WM_operator_properties_create_ptr(&ptr, ot);
 	RNA_string_set(&ptr, propname, value);
@@ -1878,7 +1878,7 @@ void uiItemMenuEnumO(uiLayout *layout, bContext *C, const char *opname, const ch
 	MenuItemLevel *lvl;
 	uiBut *but;
 
-	UI_OPERATOR_ERROR_RET(ot, opname, return );
+	UI_OPERATOR_ERROR_RET(ot, opname, return);
 
 	if (!ot->srna) {
 		ui_item_disabled(layout, opname);
diff --git a/source/blender/editors/interface/interface_ops.c b/source/blender/editors/interface/interface_ops.c
index 9bd09b571db..19e389154e4 100644
--- a/source/blender/editors/interface/interface_ops.c
+++ b/source/blender/editors/interface/interface_ops.c
@@ -858,7 +858,7 @@ int UI_drop_color_poll(struct bContext *C, wmDrag *drag, const wmEvent *UNUSED(e
 
 void UI_drop_color_copy(wmDrag *drag, wmDropBox *drop)
 {
-	uiDragColorHandle *drag_info = (uiDragColorHandle *)drag->poin;
+	uiDragColorHandle *drag_info = drag->poin;
 
 	RNA_float_set_array(drop->ptr, "color", drag_info->color);
 	RNA_boolean_set(drop->ptr, "gamma", drag_info->gamma_corrected);
diff --git a/source/blender/editors/interface/view2d.c b/source/blender/editors/interface/view2d.c
index 12ee3199f43..b4a120b2dea 100644
--- a/source/blender/editors/interface/view2d.c
+++ b/source/blender/editors/interface/view2d.c
@@ -371,7 +371,8 @@ static void ui_view2d_curRect_validate_resize(View2D *v2d, int resize, int mask_
 	float winx, winy;
 	rctf *cur, *tot;
 	
-	/* use mask as size of region that View2D resides in, as it takes into account scrollbars already  */
+	/* use mask as size of region that View2D resides in, as it takes into account
+	 * scrollbars already - keep in sync with zoomx/zoomy in view_zoomstep_apply_ex! */
 	winx = (float)(BLI_rcti_size_x(&v2d->mask) + 1);
 	winy = (float)(BLI_rcti_size_y(&v2d->mask) + 1);
 	
@@ -393,6 +394,7 @@ static void ui_view2d_curRect_validate_resize(View2D *v2d, int resize, int mask_
 	 */
 	totwidth  = BLI_rctf_size_x(tot);
 	totheight = BLI_rctf_size_y(tot);
+	/* keep in sync with zoomx/zoomy in view_zoomstep_apply_ex! */
 	curwidth  = width  = BLI_rctf_size_x(cur);
 	curheight = height = BLI_rctf_size_y(cur);
 	
diff --git a/source/blender/editors/interface/view2d_ops.c b/source/blender/editors/interface/view2d_ops.c
index 297d8d0f258..88140d897ae 100644
--- a/source/blender/editors/interface/view2d_ops.c
+++ b/source/blender/editors/interface/view2d_ops.c
@@ -625,6 +625,7 @@ static void view_zoomstep_apply_ex(bContext *C, v2dViewZoomData *vzd, const bool
 {
 	ARegion *ar = CTX_wm_region(C);
 	View2D *v2d = &ar->v2d;
+	const rctf cur_old = v2d->cur;
 	float dx, dy;
 
 	/* calculate amount to move view by, ensuring symmetry so the
@@ -651,17 +652,23 @@ static void view_zoomstep_apply_ex(bContext *C, v2dViewZoomData *vzd, const bool
 				v2d->cur.xmax -= 2 * dx;
 		}
 		else {
+
+			v2d->cur.xmin += dx;
+			v2d->cur.xmax -= dx;
+
 			if (use_mousepos && (U.uiflag & USER_ZOOM_TO_MOUSEPOS)) {
-				float mval_fac = (vzd->mx_2d - v2d->cur.xmin) / BLI_rctf_size_x(&v2d->cur);
-				float mval_faci = 1.0f - mval_fac;
-				float ofs = (mval_fac * dx) - (mval_faci * dx);
-				
-				v2d->cur.xmin += ofs + dx;
-				v2d->cur.xmax += ofs - dx;
-			}
-			else {
-				v2d->cur.xmin += dx;
-				v2d->cur.xmax -= dx;
+				/* get zoom fac the same way as in ui_view2d_curRect_validate_resize - better keep in sync! */
+				const float zoomx = (float)(BLI_rcti_size_x(&v2d->mask) + 1) / BLI_rctf_size_x(&v2d->cur);
+
+				/* only move view to mouse if zoom fac is inside minzoom/maxzoom */
+				if (IN_RANGE_INCL(zoomx, v2d->minzoom, v2d->maxzoom)) {
+					float mval_fac = (vzd->mx_2d - cur_old.xmin) / BLI_rctf_size_x(&cur_old);
+					float mval_faci = 1.0f - mval_fac;
+					float ofs = (mval_fac * dx) - (mval_faci * dx);
+
+					v2d->cur.xmin += ofs;
+					v2d->cur.xmax += ofs;
+				}
 			}
 		}
 	}
@@ -676,17 +683,23 @@ static void view_zoomstep_apply_ex(bContext *C, v2dViewZoomData *vzd, const bool
 				v2d->cur.ymax -= 2 * dy;
 		}
 		else {
+
+			v2d->cur.ymin += dy;
+			v2d->cur.ymax -= dy;
+
 			if (use_mousepos && (U.uiflag & USER_ZOOM_TO_MOUSEPOS)) {
-				float mval_fac = (vzd->my_2d - v2d->cur.ymin) / BLI_rctf_size_y(&v2d->cur);
-				float mval_faci = 1.0f - mval_fac;
-				float ofs = (mval_fac * dy) - (mval_faci * dy);
-				
-				v2d->cur.ymin += ofs + dy;
-				v2d->cur.ymax += ofs - dy;
-			}
-			else {
-				v2d->cur.ymin += dy;
-				v2d->cur.ymax -= dy;
+				/* get zoom fac the same way as in ui_view2d_curRect_validate_resize - better keep in sync! */
+				const float zoomy = (float)(BLI_rcti_size_y(&v2d->mask) + 1) / BLI_rctf_size_y(&v2d->cur);
+
+				/* only move view to mouse if zoom fac is inside minzoom/maxzoom */
+				if (IN_RANGE_INCL(zoomy, v2d->minzoom, v2d->maxzoom)) {
+					float mval_fac = (vzd->my_2d - cur_old.ymin) / BLI_rctf_size_y(&cur_old);
+					float mval_faci = 1.0f - mval_fac;
+					float ofs = (mval_fac * dy) - (mval_faci * dy);
+
+					v2d->cur.ymin += ofs;
+					v2d->cur.ymax += ofs;
+				}
 			}
 		}
 	}
diff --git a/source/blender/editors/mesh/editmesh_add.c b/source/blender/editors/mesh/editmesh_add.c
index b288a02a3d1..6ce5e8a304b 100644
--- a/source/blender/editors/mesh/editmesh_add.c
+++ b/source/blender/editors/mesh/editmesh_add.c
@@ -32,6 +32,7 @@
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 
+#include "BLI_math.h"
 
 #include "BLF_translation.h"
 
@@ -71,7 +72,7 @@ static Object *make_prim_init(bContext *C, const char *idname,
 		*was_editmode = true;
 	}
 
-	*dia = ED_object_new_primitive_matrix(C, obedit, loc, rot, mat, false);
+	*dia = ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
 
 	return obedit;
 }
@@ -421,7 +422,9 @@ static int add_primitive_monkey_exec(bContext *C, wmOperator *op)
 {
 	Object *obedit;
 	BMEditMesh *em;
-	float loc[3], rot[3], mat[4][4], dia;
+	float mat[4][4];
+	float loc[3], rot[3];
+	float dia;
 	bool enter_editmode;
 	unsigned int layer;
 	bool was_editmode;
@@ -431,9 +434,7 @@ static int add_primitive_monkey_exec(bContext *C, wmOperator *op)
 
 	obedit = make_prim_init(C, CTX_DATA_(BLF_I18NCONTEXT_ID_MESH, "Suzanne"), &dia, mat, &was_editmode, loc, rot, layer);
 	dia = RNA_float_get(op->ptr, "radius");
-	mat[0][0] *= dia;
-	mat[1][1] *= dia;
-	mat[2][2] *= dia;
+	mul_mat3_m4_fl(mat, dia);
 
 	em = BKE_editmesh_from_object(obedit);
 
diff --git a/source/blender/editors/mesh/editmesh_tools.c b/source/blender/editors/mesh/editmesh_tools.c
index 3a9e366fe37..16b74c3bddd 100644
--- a/source/blender/editors/mesh/editmesh_tools.c
+++ b/source/blender/editors/mesh/editmesh_tools.c
@@ -988,7 +988,7 @@ void MESH_OT_vert_connect_concave(wmOperatorType *ot)
 	/* identifiers */
 	ot->name = "Split Concave Faces";
 	ot->idname = "MESH_OT_vert_connect_concave";
-	ot->description = "Makes all faces convex";
+	ot->description = "Make all faces convex";
 
 	/* api callbacks */
 	ot->exec = edbm_vert_connect_concave_exec;
diff --git a/source/blender/editors/mesh/mesh_data.c b/source/blender/editors/mesh/mesh_data.c
index 152d055d239..30e9a85d083 100644
--- a/source/blender/editors/mesh/mesh_data.c
+++ b/source/blender/editors/mesh/mesh_data.c
@@ -57,6 +57,7 @@
 
 #include "ED_mesh.h"
 #include "ED_object.h"
+#include "ED_screen.h"
 #include "ED_uvedit.h"
 #include "ED_view3d.h"
 
@@ -838,6 +839,71 @@ void MESH_OT_customdata_clear_skin(wmOperatorType *ot)
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
+/* Clear custom loop normals */
+static int mesh_customdata_custom_splitnormals_add_exec(bContext *C, wmOperator *UNUSED(op))
+{
+	Object *ob = ED_object_context(C);
+	Mesh *me = ob->data;
+
+	if (!BKE_mesh_has_custom_loop_normals(me)) {
+		CustomData *data = GET_CD_DATA(me, ldata);
+
+		if (me->edit_btmesh) {
+			BM_data_layer_add(me->edit_btmesh->bm, data, CD_CUSTOMLOOPNORMAL);
+		}
+		else {
+			CustomData_add_layer(data, CD_CUSTOMLOOPNORMAL, CD_DEFAULT, NULL, me->totloop);
+		}
+
+		DAG_id_tag_update(&me->id, 0);
+		WM_event_add_notifier(C, NC_GEOM | ND_DATA, me);
+
+		return OPERATOR_FINISHED;
+	}
+	return OPERATOR_CANCELLED;
+}
+
+void MESH_OT_customdata_custom_splitnormals_add(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Add Custom Split Normals Data";
+	ot->idname = "MESH_OT_customdata_custom_splitnormals_add";
+	ot->description = "Add a custom split normals layer, if none exists yet";
+
+	/* api callbacks */
+	ot->exec = mesh_customdata_custom_splitnormals_add_exec;
+	ot->poll = ED_operator_object_active_editable_mesh;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+static int mesh_customdata_custom_splitnormals_clear_exec(bContext *C, wmOperator *UNUSED(op))
+{
+	Object *ob = ED_object_context(C);
+	Mesh *me = ob->data;
+
+	if (BKE_mesh_has_custom_loop_normals(me)) {
+		return mesh_customdata_clear_exec__internal(C, BM_LOOP, CD_CUSTOMLOOPNORMAL);
+	}
+	return OPERATOR_CANCELLED;
+}
+
+void MESH_OT_customdata_custom_splitnormals_clear(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Clear Custom Split Normals Data";
+	ot->idname = "MESH_OT_customdata_custom_splitnormals_clear";
+	ot->description = "Remove the custom split normals layer, if it exists";
+
+	/* api callbacks */
+	ot->exec = mesh_customdata_custom_splitnormals_clear_exec;
+	ot->poll = ED_operator_object_active_editable_mesh;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
 /************************** Add Geometry Layers *************************/
 
 void ED_mesh_update(Mesh *mesh, bContext *C, int calc_edges, int calc_tessface)
diff --git a/source/blender/editors/mesh/mesh_intern.h b/source/blender/editors/mesh/mesh_intern.h
index a794db62e3e..8f5ecaed524 100644
--- a/source/blender/editors/mesh/mesh_intern.h
+++ b/source/blender/editors/mesh/mesh_intern.h
@@ -238,6 +238,8 @@ void MESH_OT_vertex_color_remove(struct wmOperatorType *ot);
 /* no create_mask yet */
 void MESH_OT_customdata_clear_mask(struct wmOperatorType *ot);
 void MESH_OT_customdata_clear_skin(struct wmOperatorType *ot);
+void MESH_OT_customdata_custom_splitnormals_add(struct wmOperatorType *ot);
+void MESH_OT_customdata_custom_splitnormals_clear(struct wmOperatorType *ot);
 void MESH_OT_drop_named_image(struct wmOperatorType *ot);
 
 
diff --git a/source/blender/editors/mesh/mesh_ops.c b/source/blender/editors/mesh/mesh_ops.c
index 8146be7ee47..59d0de87de6 100644
--- a/source/blender/editors/mesh/mesh_ops.c
+++ b/source/blender/editors/mesh/mesh_ops.c
@@ -153,6 +153,8 @@ void ED_operatortypes_mesh(void)
 	WM_operatortype_append(MESH_OT_vertex_color_remove);
 	WM_operatortype_append(MESH_OT_customdata_clear_mask);
 	WM_operatortype_append(MESH_OT_customdata_clear_skin);
+	WM_operatortype_append(MESH_OT_customdata_custom_splitnormals_add);
+	WM_operatortype_append(MESH_OT_customdata_custom_splitnormals_clear);
 	WM_operatortype_append(MESH_OT_drop_named_image);
 
 	WM_operatortype_append(MESH_OT_edgering_select);
diff --git a/source/blender/editors/object/object_add.c b/source/blender/editors/object/object_add.c
index 2fde09570c0..1180c082783 100644
--- a/source/blender/editors/object/object_add.c
+++ b/source/blender/editors/object/object_add.c
@@ -218,9 +218,9 @@ void ED_object_base_init_transform(bContext *C, Base *base, const float loc[3],
 
 /* Uses context to figure out transform for primitive.
  * Returns standard diameter. */
-float ED_object_new_primitive_matrix(bContext *C, Object *obedit,
-                                     const float loc[3], const float rot[3], float primmat[4][4],
-                                     bool apply_diameter)
+float ED_object_new_primitive_matrix(
+        bContext *C, Object *obedit,
+        const float loc[3], const float rot[3], float primmat[4][4])
 {
 	Scene *scene = CTX_data_scene(C);
 	View3D *v3d = CTX_wm_view3d(C);
@@ -245,13 +245,6 @@ float ED_object_new_primitive_matrix(bContext *C, Object *obedit,
 
 	{
 		const float dia = v3d ? ED_view3d_grid_scale(scene, v3d, NULL) : ED_scene_grid_scale(scene, NULL);
-
-		if (apply_diameter) {
-			primmat[0][0] *= dia;
-			primmat[1][1] *= dia;
-			primmat[2][2] *= dia;
-		}
-
 		return dia;
 	}
 
@@ -515,7 +508,7 @@ static int effector_add_exec(bContext *C, wmOperator *op)
 		cu = ob->data;
 		cu->flag |= CU_PATH | CU_3D;
 		ED_object_editmode_enter(C, 0);
-		ED_object_new_primitive_matrix(C, ob, loc, rot, mat, false);
+		ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
 		BLI_addtail(&cu->editnurb->nurbs, add_nurbs_primitive(C, ob, mat, CU_NURBS | CU_PRIM_PATH, dia));
 		if (!enter_editmode)
 			ED_object_editmode_exit(C, EM_FREEDATA);
@@ -638,7 +631,7 @@ static int object_metaball_add_exec(bContext *C, wmOperator *op)
 		DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);
 	}
 
-	ED_object_new_primitive_matrix(C, obedit, loc, rot, mat, false);
+	ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
 	dia = RNA_float_get(op->ptr, "radius");
 
 	add_metaball_primitive(C, obedit, mat, dia, RNA_enum_get(op->ptr, "type"));
diff --git a/source/blender/editors/object/object_data_transfer.c b/source/blender/editors/object/object_data_transfer.c
index ec3ae92adc4..c57cae41bf4 100644
--- a/source/blender/editors/object/object_data_transfer.c
+++ b/source/blender/editors/object/object_data_transfer.c
@@ -83,6 +83,7 @@ static EnumPropertyItem DT_layer_items[] = {
 	{DT_TYPE_BWEIGHT_EDGE, "BEVEL_WEIGHT_EDGE", 0, "Bevel Weight", "Transfer bevel weights"},
 	{DT_TYPE_FREESTYLE_EDGE, "FREESTYLE_EDGE", 0, "Freestyle Mark", "Transfer Freestyle edge mark"},
 	{0, "", 0, "Face Corner Data", ""},
+	{DT_TYPE_LNOR, "CUSTOM_NORMAL", 0, "Custom Normals", "Transfer custom normals"},
 	{DT_TYPE_VCOL, "VCOL", 0, "VCol", "Vertex (face corners) colors"},
 	{DT_TYPE_UV, "UV", 0, "UVs", "Transfer UV layers"},
 	{0, "", 0, "Face Data", ""},
diff --git a/source/blender/editors/object/object_group.c b/source/blender/editors/object/object_group.c
index 20e2e22cdf8..3c43f2729bd 100644
--- a/source/blender/editors/object/object_group.c
+++ b/source/blender/editors/object/object_group.c
@@ -61,47 +61,6 @@
 
 /********************* 3d view operators ***********************/
 
-static bool group_link_early_exit_check(Group *group, Object *object)
-{
-	GroupObject *group_object;
-
-	for (group_object = group->gobject.first; group_object; group_object = group_object->next) {
-		if (group_object->ob == object) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-static bool check_object_instances_group_recursive(Object *object, Group *group)
-{
-	if (object->dup_group) {
-		Group *dup_group = object->dup_group;
-		if ((dup_group->id.flag & LIB_DOIT) == 0) {
-			/* Cycle already exists in groups, let's prevent further crappyness */
-			return true;
-		}
-		/* flag the object to identify cyclic dependencies in further dupli groups */
-		dup_group->id.flag &= ~LIB_DOIT;
-		
-		if (dup_group == group)
-			return true;
-		else {
-			GroupObject *gob;
-			for (gob = dup_group->gobject.first; gob; gob = gob->next) {
-				if (check_object_instances_group_recursive(gob->ob, group))
-					return true;
-			}
-		}
-		
-		/* un-flag the object, it's allowed to have the same group multiple times in parallel */
-		dup_group->id.flag |= LIB_DOIT;
-	}
-	
-	return false;
-}
-
 /* can be called with C == NULL */
 static EnumPropertyItem *group_object_active_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
 {
@@ -185,15 +144,12 @@ static int objects_add_active_exec(bContext *C, wmOperator *op)
 		if (!BKE_group_object_exists(group, ob))
 			continue;
 
-		/* for recursive check */
-		BKE_main_id_tag_listbase(&bmain->group, true);
-
 		CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
 		{
-			if (group_link_early_exit_check(group, base->object))
+			if (BKE_group_object_exists(group, base->object))
 				continue;
 
-			if (!check_object_instances_group_recursive(base->object, group)) {
+			if (!BKE_group_object_cyclic_check(bmain, base->object, group)) {
 				BKE_group_object_add(group, base->object, scene, base);
 				updated = true;
 			}
@@ -486,7 +442,7 @@ static int group_link_exec(bContext *C, wmOperator *op)
 	 * we could sckip all the dependency check and just consider
 	 * operator is finished.
 	 */
-	if (group_link_early_exit_check(group, ob)) {
+	if (BKE_group_object_exists(group, ob)) {
 		return OPERATOR_FINISHED;
 	}
 
@@ -495,8 +451,7 @@ static int group_link_exec(bContext *C, wmOperator *op)
 	 * It is also  bad idea to add object to group which is in group which
 	 * contains our current object.
 	 */
-	BKE_main_id_tag_listbase(&bmain->group, true);
-	if (check_object_instances_group_recursive(ob, group)) {
+	if (BKE_group_object_cyclic_check(bmain, ob, group)) {
 		BKE_report(op->reports, RPT_ERROR, "Could not add the group because of dependency cycle detected");
 		return OPERATOR_CANCELLED;
 	}
diff --git a/source/blender/editors/object/object_hook.c b/source/blender/editors/object/object_hook.c
index 9f9a647c9f1..1d764ced524 100644
--- a/source/blender/editors/object/object_hook.c
+++ b/source/blender/editors/object/object_hook.c
@@ -503,6 +503,15 @@ static int add_hook_object(Main *bmain, Scene *scene, Object *obedit, Object *ob
 	
 	unit_m4(pose_mat);
 
+	invert_m4_m4(obedit->imat, obedit->obmat);
+	if (mode == OBJECT_ADDHOOK_NEWOB) {
+		/* pass */
+	}
+	else {
+		/* may overwrite with pose-bone location, below */
+		mul_v3_m4v3(cent, obedit->imat, ob->obmat[3]);
+	}
+
 	if (mode == OBJECT_ADDHOOK_SELOB_BONE) {
 		bArmature *arm = ob->data;
 		BLI_assert(ob->type == OB_ARMATURE);
@@ -514,6 +523,8 @@ static int add_hook_object(Main *bmain, Scene *scene, Object *obedit, Object *ob
 			pchan_act = BKE_pose_channel_active(ob);
 			if (LIKELY(pchan_act)) {
 				invert_m4_m4(pose_mat, pchan_act->pose_mat);
+				mul_v3_m4v3(cent, ob->obmat, pchan_act->pose_mat[3]);
+				mul_v3_m4v3(cent, obedit->imat, cent);
 			}
 		}
 		else {
@@ -521,6 +532,9 @@ static int add_hook_object(Main *bmain, Scene *scene, Object *obedit, Object *ob
 		}
 	}
 
+	copy_v3_v3(hmd->cent, cent);
+
+
 	/* matrix calculus */
 	/* vert x (obmat x hook->imat) x hook->obmat x ob->imat */
 	/*        (parentinv         )                          */
diff --git a/source/blender/editors/object/object_vgroup.c b/source/blender/editors/object/object_vgroup.c
index e70281c502b..f885cbbb24f 100644
--- a/source/blender/editors/object/object_vgroup.c
+++ b/source/blender/editors/object/object_vgroup.c
@@ -1646,7 +1646,7 @@ static void vgroup_blend_subset(Object *ob, const bool *vgroup_validmap, const i
 	BMesh *bm = em ? em->bm : NULL;
 	Mesh  *me = em ? NULL   : ob->data;
 
-	MeshElemMap *emap ;
+	MeshElemMap *emap;
 	int *emap_mem;
 
 	BLI_SMALLSTACK_DECLARE(dv_stack, MDeformVert *);
diff --git a/source/blender/editors/screen/glutil.c b/source/blender/editors/screen/glutil.c
index 134feb59d55..4c1698bd1d4 100644
--- a/source/blender/editors/screen/glutil.c
+++ b/source/blender/editors/screen/glutil.c
@@ -1136,9 +1136,9 @@ void glaDrawImBuf_glsl_ctx(const bContext *C, ImBuf *ibuf, float x, float y, int
 
 void cpack(unsigned int x)
 {
-	glColor3ub( ( (x)        & 0xFF),
-	            (((x) >>  8) & 0xFF),
-	            (((x) >> 16) & 0xFF) );
+	glColor3ub(( (x)        & 0xFF),
+	           (((x) >>  8) & 0xFF),
+	           (((x) >> 16) & 0xFF));
 }
 
 void glaDrawBorderCorners(const rcti *border, float zoomx, float zoomy)
diff --git a/source/blender/editors/screen/screen_ops.c b/source/blender/editors/screen/screen_ops.c
index 1990216aa30..ad3d2d1a21a 100644
--- a/source/blender/editors/screen/screen_ops.c
+++ b/source/blender/editors/screen/screen_ops.c
@@ -3387,7 +3387,12 @@ static int screen_animation_step(bContext *C, wmOperator *UNUSED(op), const wmEv
 		    (sad->flag & ANIMPLAY_FLAG_REVERSE) == false &&
 		    finite(time = sound_sync_scene(scene)))
 		{
-			scene->r.cfra = (double)time * FPS + 0.5;
+			double newfra = (double)time * FPS;
+			/* give some space here to avoid jumps */
+			if (newfra + 0.5 > scene->r.cfra && newfra - 0.5 < scene->r.cfra)
+				scene->r.cfra++;
+			else
+				scene->r.cfra = newfra + 0.5;
 		}
 		else {
 			if (sync) {
@@ -3464,11 +3469,29 @@ static int screen_animation_step(bContext *C, wmOperator *UNUSED(op), const wmEv
 			for (sa = window->screen->areabase.first; sa; sa = sa->next) {
 				ARegion *ar;
 				for (ar = sa->regionbase.first; ar; ar = ar->next) {
+					bool redraw = false;
 					if (ar == sad->ar) {
-						ED_region_tag_redraw(ar);
+						redraw = true;
 					}
 					else if (match_region_with_redraws(sa->spacetype, ar->regiontype, sad->redraws)) {
+						redraw = true;
+					}
+
+					if (redraw) {
 						ED_region_tag_redraw(ar);
+						/* do follow here if editor type supports it */
+						if ((sad->redraws & TIME_FOLLOW)) {
+							if ((ar->regiontype == RGN_TYPE_WINDOW &&
+							    ELEM (sa->spacetype, SPACE_SEQ, SPACE_TIME, SPACE_IPO, SPACE_ACTION, SPACE_NLA)) ||
+							    (sa->spacetype == SPACE_CLIP && ar->regiontype == RGN_TYPE_PREVIEW))
+							{
+								float w = BLI_rctf_size_x(&ar->v2d.cur);
+								if (scene->r.cfra < ar->v2d.cur.xmin || scene->r.cfra > (ar->v2d.cur.xmax)) {
+									ar->v2d.cur.xmin = scene->r.cfra;
+									ar->v2d.cur.xmax = ar->v2d.cur.xmin + w;
+								}
+							}
+						}
 					}
 				}
 				
diff --git a/source/blender/editors/sculpt_paint/paint_image_proj.c b/source/blender/editors/sculpt_paint/paint_image_proj.c
index 91cabcaee9f..098477ed2a1 100644
--- a/source/blender/editors/sculpt_paint/paint_image_proj.c
+++ b/source/blender/editors/sculpt_paint/paint_image_proj.c
@@ -3279,7 +3279,7 @@ static void proj_paint_state_vert_flags_init(ProjPaintState *ps)
 #ifndef PROJ_DEBUG_NOSEAMBLEED
 static void project_paint_bleed_add_face_user(
         const ProjPaintState *ps, MemArena *arena,
-		const MFace *mf, const int face_index)
+        const MFace *mf, const int face_index)
 {
 	/* add face user if we have bleed enabled, set the UV seam flags later */
 	/* annoying but we need to add all faces even ones we never use elsewhere */
@@ -4923,7 +4923,7 @@ void *paint_proj_new_stroke(bContext *C, Object *ob, const float mouse[2], int m
 
 	/* Don't allow brush size below 2 */
 	if (BKE_brush_size_get(ps->scene, ps->brush) < 2)
-		BKE_brush_size_set(ps->scene, ps->brush, 2);
+		BKE_brush_size_set(ps->scene, ps->brush, 2 * U.pixelsize);
 
 	/* allocate and initialize spatial data structures */
 	project_paint_begin(ps);
@@ -5042,7 +5042,7 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
 	ps.is_maskbrush = false;
 	ps.do_masking = false;
 	orig_brush_size = BKE_brush_size_get(scene, ps.brush);
-	BKE_brush_size_set(scene, ps.brush, 32); /* cover the whole image */
+	BKE_brush_size_set(scene, ps.brush, 32 * U.pixelsize); /* cover the whole image */
 
 	ps.tool = PAINT_TOOL_DRAW; /* so pixels are initialized with minimal info */
 
@@ -5136,6 +5136,9 @@ static int texture_paint_image_from_view_exec(bContext *C, wmOperator *op)
 
 	image = BKE_image_add_from_imbuf(ibuf);
 
+	/* Drop reference to ibuf so that the image owns it */
+	IMB_freeImBuf(ibuf);
+
 	if (image) {
 		/* now for the trickyness. store the view projection here!
 		 * re-projection will reuse this */
diff --git a/source/blender/editors/sculpt_paint/paint_ops.c b/source/blender/editors/sculpt_paint/paint_ops.c
index ea5f77acc5b..fac1a05862f 100644
--- a/source/blender/editors/sculpt_paint/paint_ops.c
+++ b/source/blender/editors/sculpt_paint/paint_ops.c
@@ -106,15 +106,14 @@ static int brush_scale_size_exec(bContext *C, wmOperator *op)
 			const int old_size = BKE_brush_size_get(scene, brush);
 			int size = (int)(scalar * old_size);
 
-			if (old_size == size) {
+			if (abs(old_size - size) < U.pixelsize) {
 				if (scalar > 1) {
-					size++;
+					size += U.pixelsize;
 				}
 				else if (scalar < 1) {
-					size--;
+					size -= U.pixelsize;
 				}
 			}
-			CLAMP(size, 1, 2000); // XXX magic number
 
 			BKE_brush_size_set(scene, brush, size);
 		}
@@ -128,6 +127,8 @@ static int brush_scale_size_exec(bContext *C, wmOperator *op)
 
 			BKE_brush_unprojected_radius_set(scene, brush, unprojected_radius);
 		}
+
+		WM_main_add_notifier(NC_BRUSH | NA_EDITED, brush);
 	}
 
 	return OPERATOR_FINISHED;
diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c
index dbb29997102..69428c0f0d7 100644
--- a/source/blender/editors/sculpt_paint/sculpt.c
+++ b/source/blender/editors/sculpt_paint/sculpt.c
@@ -4248,14 +4248,14 @@ static void sculpt_stroke_update_step(bContext *C, struct PaintStroke *UNUSED(st
 	sculpt_restore_mesh(sd, ob);
 
 	if (sd->flags & SCULPT_DYNTOPO_DETAIL_CONSTANT) {
-		BKE_pbvh_bmesh_detail_size_set(ss->pbvh,
-			sd->constant_detail / 100.0f);
+		BKE_pbvh_bmesh_detail_size_set(ss->pbvh, sd->constant_detail / 100.0f);
 	}
 	else {
-		BKE_pbvh_bmesh_detail_size_set(ss->pbvh,
-		                               (ss->cache->radius /
-		                                (float)ups->pixel_radius) *
-		                               (float)sd->detail_size / 0.4f);
+		BKE_pbvh_bmesh_detail_size_set(
+		        ss->pbvh,
+		        (ss->cache->radius /
+		        (float)ups->pixel_radius) *
+		        (float)(sd->detail_size * U.pixelsize) / 0.4f);
 	}
 
 	if (sculpt_stroke_dynamic_topology(ss, brush)) {
diff --git a/source/blender/editors/sculpt_paint/sculpt_uv.c b/source/blender/editors/sculpt_paint/sculpt_uv.c
index 23bc4a483d3..a9feb9f48de 100644
--- a/source/blender/editors/sculpt_paint/sculpt_uv.c
+++ b/source/blender/editors/sculpt_paint/sculpt_uv.c
@@ -598,7 +598,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
 
 		UvEdge *edges;
 		GHash *edgeHash;
-		GHashIterator *ghi;
+		GHashIterator gh_iter;
 
 		bool do_island_optimization = !(ts->uv_sculpt_settings & UV_SCULPT_ALL_ISLANDS);
 		int island_index = 0;
@@ -754,21 +754,15 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, const wm
 			uv_sculpt_stroke_exit(C, op);
 			return NULL;
 		}
-		ghi = BLI_ghashIterator_new(edgeHash);
-		if (!ghi) {
-			BLI_ghash_free(edgeHash, NULL, NULL);
-			MEM_freeN(edges);
-			uv_sculpt_stroke_exit(C, op);
-			return NULL;
-		}
+
 		/* fill the edges with data */
-		for (i = 0; !BLI_ghashIterator_done(ghi); BLI_ghashIterator_step(ghi)) {
-			data->uvedges[i++] = *((UvEdge *)BLI_ghashIterator_getKey(ghi));
+		i = 0;
+		GHASH_ITER (gh_iter, edgeHash) {
+			data->uvedges[i++] = *((UvEdge *)BLI_ghashIterator_getKey(&gh_iter));
 		}
 		data->totalUvEdges = BLI_ghash_size(edgeHash);
 
 		/* cleanup temporary stuff */
-		BLI_ghashIterator_free(ghi);
 		BLI_ghash_free(edgeHash, NULL, NULL);
 		MEM_freeN(edges);
 
diff --git a/source/blender/editors/space_clip/clip_buttons.c b/source/blender/editors/space_clip/clip_buttons.c
index f8299a8d335..c32d06cf9b1 100644
--- a/source/blender/editors/space_clip/clip_buttons.c
+++ b/source/blender/editors/space_clip/clip_buttons.c
@@ -540,7 +540,7 @@ void uiTemplateMovieclipInformation(uiLayout *layout, PointerRNA *ptr, const cha
 	uiItemL(col, str, ICON_NONE);
 
 	/* Display current frame number. */
-	framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr) ;
+	framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
 	if (framenr <= clip->len)
 		BLI_snprintf(str, sizeof(str), IFACE_("Frame: %d / %d"), framenr, clip->len);
 	else
diff --git a/source/blender/editors/space_file/filelist.c b/source/blender/editors/space_file/filelist.c
index edf0bb025c7..f0180c3c841 100644
--- a/source/blender/editors/space_file/filelist.c
+++ b/source/blender/editors/space_file/filelist.c
@@ -761,29 +761,20 @@ struct direntry *filelist_file(struct FileList *filelist, int index)
 
 int filelist_find(struct FileList *filelist, const char *filename)
 {
-	int index = -1;
-	int i;
 	int fidx = -1;
 	
 	if (!filelist->fidx) 
 		return fidx;
 
-	
-	for (i = 0; i < filelist->numfiles; ++i) {
-		/* not dealing with user input so don't need BLI_path_cmp */
-		if (STREQ(filelist->filelist[i].relname, filename)) {
-			index = i;
-			break;
-		}
-	}
+	for (fidx = 0; fidx < filelist->numfiltered; fidx++) {
+		int index = filelist->fidx[fidx];
 
-	for (i = 0; i < filelist->numfiltered; ++i) {
-		if (filelist->fidx[i] == index) {
-			fidx = i;
-			break;
+		if (STREQ(filelist->filelist[index].relname, filename)) {
+			return fidx;
 		}
 	}
-	return fidx;
+
+	return -1;
 }
 
 /* would recognize .blend as well */
diff --git a/source/blender/editors/space_graph/graph_select.c b/source/blender/editors/space_graph/graph_select.c
index 78dbae7618b..46a39806ad7 100644
--- a/source/blender/editors/space_graph/graph_select.c
+++ b/source/blender/editors/space_graph/graph_select.c
@@ -66,6 +66,15 @@
 /* ************************************************************************** */
 /* KEYFRAMES STUFF */
 
+static void graphkeys_auto_view(bContext *C)
+{
+	const SpaceIpo *sipo = CTX_wm_space_graph(C);
+
+	if (sipo && sipo->flag & SIPO_AUTO_VIEW_SELECTED) {
+		WM_operator_name_call(C, "GRAPH_OT_view_selected", WM_OP_INVOKE_DEFAULT, NULL);
+	}
+}
+
 /* ******************** Deselect All Operator ***************************** */
 /* This operator works in one of three ways:
  *	1) (de)select all (AKEY) - test if select all or deselect all
@@ -83,7 +92,7 @@
  *		2 = invert
  *	- do_channels: whether to affect selection status of channels
  */
-static void deselect_graph_keys(bAnimContext *ac, short test, short sel, short do_channels)
+static short deselect_graph_keys(bAnimContext *ac, short test, short sel, short do_channels)
 {
 	ListBase anim_data = {NULL, NULL};
 	bAnimListElem *ale;
@@ -142,6 +151,8 @@ static void deselect_graph_keys(bAnimContext *ac, short test, short sel, short d
 	
 	/* Cleanup */
 	ANIM_animdata_freelist(&anim_data);
+	
+	return sel;
 }
 
 /* ------------------- */
@@ -150,6 +161,7 @@ static int graphkeys_deselectall_exec(bContext *C, wmOperator *op)
 {
 	bAnimContext ac;
 	bAnimListElem *ale_active = NULL;
+	short sel;
 	
 	/* get editor data */
 	if (ANIM_animdata_get_context(C, &ac) == 0)
@@ -163,9 +175,9 @@ static int graphkeys_deselectall_exec(bContext *C, wmOperator *op)
 	
 	/* 'standard' behavior - check if selected, then apply relevant selection */
 	if (RNA_boolean_get(op->ptr, "invert"))
-		deselect_graph_keys(&ac, 0, SELECT_INVERT, true);
+		sel = deselect_graph_keys(&ac, 0, SELECT_INVERT, true);
 	else
-		deselect_graph_keys(&ac, 1, SELECT_ADD, true);
+		sel = deselect_graph_keys(&ac, 1, SELECT_ADD, true);
 	
 	/* restore active F-Curve... */
 	if (ale_active) {
@@ -180,6 +192,9 @@ static int graphkeys_deselectall_exec(bContext *C, wmOperator *op)
 		ale_active = NULL;
 	}
 	
+	if (sel != SELECT_SUBTRACT)
+		graphkeys_auto_view(C);
+	
 	/* set notifier that things have changed */
 	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
 	
@@ -374,6 +389,8 @@ static int graphkeys_borderselect_exec(bContext *C, wmOperator *op)
 	/* apply borderselect action */
 	borderselect_graphkeys(&ac, &rect_fl, mode, selectmode, incl_handles, NULL);
 	
+	graphkeys_auto_view(C);
+	
 	/* send notifier that keyframe selection has changed */
 	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
 	
@@ -461,6 +478,8 @@ static int graphkeys_lassoselect_exec(bContext *C, wmOperator *op)
 	MEM_freeN((void *)data_lasso.mcords);
 
 
+	graphkeys_auto_view(C);
+
 	/* send notifier that keyframe selection has changed */
 	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
 
@@ -491,6 +510,14 @@ void GRAPH_OT_select_lasso(wmOperatorType *ot)
 	RNA_def_boolean(ot->srna, "extend", true, "Extend", "Extend selection instead of deselecting everything first");
 }
 
+static int graph_circle_select_modal(bContext *C, wmOperator *op, const wmEvent *event)
+{
+	if (event->type == EVT_MODAL_MAP && event->val == GESTURE_MODAL_NOP)
+		graphkeys_auto_view(C);
+
+	return WM_gesture_circle_modal(C, op, event);
+}
+
 static int graph_circle_select_exec(bContext *C, wmOperator *op)
 {
 	bAnimContext ac;
@@ -552,7 +579,7 @@ void GRAPH_OT_select_circle(wmOperatorType *ot)
 	ot->idname = "GRAPH_OT_select_circle";
 	
 	ot->invoke = WM_gesture_circle_invoke;
-	ot->modal = WM_gesture_circle_modal;
+	ot->modal = graph_circle_select_modal;
 	ot->exec = graph_circle_select_exec;
 	ot->poll = graphop_visible_keyframes_poll;
 	ot->cancel = WM_gesture_circle_cancel;
@@ -725,6 +752,8 @@ static int graphkeys_columnselect_exec(bContext *C, wmOperator *op)
 	else
 		columnselect_graph_keys(&ac, mode);
 	
+	graphkeys_auto_view(C);
+	
 	/* set notifier that keyframe selection has changed */
 	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
 	
@@ -783,6 +812,8 @@ static int graphkeys_select_linked_exec(bContext *C, wmOperator *UNUSED(op))
 	/* Cleanup */
 	ANIM_animdata_freelist(&anim_data);
 	
+	graphkeys_auto_view(C);
+	
 	/* set notifier that keyframe selection has changed */
 	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
 	
@@ -807,12 +838,13 @@ void GRAPH_OT_select_linked(wmOperatorType *ot)
 /* ******************** Select More/Less Operators *********************** */
 
 /* Common code to perform selection */
-static void select_moreless_graph_keys(bAnimContext *ac, short mode)
+static void select_moreless_graph_keys(bContext *C, bAnimContext *ac, short mode)
 {
 	ListBase anim_data = {NULL, NULL};
 	bAnimListElem *ale;
 	int filter;
 	
+	const SpaceIpo *sipo = (SpaceIpo *)ac->sl;
 	KeyframeEditData ked;
 	KeyframeEditFunc build_cb;
 	
@@ -842,6 +874,24 @@ static void select_moreless_graph_keys(bAnimContext *ac, short mode)
 		/* free the selmap used here */
 		MEM_freeN(ked.data);
 		ked.data = NULL;
+		
+		/* only do auto view if a bezier point is selected */
+		if (sipo->flag & SIPO_AUTO_VIEW_SELECTED) {
+			const FCurve *fcu = (FCurve *)ale->key_data;
+			const BezTriple *bezt;
+			unsigned int i;
+
+			/* only continue if F-Curve has keyframes */
+			if (fcu->bezt == NULL)
+				continue;
+
+			for (bezt = fcu->bezt, i = 0; i < fcu->totvert; bezt++, i++) {
+				if (BEZSELECTED(bezt)) {
+					graphkeys_auto_view(C);
+					break;
+				}
+			}
+		}
 	}
 	
 	/* Cleanup */
@@ -859,7 +909,7 @@ static int graphkeys_select_more_exec(bContext *C, wmOperator *UNUSED(op))
 		return OPERATOR_CANCELLED;
 	
 	/* perform select changes */
-	select_moreless_graph_keys(&ac, SELMAP_MORE);
+	select_moreless_graph_keys(C, &ac, SELMAP_MORE);
 	
 	/* set notifier that keyframe selection has changed */
 	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
@@ -893,7 +943,7 @@ static int graphkeys_select_less_exec(bContext *C, wmOperator *UNUSED(op))
 		return OPERATOR_CANCELLED;
 	
 	/* perform select changes */
-	select_moreless_graph_keys(&ac, SELMAP_LESS);
+	select_moreless_graph_keys(C, &ac, SELMAP_LESS);
 	
 	/* set notifier that keyframe selection has changed */
 	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
@@ -1008,6 +1058,8 @@ static int graphkeys_select_leftright_exec(bContext *C, wmOperator *op)
 	/* do the selecting now */
 	graphkeys_select_leftright(&ac, leftright, selectmode);
 	
+	graphkeys_auto_view(C);
+	
 	/* set notifier that keyframe selection (and channels too) have changed */
 	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | ND_ANIMCHAN | NA_SELECTED, NULL);
 	
diff --git a/source/blender/editors/space_node/drawnode.c b/source/blender/editors/space_node/drawnode.c
index 394d148de54..c986a249663 100644
--- a/source/blender/editors/space_node/drawnode.c
+++ b/source/blender/editors/space_node/drawnode.c
@@ -2314,6 +2314,7 @@ static void node_composit_buts_trackpos(uiLayout *layout, bContext *C, PointerRN
 static void node_composit_buts_planetrackdeform(uiLayout *layout, bContext *C, PointerRNA *ptr)
 {
 	bNode *node = ptr->data;
+	NodePlaneTrackDeformData *data = node->storage;
 
 	uiTemplateID(layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL);
 
@@ -2342,6 +2343,12 @@ static void node_composit_buts_planetrackdeform(uiLayout *layout, bContext *C, P
 			uiItemR(layout, ptr, "plane_track_name", 0, "", ICON_ANIM_DATA);
 		}
 	}
+
+	uiItemR(layout, ptr, "use_motion_blur", 0, NULL, ICON_NONE);
+	if (data->flag & CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR) {
+		uiItemR(layout, ptr, "motion_blur_samples", 0, NULL, ICON_NONE);
+		uiItemR(layout, ptr, "motion_blur_shutter", 0, NULL, ICON_NONE);
+	}
 }
 
 static void node_composit_buts_cornerpin(uiLayout *UNUSED(layout), bContext *UNUSED(C), PointerRNA *UNUSED(ptr))
diff --git a/source/blender/editors/space_node/space_node.c b/source/blender/editors/space_node/space_node.c
index e3baddef158..62cb0bc73cd 100644
--- a/source/blender/editors/space_node/space_node.c
+++ b/source/blender/editors/space_node/space_node.c
@@ -668,7 +668,7 @@ static void node_main_area_draw(const bContext *C, ARegion *ar)
 static int node_ima_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent *UNUSED(event))
 {
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_IM)
 			return 1;
 	}
@@ -682,7 +682,7 @@ static int node_ima_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent *
 static int node_mask_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent *UNUSED(event))
 {
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_MSK)
 			return 1;
 	}
@@ -691,14 +691,14 @@ static int node_mask_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent
 
 static void node_id_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 
 	RNA_string_set(drop->ptr, "name", id->name + 2);
 }
 
 static void node_id_path_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 
 	if (id) {
 		RNA_string_set(drop->ptr, "name", id->name + 2);
diff --git a/source/blender/editors/space_outliner/outliner_draw.c b/source/blender/editors/space_outliner/outliner_draw.c
index ab6e371072e..3aaa1165c19 100644
--- a/source/blender/editors/space_outliner/outliner_draw.c
+++ b/source/blender/editors/space_outliner/outliner_draw.c
@@ -31,6 +31,7 @@
 
 #include "DNA_anim_types.h"
 #include "DNA_armature_types.h"
+#include "DNA_gpencil_types.h"
 #include "DNA_group_types.h"
 #include "DNA_lamp_types.h"
 #include "DNA_object_types.h"
@@ -346,6 +347,11 @@ static void restrictbutton_ebone_visibility_cb(bContext *C, void *UNUSED(poin),
 	WM_event_add_notifier(C, NC_OBJECT | ND_POSE, NULL);
 }
 
+static void restrictbutton_gp_layer_flag_cb(bContext *C, void *UNUSED(poin), void *UNUSED(poin2))
+{
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA, NULL);
+}
+
 static int group_restrict_flag(Group *gr, int flag)
 {
 	GroupObject *gob;
@@ -447,7 +453,7 @@ static void namebutton_cb(bContext *C, void *tsep, char *oldname)
 	TreeStoreElem *tselem = tsep;
 	
 	if (ts && tselem) {
-		TreeElement *te = outliner_find_tse(soops, tselem);
+		TreeElement *te = outliner_find_tree_element(&soops->tree, tselem);
 		
 		if (tselem->type == 0) {
 			test_idbutton(tselem->id->name);  // library.c, unique name and alpha sort
@@ -549,6 +555,17 @@ static void namebutton_cb(bContext *C, void *tsep, char *oldname)
 					WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
 					break;
 				}
+				case TSE_GP_LAYER:
+				{
+					bGPdata *gpd = (bGPdata *)tselem->id; // id = GP Datablock
+					bGPDlayer *gpl = te->directdata;
+					
+					// XXX: name needs translation stuff
+					BLI_uniquename(&gpd->layers, gpl, "GP Layer", '.',
+					               offsetof(bGPDlayer, info), sizeof(gpl->info));
+					WM_event_add_notifier(C, NC_GPENCIL | ND_DATA, gpd);
+					break;
+				}
 				case TSE_R_LAYER:
 					break;
 			}
@@ -742,6 +759,29 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
 
 				UI_block_emboss_set(block, UI_EMBOSS);
 			}
+			else if (tselem->type == TSE_GP_LAYER) {
+				bGPDlayer *gpl = (bGPDlayer *)te->directdata;
+				
+				UI_block_emboss_set(block, UI_EMBOSS_NONE);
+				
+				bt = uiDefIconButBitS(block, UI_BTYPE_ICON_TOGGLE, GP_LAYER_HIDE, 0, ICON_RESTRICT_VIEW_OFF,
+				                      (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX), te->ys, UI_UNIT_X,
+				                      UI_UNIT_Y, &gpl->flag, 0, 0, 0, 0,
+				                      TIP_("Restrict/Allow visibility in the 3D View"));
+				UI_but_func_set(bt, restrictbutton_gp_layer_flag_cb, NULL, gpl);
+				UI_but_flag_enable(bt, UI_BUT_DRAG_LOCK);
+				
+				bt = uiDefIconButBitS(block, UI_BTYPE_ICON_TOGGLE, GP_LAYER_LOCKED, 0, ICON_UNLOCKED,
+				                      (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX), te->ys, UI_UNIT_X,
+				                      UI_UNIT_Y, &gpl->flag, 0, 0, 0, 0,
+				                      TIP_("Restrict/Allow editing of strokes and keyframes in this layer"));
+				UI_but_func_set(bt, restrictbutton_gp_layer_flag_cb, NULL, gpl);
+				UI_but_flag_enable(bt, UI_BUT_DRAG_LOCK);
+				
+				/* TODO: visibility in renders */
+				
+				UI_block_emboss_set(block, UI_EMBOSS);
+			}
 		}
 		
 		if (TSELEM_OPEN(tselem, soops)) outliner_draw_restrictbuts(block, scene, ar, soops, &te->subtree);
@@ -877,6 +917,36 @@ static void tselem_draw_icon_uibut(struct DrawIconArg *arg, int icon)
 
 }
 
+static void tselem_draw_gp_icon_uibut(struct DrawIconArg *arg, ID *id, bGPDlayer *gpl)
+{
+	/* restrict column clip - skip it for now... */
+	if (arg->x >= arg->xmax) {
+		/* pass */
+	}
+	else {
+		PointerRNA ptr;
+		float w = 0.85f * U.widget_unit;
+		float h = 0.85f * UI_UNIT_Y;
+		
+		RNA_pointer_create(id, &RNA_GPencilLayer, gpl, &ptr);
+		
+		UI_block_align_begin(arg->block);
+		
+		UI_block_emboss_set(arg->block, RNA_boolean_get(&ptr, "is_stroke_visible") ? UI_EMBOSS : UI_EMBOSS_NONE);
+		uiDefButR(arg->block, UI_BTYPE_COLOR, 1, "", arg->xb, arg->yb, w, h,
+		          &ptr, "color", -1,
+		          0, 0, 0, 0, NULL);
+		
+		UI_block_emboss_set(arg->block, RNA_boolean_get(&ptr, "is_fill_visible") ? UI_EMBOSS : UI_EMBOSS_NONE);
+		uiDefButR(arg->block, UI_BTYPE_COLOR, 1, "", arg->xb, arg->yb, w, h,
+		          &ptr, "fill_color", -1,
+		          0, 0, 0, 0, NULL);
+		
+		UI_block_emboss_set(arg->block, UI_EMBOSS_NONE);
+		UI_block_align_end(arg->block);
+	}
+}
+
 static void tselem_draw_icon(uiBlock *block, int xmax, float x, float y, TreeStoreElem *tselem, TreeElement *te,
                              float alpha)
 {
@@ -1020,6 +1090,8 @@ static void tselem_draw_icon(uiBlock *block, int xmax, float x, float y, TreeSto
 						UI_icon_draw(x, y, ICON_MOD_MESHDEFORM); break;  /* XXX, needs own icon */
 					case eModifierType_DataTransfer:
 						UI_icon_draw(x, y, ICON_MOD_DATA_TRANSFER); break;
+					case eModifierType_NormalEdit:
+						UI_icon_draw(x, y, ICON_MOD_NORMALEDIT); break;
 					/* Default */
 					case eModifierType_None:
 					case eModifierType_ShapeKey:
@@ -1072,6 +1144,9 @@ static void tselem_draw_icon(uiBlock *block, int xmax, float x, float y, TreeSto
 				else
 					UI_icon_draw(x, y, RNA_struct_ui_icon(te->rnaptr.type));
 				break;
+			case TSE_GP_LAYER:
+				tselem_draw_gp_icon_uibut(&arg, tselem->id, te->directdata);
+				break;
 			default:
 				UI_icon_draw(x, y, ICON_DOT); break;
 		}
@@ -1165,6 +1240,8 @@ static void tselem_draw_icon(uiBlock *block, int xmax, float x, float y, TreeSto
 				tselem_draw_icon_uibut(&arg, ICON_LIBRARY_DATA_DIRECT); break;
 			case ID_LS:
 				tselem_draw_icon_uibut(&arg, ICON_LINE_DATA); break;
+			case ID_GD:
+				tselem_draw_icon_uibut(&arg, ICON_GREASEPENCIL); break;
 		}
 	}
 }
diff --git a/source/blender/editors/space_outliner/outliner_edit.c b/source/blender/editors/space_outliner/outliner_edit.c
index 9502ac50a44..d17ab33d0fa 100644
--- a/source/blender/editors/space_outliner/outliner_edit.c
+++ b/source/blender/editors/space_outliner/outliner_edit.c
@@ -50,6 +50,7 @@
 #include "BKE_report.h"
 #include "BKE_scene.h"
 #include "BKE_material.h"
+#include "BKE_group.h"
 
 #include "ED_object.h"
 #include "ED_screen.h"
@@ -97,7 +98,9 @@ static void outliner_open_reveal(SpaceOops *soops, ListBase *lb, TreeElement *te
 }
 #endif
 
-static TreeElement *outliner_dropzone_element(const SpaceOops *soops, TreeElement *te, const float fmval[2], const int children)
+static TreeElement *outliner_dropzone_element(
+        const SpaceOops *soops, TreeElement *te,
+        const float fmval[2], const bool children)
 {
 	if ((fmval[1] > te->ys) && (fmval[1] < (te->ys + UI_UNIT_Y))) {
 		/* name and first icon */
@@ -116,7 +119,7 @@ static TreeElement *outliner_dropzone_element(const SpaceOops *soops, TreeElemen
 }
 
 /* Used for drag and drop parenting */
-TreeElement *outliner_dropzone_find(const SpaceOops *soops, const float fmval[2], const int children)
+TreeElement *outliner_dropzone_find(const SpaceOops *soops, const float fmval[2], const bool children)
 {
 	TreeElement *te;
 
@@ -1502,7 +1505,7 @@ static int parent_drop_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
 
 	/* Find object hovered over */
-	te = outliner_dropzone_find(soops, fmval, 1);
+	te = outliner_dropzone_find(soops, fmval, true);
 
 	if (te) {
 		RNA_string_set(op->ptr, "parent", te->name);
@@ -1717,7 +1720,7 @@ static int scene_drop_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
 
 	/* Find object hovered over */
-	te = outliner_dropzone_find(soops, fmval, 0);
+	te = outliner_dropzone_find(soops, fmval, false);
 
 	if (te) {
 		Base *base;
@@ -1787,7 +1790,7 @@ static int material_drop_invoke(bContext *C, wmOperator *op, const wmEvent *even
 	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
 
 	/* Find object hovered over */
-	te = outliner_dropzone_find(soops, fmval, 1);
+	te = outliner_dropzone_find(soops, fmval, true);
 
 	if (te) {
 		RNA_string_set(op->ptr, "object", te->name);
@@ -1831,3 +1834,65 @@ void OUTLINER_OT_material_drop(wmOperatorType *ot)
 	RNA_def_string(ot->srna, "material", "Material", MAX_ID_NAME, "Material", "Target Material");
 }
 
+static int group_link_invoke(bContext *C, wmOperator *op, const wmEvent *event)
+{
+	Main *bmain = CTX_data_main(C);
+	Group *group = NULL;
+	Object *ob = NULL;
+	Scene *scene = CTX_data_scene(C);
+	SpaceOops *soops = CTX_wm_space_outliner(C);
+	ARegion *ar = CTX_wm_region(C);
+	TreeElement *te = NULL;
+	char ob_name[MAX_ID_NAME - 2];
+	float fmval[2];
+
+	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
+
+	/* Find object hovered over */
+	te = outliner_dropzone_find(soops, fmval, true);
+
+	if (te) {
+		group = (Group *)BKE_libblock_find_name(ID_GR, te->name);
+
+		RNA_string_get(op->ptr, "object", ob_name);
+		ob = (Object *)BKE_libblock_find_name(ID_OB, ob_name);
+
+		if (ELEM(NULL, group, ob)) {
+			return OPERATOR_CANCELLED;
+		}
+		if (BKE_group_object_exists(group, ob)) {
+			return OPERATOR_FINISHED;
+		}
+
+		if (BKE_group_object_cyclic_check(bmain, ob, group)) {
+			BKE_report(op->reports, RPT_ERROR, "Could not add the group because of dependency cycle detected");
+			return OPERATOR_CANCELLED;
+		}
+
+		BKE_group_object_add(group, ob, scene, NULL);
+		WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
+
+		return OPERATOR_FINISHED;
+	}
+
+	return OPERATOR_CANCELLED;
+}
+
+void OUTLINER_OT_group_link(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Link Object to Group";
+	ot->description = "Link Object to Group in Outliner";
+	ot->idname = "OUTLINER_OT_group_link";
+
+	/* api callbacks */
+	ot->invoke = group_link_invoke;
+
+	ot->poll = ED_operator_outliner_active;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
+
+	/* properties */
+	RNA_def_string(ot->srna, "object", "Object", MAX_ID_NAME, "Object", "Target Object");
+}
diff --git a/source/blender/editors/space_outliner/outliner_intern.h b/source/blender/editors/space_outliner/outliner_intern.h
index 317d33dd3e2..f0920466b85 100644
--- a/source/blender/editors/space_outliner/outliner_intern.h
+++ b/source/blender/editors/space_outliner/outliner_intern.h
@@ -104,6 +104,7 @@ typedef struct TreeElement {
 #define TSE_KEYMAP          34
 #define TSE_KEYMAP_ITEM     35
 #define TSE_ID_BASE			36
+#define TSE_GP_LAYER        37
 
 /* button events */
 #define OL_NAMEBUTTON       1
@@ -166,6 +167,7 @@ void outliner_free_tree(ListBase *lb);
 void outliner_cleanup_tree(struct SpaceOops *soops);
 
 TreeElement *outliner_find_tse(struct SpaceOops *soops, TreeStoreElem *tse);
+TreeElement *outliner_find_tree_element(ListBase *lb, TreeStoreElem *store_elem);
 TreeElement *outliner_find_id(struct SpaceOops *soops, ListBase *lb, struct ID *id);
 struct ID *outliner_search_back(SpaceOops *soops, TreeElement *te, short idcode);
 
@@ -205,7 +207,7 @@ void group_toggle_renderability_cb(struct bContext *C, struct Scene *scene, Tree
 
 void item_rename_cb(struct bContext *C, struct Scene *scene, TreeElement *te, struct TreeStoreElem *tsep, struct TreeStoreElem *tselem);
 
-TreeElement *outliner_dropzone_find(const struct SpaceOops *soops, const float fmval[2], const int children);
+TreeElement *outliner_dropzone_find(const struct SpaceOops *soops, const float fmval[2], const bool children);
 /* ...................................................... */
 
 void OUTLINER_OT_item_activate(struct wmOperatorType *ot);
@@ -237,6 +239,7 @@ void OUTLINER_OT_parent_drop(struct wmOperatorType *ot);
 void OUTLINER_OT_parent_clear(struct wmOperatorType *ot);
 void OUTLINER_OT_scene_drop(struct wmOperatorType *ot);
 void OUTLINER_OT_material_drop(struct wmOperatorType *ot);
+void OUTLINER_OT_group_link(struct wmOperatorType *ot);
 
 /* outliner_tools.c ---------------------------------------------- */
 
diff --git a/source/blender/editors/space_outliner/outliner_ops.c b/source/blender/editors/space_outliner/outliner_ops.c
index 4f13454ef34..d54ae3f22a7 100644
--- a/source/blender/editors/space_outliner/outliner_ops.c
+++ b/source/blender/editors/space_outliner/outliner_ops.c
@@ -77,6 +77,7 @@ void outliner_operatortypes(void)
 	WM_operatortype_append(OUTLINER_OT_parent_clear);
 	WM_operatortype_append(OUTLINER_OT_scene_drop);
 	WM_operatortype_append(OUTLINER_OT_material_drop);
+	WM_operatortype_append(OUTLINER_OT_group_link);
 }
 
 void outliner_keymap(wmKeyConfig *keyconf)
diff --git a/source/blender/editors/space_outliner/outliner_select.c b/source/blender/editors/space_outliner/outliner_select.c
index a98f57fa8ff..730ee02f448 100644
--- a/source/blender/editors/space_outliner/outliner_select.c
+++ b/source/blender/editors/space_outliner/outliner_select.c
@@ -873,6 +873,9 @@ eOLDrawState tree_element_type_active(
 			return tree_element_active_sequence_dup(scene, te, tselem, set);
 		case TSE_KEYMAP_ITEM:
 			return tree_element_active_keymap_item(C, te, tselem, set);
+		case TSE_GP_LAYER:
+			//return tree_element_active_gplayer(C, scene, te, tselem, set);
+			break;
 			
 	}
 	return OL_DRAWSEL_NONE;
@@ -915,7 +918,7 @@ static bool do_outliner_item_activate(bContext *C, Scene *scene, ARegion *ar, Sp
 			if (tselem->type != TSE_SEQUENCE && tselem->type != TSE_SEQ_STRIP && tselem->type != TSE_SEQUENCE_DUP)
 				tree_element_set_active_object(C, scene, soops, te,
 				                               (extend && tselem->type == 0) ? OL_SETSEL_EXTEND : OL_SETSEL_NORMAL,
-				                               recursive && tselem->type == 0 );
+				                               recursive && tselem->type == 0);
 			
 			if (tselem->type == 0) { // the lib blocks
 				/* editmode? */
diff --git a/source/blender/editors/space_outliner/outliner_tree.c b/source/blender/editors/space_outliner/outliner_tree.c
index c7cd4fa29d1..abc82775c8d 100644
--- a/source/blender/editors/space_outliner/outliner_tree.c
+++ b/source/blender/editors/space_outliner/outliner_tree.c
@@ -38,6 +38,7 @@
 #include "DNA_armature_types.h"
 #include "DNA_constraint_types.h"
 #include "DNA_camera_types.h"
+#include "DNA_gpencil_types.h"
 #include "DNA_group_types.h"
 #include "DNA_key_types.h"
 #include "DNA_lamp_types.h"
@@ -196,7 +197,7 @@ void outliner_cleanup_tree(SpaceOops *soops)
 }
 
 /* Find specific item from the treestore */
-static TreeElement *outliner_find_tree_element(ListBase *lb, TreeStoreElem *store_elem)
+TreeElement *outliner_find_tree_element(ListBase *lb, TreeStoreElem *store_elem)
 {
 	TreeElement *te, *tes;
 	for (te = lb->first; te; te = te->next) {
@@ -430,6 +431,8 @@ static void outliner_add_scene_contents(SpaceOops *soops, ListBase *lb, Scene *s
 	// TODO: move this to the front?
 	if (outliner_animdata_test(sce->adt))
 		outliner_add_element(soops, lb, sce, te, TSE_ANIM_DATA, 0);
+		
+	outliner_add_element(soops, lb, sce->gpd, te, 0, 0);
 	
 	outliner_add_element(soops,  lb, sce->world, te, 0, 0);
 
@@ -451,6 +454,8 @@ static void outliner_add_object_contents(SpaceOops *soops, TreeElement *te, Tree
 	
 	if (ob->proxy && ob->id.lib == NULL)
 		outliner_add_element(soops, &te->subtree, ob->proxy, te, TSE_PROXY, 0);
+		
+	outliner_add_element(soops, &te->subtree, ob->gpd, te, 0, 0);
 	
 	outliner_add_element(soops, &te->subtree, ob->data, te, 0, 0);
 	
@@ -809,6 +814,21 @@ static void outliner_add_id_contents(SpaceOops *soops, TreeElement *te, TreeStor
 			}
 			break;
 		}
+		case ID_GD:
+		{
+			bGPdata *gpd = (bGPdata *)id;
+			bGPDlayer *gpl;
+			int a = 0;
+			
+			if (outliner_animdata_test(gpd->adt))
+				outliner_add_element(soops, &te->subtree, gpd, te, TSE_ANIM_DATA, 0);
+			
+			// TODO: base element for layers?
+			for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
+				outliner_add_element(soops, &te->subtree, gpl, te, TSE_GP_LAYER, a);
+				a++;
+			}
+		}
 	}
 }
 
@@ -856,6 +876,9 @@ static TreeElement *outliner_add_element(SpaceOops *soops, ListBase *lb, void *i
 	else if (type == TSE_ANIM_DATA) {
 		/* pass */
 	}
+	else if (type == TSE_GP_LAYER) {
+		/* pass */
+	}
 	else if (type == TSE_ID_BASE) {
 		/* pass */
 	}
@@ -938,6 +961,12 @@ static TreeElement *outliner_add_element(SpaceOops *soops, ListBase *lb, void *i
 			}
 		}
 	}
+	else if (type == TSE_GP_LAYER) {
+		bGPDlayer *gpl = (bGPDlayer *)idv;
+		
+		te->name = gpl->info;
+		te->directdata = gpl;
+	}
 	else if (type == TSE_SEQUENCE) {
 		Sequence *seq = (Sequence *) idv;
 		Sequence *p;
diff --git a/source/blender/editors/space_outliner/space_outliner.c b/source/blender/editors/space_outliner/space_outliner.c
index 504d9628d98..30de9c16500 100644
--- a/source/blender/editors/space_outliner/space_outliner.c
+++ b/source/blender/editors/space_outliner/space_outliner.c
@@ -98,10 +98,10 @@ static int outliner_parent_drop_poll(bContext *C, wmDrag *drag, const wmEvent *e
 	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
 
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_OB) {
 			/* Ensure item under cursor is valid drop target */
-			TreeElement *te = outliner_dropzone_find(soops, fmval, 1);
+			TreeElement *te = outliner_dropzone_find(soops, fmval, true);
 
 			if (te && te->idcode == ID_OB && TREESTORE(te)->type == 0) {
 				Scene *scene;
@@ -129,7 +129,7 @@ static int outliner_parent_drop_poll(bContext *C, wmDrag *drag, const wmEvent *e
 
 static void outliner_parent_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 
 	RNA_string_set(drop->ptr, "child", id->name + 2);
 }
@@ -148,10 +148,10 @@ static int outliner_parent_clear_poll(bContext *C, wmDrag *drag, const wmEvent *
 	}
 
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_OB) {
 			if (((Object *)id)->parent) {
-				if ((te = outliner_dropzone_find(soops, fmval, 1))) {
+				if ((te = outliner_dropzone_find(soops, fmval, true))) {
 					TreeStoreElem *tselem = TREESTORE(te);
 
 					switch (te->idcode) {
@@ -171,7 +171,7 @@ static int outliner_parent_clear_poll(bContext *C, wmDrag *drag, const wmEvent *
 
 static void outliner_parent_clear_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 	RNA_string_set(drop->ptr, "dragged_obj", id->name + 2);
 
 	/* Set to simple parent clear type. Avoid menus for drag and drop if possible.
@@ -188,10 +188,10 @@ static int outliner_scene_drop_poll(bContext *C, wmDrag *drag, const wmEvent *ev
 	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
 
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_OB) {
 			/* Ensure item under cursor is valid drop target */
-			TreeElement *te = outliner_dropzone_find(soops, fmval, 0);
+			TreeElement *te = outliner_dropzone_find(soops, fmval, false);
 			return (te && te->idcode == ID_SCE && TREESTORE(te)->type == 0);
 		}
 	}
@@ -200,7 +200,7 @@ static int outliner_scene_drop_poll(bContext *C, wmDrag *drag, const wmEvent *ev
 
 static void outliner_scene_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 
 	RNA_string_set(drop->ptr, "object", id->name + 2);
 }
@@ -213,10 +213,10 @@ static int outliner_material_drop_poll(bContext *C, wmDrag *drag, const wmEvent
 	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
 
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_MA) {
 			/* Ensure item under cursor is valid drop target */
-			TreeElement *te = outliner_dropzone_find(soops, fmval, 1);
+			TreeElement *te = outliner_dropzone_find(soops, fmval, true);
 			return (te && te->idcode == ID_OB && TREESTORE(te)->type == 0);
 		}
 	}
@@ -225,11 +225,35 @@ static int outliner_material_drop_poll(bContext *C, wmDrag *drag, const wmEvent
 
 static void outliner_material_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 
 	RNA_string_set(drop->ptr, "material", id->name + 2);
 }
 
+static int outliner_group_link_poll(bContext *C, wmDrag *drag, const wmEvent *event)
+{
+	ARegion *ar = CTX_wm_region(C);
+	SpaceOops *soops = CTX_wm_space_outliner(C);
+	float fmval[2];
+	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
+
+	if (drag->type == WM_DRAG_ID) {
+		ID *id = drag->poin;
+		if (GS(id->name) == ID_OB) {
+			/* Ensure item under cursor is valid drop target */
+			TreeElement *te = outliner_dropzone_find(soops, fmval, true);
+			return (te && te->idcode == ID_GR && TREESTORE(te)->type == 0);
+		}
+	}
+	return 0;
+}
+
+static void outliner_group_link_copy(wmDrag *drag, wmDropBox *drop)
+{
+	ID *id = drag->poin;
+	RNA_string_set(drop->ptr, "object", id->name + 2);
+}
+
 /* region dropbox definition */
 static void outliner_dropboxes(void)
 {
@@ -239,6 +263,7 @@ static void outliner_dropboxes(void)
 	WM_dropbox_add(lb, "OUTLINER_OT_parent_clear", outliner_parent_clear_poll, outliner_parent_clear_copy);
 	WM_dropbox_add(lb, "OUTLINER_OT_scene_drop", outliner_scene_drop_poll, outliner_scene_drop_copy);
 	WM_dropbox_add(lb, "OUTLINER_OT_material_drop", outliner_material_drop_poll, outliner_material_drop_copy);
+	WM_dropbox_add(lb, "OUTLINER_OT_group_link", outliner_group_link_poll, outliner_group_link_copy);
 }
 
 static void outliner_main_area_draw(const bContext *C, ARegion *ar)
@@ -362,6 +387,13 @@ static void outliner_main_area_listener(bScreen *UNUSED(sc), ScrArea *UNUSED(sa)
 					break;
 			}
 			break;
+		case NC_GPENCIL:
+			switch (wmn->data) {
+				case ND_DATA:
+					ED_region_tag_redraw(ar);
+					break;
+			}
+			break;
 	}
 	
 }
diff --git a/source/blender/editors/space_sequencer/sequencer_edit.c b/source/blender/editors/space_sequencer/sequencer_edit.c
index fcb35bc86f2..8d4a82fc02c 100644
--- a/source/blender/editors/space_sequencer/sequencer_edit.c
+++ b/source/blender/editors/space_sequencer/sequencer_edit.c
@@ -59,6 +59,7 @@
 
 /* for menu/popup icons etc etc*/
 
+#include "ED_numinput.h"
 #include "ED_screen.h"
 #include "ED_transform.h"
 #include "ED_sequencer.h"
@@ -1269,6 +1270,7 @@ typedef struct SlipData {
 	bool slow;
 	int slow_offset; /* offset at the point where offset was turned on */
 	void *draw_handle;
+	NumInput num_input;
 } SlipData;
 
 static void transseq_backup(TransSeq *ts, Sequence *seq)
@@ -1382,6 +1384,13 @@ static int sequencer_slip_invoke(bContext *C, wmOperator *op, const wmEvent *eve
 	data->trim = MEM_mallocN(num_seq * sizeof(bool), "trimdata_trim");
 	data->num_seq = num_seq;
 
+	initNumInput(&data->num_input);
+	data->num_input.idx_max = 0;
+	data->num_input.val_flag[0] |= NUM_NO_FRACTION;
+	data->num_input.unit_sys = USER_UNIT_NONE;
+	data->num_input.unit_type[0] = 0;
+
+
 	slip_add_sequences_rec(ed->seqbasep, data->seq_array, data->trim, 0, true);
 
 	for (i = 0; i < num_seq; i++) {
@@ -1507,47 +1516,83 @@ static int sequencer_slip_exec(bContext *C, wmOperator *op)
 	}
 }
 
+
+static void sequencer_slip_update_header(Scene *scene, ScrArea *sa, SlipData *data, int offset)
+{
+#define HEADER_LENGTH 40
+	char msg[HEADER_LENGTH];
+
+	if (sa) {
+		if (hasNumInput(&data->num_input)) {
+			char num_str[NUM_STR_REP_LEN];
+			outputNumInput(&data->num_input, num_str, &scene->unit);
+			BLI_snprintf(msg, HEADER_LENGTH, "Trim offset: %s", num_str);
+		}
+		else {
+			BLI_snprintf(msg, HEADER_LENGTH, "Trim offset: %d", offset);
+		}
+	}
+
+	ED_area_headerprint(sa, msg);
+
+#undef HEADER_LENGTH
+}
+
 static int sequencer_slip_modal(bContext *C, wmOperator *op, const wmEvent *event)
 {
 	Scene *scene = CTX_data_scene(C);
 	SlipData *data = (SlipData *)op->customdata;
 	ScrArea *sa = CTX_wm_area(C);
 	ARegion *ar = CTX_wm_region(C);
+	const bool has_numInput = hasNumInput(&data->num_input);
+	bool handled = true;
+
+	/* Modal numinput active, try to handle numeric inputs first... */
+	if (event->val == KM_PRESS && has_numInput && handleNumInput(C, &data->num_input, event)) {
+		float offset;
+		applyNumInput(&data->num_input, &offset);
+
+		sequencer_slip_update_header(scene, sa, data, (int)offset);
+
+		RNA_int_set(op->ptr, "offset", offset);
+
+		if (sequencer_slip_recursively(scene, data, offset)) {
+			WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
+		}
+
+		return OPERATOR_RUNNING_MODAL;
+	}
 
 	switch (event->type) {
 		case MOUSEMOVE:
 		{
-			float mouseloc[2];
-			int offset;
-			int mouse_x;
-			View2D *v2d = UI_view2d_fromcontext(C);
-
-			if (data->slow) {
-				mouse_x = event->mval[0] - data->slow_offset;
-				mouse_x *= 0.1f;
-				mouse_x += data->slow_offset;
-			}
-			else {
-				mouse_x = event->mval[0];
-			}
+			if (!has_numInput) {
+				float mouseloc[2];
+				int offset;
+				int mouse_x;
+				View2D *v2d = UI_view2d_fromcontext(C);
+
+				if (data->slow) {
+					mouse_x = event->mval[0] - data->slow_offset;
+					mouse_x *= 0.1f;
+					mouse_x += data->slow_offset;
+				}
+				else {
+					mouse_x = event->mval[0];
+				}
 
 
-			/* choose the side based on which side of the playhead the mouse is on */
-			UI_view2d_region_to_view(v2d, mouse_x, 0, &mouseloc[0], &mouseloc[1]);
-			offset = mouseloc[0] - data->init_mouseloc[0];
+				/* choose the side based on which side of the playhead the mouse is on */
+				UI_view2d_region_to_view(v2d, mouse_x, 0, &mouseloc[0], &mouseloc[1]);
+				offset = mouseloc[0] - data->init_mouseloc[0];
 
-			RNA_int_set(op->ptr, "offset", offset);
+				sequencer_slip_update_header(scene, sa, data, offset);
 
-			if (sa) {
-#define HEADER_LENGTH 40
-				char msg[HEADER_LENGTH];
-				BLI_snprintf(msg, HEADER_LENGTH, "Trim offset: %d", offset);
-#undef HEADER_LENGTH
-				ED_area_headerprint(sa, msg);
-			}
+				RNA_int_set(op->ptr, "offset", offset);
 
-			if (sequencer_slip_recursively(scene, data, offset)) {
-				WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
+				if (sequencer_slip_recursively(scene, data, offset)) {
+					WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
+				}
 			}
 			break;
 		}
@@ -1604,19 +1649,36 @@ static int sequencer_slip_modal(bContext *C, wmOperator *op, const wmEvent *even
 
 		case RIGHTSHIFTKEY:
 		case LEFTSHIFTKEY:
-			if (event->val == KM_PRESS) {
-				data->slow = true;
-				data->slow_offset = event->mval[0];
-			}
-			else if (event->val == KM_RELEASE) {
-				data->slow = false;
+			if (!has_numInput) {
+				if (event->val == KM_PRESS) {
+					data->slow = true;
+					data->slow_offset = event->mval[0];
+				}
+				else if (event->val == KM_RELEASE) {
+					data->slow = false;
+				}
 			}
 			break;
 
 		default:
+			handled = false;
 			break;
 	}
 
+	/* Modal numinput inactive, try to handle numeric inputs last... */
+	if (!handled && event->val == KM_PRESS && handleNumInput(C, &data->num_input, event)) {
+		float offset;
+		applyNumInput(&data->num_input, &offset);
+
+		sequencer_slip_update_header(scene, sa, data, (int)offset);
+
+		RNA_int_set(op->ptr, "offset", offset);
+
+		if (sequencer_slip_recursively(scene, data, offset)) {
+			WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
+		}
+	}
+
 	return OPERATOR_RUNNING_MODAL;
 }
 
diff --git a/source/blender/editors/space_sequencer/space_sequencer.c b/source/blender/editors/space_sequencer/space_sequencer.c
index 4d97056c4c5..7be356dd2ec 100644
--- a/source/blender/editors/space_sequencer/space_sequencer.c
+++ b/source/blender/editors/space_sequencer/space_sequencer.c
@@ -504,6 +504,13 @@ static void sequencer_main_area_listener(bScreen *UNUSED(sc), ScrArea *UNUSED(sa
 					break;
 			}
 			break;
+		case NC_ANIMATION:
+			switch (wmn->data) {
+				case ND_KEYFRAME:
+					ED_region_tag_redraw(ar);
+					break;
+			}
+			break;
 		case NC_SPACE:
 			if (wmn->data == ND_SPACE_SEQUENCER)
 				ED_region_tag_redraw(ar);
@@ -604,6 +611,15 @@ static void sequencer_preview_area_listener(bScreen *UNUSED(sc), ScrArea *UNUSED
 					break;
 			}
 			break;
+		case NC_ANIMATION:
+			switch (wmn->data) {
+				case ND_KEYFRAME:
+					/* Otherwise, often prevents seing immediately effects of keyframe editing... */
+					BKE_sequencer_cache_cleanup();
+					ED_region_tag_redraw(ar);
+					break;
+			}
+			break;
 		case NC_SPACE:
 			if (wmn->data == ND_SPACE_SEQUENCER)
 				ED_region_tag_redraw(ar);
diff --git a/source/blender/editors/space_text/text_autocomplete.c b/source/blender/editors/space_text/text_autocomplete.c
index 19af71c9139..1637ae14892 100644
--- a/source/blender/editors/space_text/text_autocomplete.c
+++ b/source/blender/editors/space_text/text_autocomplete.c
@@ -207,18 +207,16 @@ static GHash *text_autocomplete_build(Text *text)
 		}
 
 		{
-			GHashIterator *iter = BLI_ghashIterator_new(gh);
+			GHashIterator gh_iter;
 
 			/* get the formatter for highlighting */
 			TextFormatType *tft;
 			tft = ED_text_format_get(text);
 
-			for (; !BLI_ghashIterator_done(iter); BLI_ghashIterator_step(iter)) {
-				const char *s = BLI_ghashIterator_getValue(iter);
+			GHASH_ITER (gh_iter, gh) {
+				const char *s = BLI_ghashIterator_getValue(&gh_iter);
 				texttool_suggest_add(s, tft->format_identifier(s));
 			}
-			BLI_ghashIterator_free(iter);
-
 		}
 	}
 
diff --git a/source/blender/editors/space_view3d/drawobject.c b/source/blender/editors/space_view3d/drawobject.c
index 5db42909a6d..01a70d36eda 100644
--- a/source/blender/editors/space_view3d/drawobject.c
+++ b/source/blender/editors/space_view3d/drawobject.c
@@ -740,6 +740,8 @@ static void drawcentercircle(View3D *v3d, RegionView3D *rv3d, const float co[3],
 	/* using gldepthfunc guarantees that it does write z values,
 	 * but not checks for it, so centers remain visible independent order of drawing */
 	if (v3d->zbuf) glDepthFunc(GL_ALWAYS);
+	/* write to near buffer always */
+	glDepthRange(0.0, 0.0);
 	glEnable(GL_BLEND);
 	
 	if (special_color) {
@@ -769,6 +771,7 @@ static void drawcentercircle(View3D *v3d, RegionView3D *rv3d, const float co[3],
 	/* finish up */
 	glDisableClientState(GL_VERTEX_ARRAY);
 
+	glDepthRange(0.0, 1.0);
 	glDisable(GL_BLEND);
 
 	if (v3d->zbuf) glDepthFunc(GL_LEQUAL);
diff --git a/source/blender/editors/space_view3d/space_view3d.c b/source/blender/editors/space_view3d/space_view3d.c
index f15817c93c3..a71fbbdd5cf 100644
--- a/source/blender/editors/space_view3d/space_view3d.c
+++ b/source/blender/editors/space_view3d/space_view3d.c
@@ -584,7 +584,7 @@ static void view3d_main_area_exit(wmWindowManager *wm, ARegion *ar)
 static int view3d_ob_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent *UNUSED(event))
 {
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_OB)
 			return 1;
 	}
@@ -594,7 +594,7 @@ static int view3d_ob_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent
 static int view3d_group_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent *UNUSED(event))
 {
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_GR)
 			return 1;
 	}
@@ -604,7 +604,7 @@ static int view3d_group_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEve
 static int view3d_mat_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent *UNUSED(event))
 {
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_MA)
 			return 1;
 	}
@@ -614,7 +614,7 @@ static int view3d_mat_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent
 static int view3d_ima_drop_poll(bContext *UNUSED(C), wmDrag *drag, const wmEvent *UNUSED(event))
 {
 	if (drag->type == WM_DRAG_ID) {
-		ID *id = (ID *)drag->poin;
+		ID *id = drag->poin;
 		if (GS(id->name) == ID_IM)
 			return 1;
 	}
@@ -661,14 +661,14 @@ static int view3d_ima_mesh_drop_poll(bContext *C, wmDrag *drag, const wmEvent *e
 
 static void view3d_ob_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 
 	RNA_string_set(drop->ptr, "name", id->name + 2);
 }
 
 static void view3d_group_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 	
 	drop->opcontext = WM_OP_EXEC_DEFAULT;
 	RNA_string_set(drop->ptr, "name", id->name + 2);
@@ -676,14 +676,14 @@ static void view3d_group_drop_copy(wmDrag *drag, wmDropBox *drop)
 
 static void view3d_id_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 	
 	RNA_string_set(drop->ptr, "name", id->name + 2);
 }
 
 static void view3d_id_path_drop_copy(wmDrag *drag, wmDropBox *drop)
 {
-	ID *id = (ID *)drag->poin;
+	ID *id = drag->poin;
 	
 	if (id) {
 		RNA_string_set(drop->ptr, "name", id->name + 2);
diff --git a/source/blender/editors/space_view3d/view3d_draw.c b/source/blender/editors/space_view3d/view3d_draw.c
index 7b3cf406141..59c6f2ca21c 100644
--- a/source/blender/editors/space_view3d/view3d_draw.c
+++ b/source/blender/editors/space_view3d/view3d_draw.c
@@ -1617,7 +1617,7 @@ static void view3d_draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d,
 		{
 			float image_aspect[2];
 			float fac, asp, zoomx, zoomy;
-			float x1, y1, x2, y2;
+			float x1, y1, x2, y2, centx, centy;
 
 			ImBuf *ibuf = NULL, *freeibuf, *releaseibuf;
 			void *lock;
@@ -1723,6 +1723,9 @@ static void view3d_draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d,
 					y2 += yof_scale;
 				}
 
+				centx = (x1 + x2) / 2.0f;
+				centy = (y1 + y2) / 2.0f;
+
 				/* aspect correction */
 				if (bgpic->flag & V3D_BGPIC_CAMERA_ASPECT) {
 					/* apply aspect from clip */
@@ -1740,16 +1743,14 @@ static void view3d_draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d,
 						if ((asp_src > asp_dst) == ((bgpic->flag & V3D_BGPIC_CAMERA_CROP) != 0)) {
 							/* fit X */
 							const float div = asp_src / asp_dst;
-							const float cent = (x1 + x2) / 2.0f;
-							x1 = ((x1 - cent) * div) + cent;
-							x2 = ((x2 - cent) * div) + cent;
+							x1 = ((x1 - centx) * div) + centx;
+							x2 = ((x2 - centx) * div) + centx;
 						}
 						else {
 							/* fit Y */
 							const float div = asp_dst / asp_src;
-							const float cent = (y1 + y2) / 2.0f;
-							y1 = ((y1 - cent) * div) + cent;
-							y2 = ((y2 - cent) * div) + cent;
+							y1 = ((y1 - centy) * div) + centy;
+							y2 = ((y2 - centy) * div) + centy;
 						}
 					}
 				}
@@ -1776,6 +1777,9 @@ static void view3d_draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d,
 				y1 =  sco[1] + asp * fac * (bgpic->yof - bgpic->size);
 				x2 =  sco[0] + fac * (bgpic->xof + bgpic->size);
 				y2 =  sco[1] + asp * fac * (bgpic->yof + bgpic->size);
+
+				centx = (x1 + x2) / 2.0f;
+				centy = (y1 + y2) / 2.0f;
 			}
 
 			/* complete clip? */
@@ -1826,6 +1830,19 @@ static void view3d_draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d,
 			glPushMatrix();
 			ED_region_pixelspace(ar);
 
+			glTranslatef(centx, centy, 0.0);
+			if (rv3d->persp != RV3D_CAMOB) {
+				glRotatef(RAD2DEGF(-bgpic->rotation), 0.0f, 0.0f, 1.0f);
+			}
+
+			if (bgpic->flag & V3D_BGPIC_FLIP_X) {
+				zoomx *= -1.0f;
+				x1 = x2;
+			}
+			if (bgpic->flag & V3D_BGPIC_FLIP_Y) {
+				zoomy *= -1.0f;
+				y1 = y2;
+			}
 			glPixelZoom(zoomx, zoomy);
 			glColor4f(1.0f, 1.0f, 1.0f, 1.0f - bgpic->blend);
 
@@ -1833,7 +1850,7 @@ static void view3d_draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d,
 			 * glaDrawPixelsSafe in some cases, which will end up in missing
 			 * alpha transparency for the background image (sergey)
 			 */
-			glaDrawPixelsTex(x1, y1, ibuf->x, ibuf->y, GL_RGBA, GL_UNSIGNED_BYTE, GL_LINEAR, ibuf->rect);
+			glaDrawPixelsTex(x1 - centx, y1 - centy, ibuf->x, ibuf->y, GL_RGBA, GL_UNSIGNED_BYTE, GL_LINEAR, ibuf->rect);
 
 			glPixelZoom(1.0, 1.0);
 			glPixelTransferf(GL_ALPHA_SCALE, 1.0f);
diff --git a/source/blender/editors/space_view3d/view3d_edit.c b/source/blender/editors/space_view3d/view3d_edit.c
index 7a1cd88ba49..e6f61fb4aca 100644
--- a/source/blender/editors/space_view3d/view3d_edit.c
+++ b/source/blender/editors/space_view3d/view3d_edit.c
@@ -5004,8 +5004,9 @@ BGpic *ED_view3D_background_image_new(View3D *v3d)
 {
 	BGpic *bgpic = MEM_callocN(sizeof(BGpic), "Background Image");
 
-	bgpic->size = 5.0;
-	bgpic->blend = 0.5;
+	bgpic->rotation = 0.0f;
+	bgpic->size = 5.0f;
+	bgpic->blend = 0.5f;
 	bgpic->iuser.fie_ima = 2;
 	bgpic->iuser.ok = 1;
 	bgpic->view = 0; /* 0 for all */
diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c
index 2679cf1992e..14bbdebd138 100644
--- a/source/blender/editors/transform/transform.c
+++ b/source/blender/editors/transform/transform.c
@@ -93,8 +93,8 @@
 #define MAX_INFO_LEN 256
 
 static void drawTransformApply(const struct bContext *C, ARegion *ar, void *arg);
-static int doEdgeSlide(TransInfo *t, float perc);
-static int doVertSlide(TransInfo *t, float perc);
+static void doEdgeSlide(TransInfo *t, float perc);
+static void doVertSlide(TransInfo *t, float perc);
 
 static void drawEdgeSlide(const struct bContext *C, TransInfo *t);
 static void drawVertSlide(const struct bContext *C, TransInfo *t);
@@ -671,8 +671,11 @@ static void viewRedrawPost(bContext *C, TransInfo *t)
 			WM_main_add_notifier(NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
 
 		/* redraw UV editor */
-		if (t->mode == TFM_EDGE_SLIDE && (t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT))
+		if (ELEM(t->mode, TFM_VERT_SLIDE, TFM_EDGE_SLIDE) &&
+		    (t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT))
+		{
 			WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
+		}
 		
 		/* XXX temp, first hack to get auto-render in compositor work (ton) */
 		WM_event_add_notifier(C, NC_SCENE | ND_TRANSFORM_DONE, CTX_data_scene(C));
@@ -5110,6 +5113,85 @@ static void applyBoneEnvelope(TransInfo *t, const int UNUSED(mval[2]))
 }
 /** \} */
 
+/* -------------------------------------------------------------------- */
+/* Original Data Store */
+
+/** \name Orig-Data Store Utility Functions
+ * \{ */
+
+static void slide_origdata_init_flag(
+        TransInfo *t, SlideOrigData *sod)
+{
+	BMEditMesh *em = BKE_editmesh_from_object(t->obedit);
+	BMesh *bm = em->bm;
+
+	if ((t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT) &&
+	    /* don't do this at all for non-basis shape keys, too easy to
+	     * accidentally break uv maps or vertex colors then */
+	    (bm->shapenr <= 1))
+	{
+		sod->use_origfaces = true;
+	}
+	else {
+		sod->use_origfaces = false;
+	}
+}
+
+static void slide_origdata_init_data(
+        TransInfo *t, SlideOrigData *sod)
+{
+	if (sod->use_origfaces) {
+		BMEditMesh *em = BKE_editmesh_from_object(t->obedit);
+		BMesh *bm = em->bm;
+
+		sod->origfaces = BLI_ghash_ptr_new(__func__);
+		sod->bm_origfaces = BM_mesh_create(&bm_mesh_allocsize_default);
+		/* we need to have matching customdata */
+		BM_mesh_copy_init_customdata(sod->bm_origfaces, bm, NULL);
+	}
+}
+
+static void slide_origdata_create_date(
+        TransInfo *t, SlideOrigData *sod,
+        BMVert **v_pt, unsigned int v_stride, unsigned int v_num)
+{
+	if (sod->use_origfaces) {
+		BMEditMesh *em = BKE_editmesh_from_object(t->obedit);
+		BMesh *bm = em->bm;
+
+		unsigned int i;
+		for (i = 0; i < v_num; i++, v_pt = (void *)(((char *)v_pt) + v_stride)) {
+			BMIter fiter;
+			BMFace *f;
+			BMVert *v = *v_pt;
+
+			BM_ITER_ELEM (f, &fiter, v, BM_FACES_OF_VERT) {
+				if (!BLI_ghash_haskey(sod->origfaces, f)) {
+					BMFace *f_copy = BM_face_copy(sod->bm_origfaces, bm, f, true, true);
+					BLI_ghash_insert(sod->origfaces, f, f_copy);
+				}
+			}
+		}
+	}
+}
+
+static void slide_origdata_free_date(
+        SlideOrigData *sod)
+{
+	if (sod->use_origfaces) {
+		if (sod->bm_origfaces) {
+			BM_mesh_free(sod->bm_origfaces);
+			sod->bm_origfaces = NULL;
+		}
+
+		if (sod->origfaces) {
+			BLI_ghash_free(sod->origfaces, NULL, NULL);
+			sod->origfaces = NULL;
+		}
+	}
+}
+
+/** \} */
 
 /* -------------------------------------------------------------------- */
 /* Transform (Edge Slide) */
@@ -5368,16 +5450,7 @@ static bool createEdgeSlideVerts(TransInfo *t)
 		rv3d = t->ar ? t->ar->regiondata : NULL;
 	}
 
-	if ((t->settings->uvcalc_flag & UVCALC_TRANSFORM_CORRECT) &&
-	    /* don't do this at all for non-basis shape keys, too easy to
-	     * accidentally break uv maps or vertex colors then */
-	    (bm->shapenr <= 1))
-	{
-		sld->use_origfaces = true;
-	}
-	else {
-		sld->use_origfaces = false;
-	}
+	slide_origdata_init_flag(t, &sld->orig_data);
 
 	sld->is_proportional = true;
 	sld->curr_sv_index = 0;
@@ -5769,30 +5842,12 @@ static bool createEdgeSlideVerts(TransInfo *t)
 	}
 
 	bmesh_edit_begin(bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
-
-	if (sld->use_origfaces) {
-		sld->origfaces = BLI_ghash_ptr_new(__func__);
-		sld->bm_origfaces = BM_mesh_create(&bm_mesh_allocsize_default);
-		/* we need to have matching customdata */
-		BM_mesh_copy_init_customdata(sld->bm_origfaces, bm, NULL);
-	}
+	slide_origdata_init_data(t, &sld->orig_data);
+	slide_origdata_create_date(t, &sld->orig_data, &sld->sv->v, sizeof(*sld->sv), sld->totsv);
 
 	/*create copies of faces for customdata projection*/
 	sv_array = sld->sv;
 	for (i = 0; i < sld->totsv; i++, sv_array++) {
-		BMIter fiter;
-		BMFace *f;
-		
-
-		if (sld->use_origfaces) {
-			BM_ITER_ELEM (f, &fiter, sv_array->v, BM_FACES_OF_VERT) {
-				if (!BLI_ghash_haskey(sld->origfaces, f)) {
-					BMFace *f_copy = BM_face_copy(sld->bm_origfaces, bm, f, true, true);
-					BLI_ghash_insert(sld->origfaces, f, f_copy);
-				}
-			}
-		}
-
 		/* switch a/b if loop direction is different from global direction */
 		l_nr = sv_array->loop_nr;
 		if (dot_v3v3(loop_dir[l_nr], mval_dir) < 0.0f) {
@@ -5836,11 +5891,12 @@ static bool createEdgeSlideVerts(TransInfo *t)
 void projectEdgeSlideData(TransInfo *t, bool is_final)
 {
 	EdgeSlideData *sld = t->customData;
+	SlideOrigData *sod = &sld->orig_data;
 	TransDataEdgeSlideVert *sv;
 	BMEditMesh *em = sld->em;
 	int i;
 
-	if (sld->use_origfaces == false) {
+	if (sod->use_origfaces == false) {
 		return;
 	}
 
@@ -5852,7 +5908,7 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
 			BMFace *f_copy;      /* the copy of 'f' */
 			BMFace *f_copy_flip; /* the copy of 'f' or detect if we need to flip to the shorter side. */
 			
-			f_copy = BLI_ghash_lookup(sld->origfaces, l->f);
+			f_copy = BLI_ghash_lookup(sod->origfaces, l->f);
 			
 			/* project onto copied projection face */
 			f_copy_flip = f_copy;
@@ -5866,12 +5922,12 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
 
 				if (sld->perc < 0.0f) {
 					if (BM_vert_in_face(sv->v_b, l_ed_sel->radial_next->f)) {
-						f_copy_flip = BLI_ghash_lookup(sld->origfaces, l_ed_sel->radial_next->f);
+						f_copy_flip = BLI_ghash_lookup(sod->origfaces, l_ed_sel->radial_next->f);
 					}
 				}
 				else if (sld->perc > 0.0f) {
 					if (BM_vert_in_face(sv->v_a, l_ed_sel->radial_next->f)) {
-						f_copy_flip = BLI_ghash_lookup(sld->origfaces, l_ed_sel->radial_next->f);
+						f_copy_flip = BLI_ghash_lookup(sod->origfaces, l_ed_sel->radial_next->f);
 					}
 				}
 
@@ -5957,7 +6013,7 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
 							l_adj = l;
 						}
 
-						f_copy_flip = BLI_ghash_lookup(sld->origfaces, l_adj->f);
+						f_copy_flip = BLI_ghash_lookup(sod->origfaces, l_adj->f);
 					}
 				}
 			}
@@ -5974,34 +6030,23 @@ void projectEdgeSlideData(TransInfo *t, bool is_final)
 			}
 			
 			/* make sure face-attributes are correct (e.g. MTexPoly) */
-			BM_elem_attrs_copy(sld->bm_origfaces, em->bm, f_copy, l->f);
+			BM_elem_attrs_copy(sod->bm_origfaces, em->bm, f_copy, l->f);
 		}
 	}
 }
 
 void freeEdgeSlideTempFaces(EdgeSlideData *sld)
 {
-	if (sld->use_origfaces) {
-		if (sld->bm_origfaces) {
-			BM_mesh_free(sld->bm_origfaces);
-			sld->bm_origfaces = NULL;
-		}
-
-		if (sld->origfaces) {
-			BLI_ghash_free(sld->origfaces, NULL, NULL);
-			sld->origfaces = NULL;
-		}
-	}
+	slide_origdata_free_date(&sld->orig_data);
 }
 
-
 void freeEdgeSlideVerts(TransInfo *t)
 {
 	EdgeSlideData *sld = t->customData;
 	
 	if (!sld)
 		return;
-	
+
 	freeEdgeSlideTempFaces(sld);
 
 	bmesh_edit_end(sld->em->bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
@@ -6175,7 +6220,7 @@ static void drawEdgeSlide(const struct bContext *C, TransInfo *t)
 	}
 }
 
-static int doEdgeSlide(TransInfo *t, float perc)
+static void doEdgeSlide(TransInfo *t, float perc)
 {
 	EdgeSlideData *sld = t->customData;
 	TransDataEdgeSlideVert *svlist = sld->sv, *sv;
@@ -6232,8 +6277,6 @@ static int doEdgeSlide(TransInfo *t, float perc)
 	}
 	
 	projectEdgeSlideData(t, 0);
-	
-	return 1;
 }
 
 static void applyEdgeSlide(TransInfo *t, const int UNUSED(mval[2]))
@@ -6398,6 +6441,8 @@ static bool createVertSlideVerts(TransInfo *t)
 		rv3d = ar ? ar->regiondata : NULL;
 	}
 
+	slide_origdata_init_flag(t, &sld->orig_data);
+
 	sld->is_proportional = true;
 	sld->curr_sv_index = 0;
 	sld->flipped_vtx = false;
@@ -6493,6 +6538,10 @@ static bool createVertSlideVerts(TransInfo *t)
 	sld->sv = sv_array;
 	sld->totsv = j;
 
+	bmesh_edit_begin(bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
+	slide_origdata_init_data(t, &sld->orig_data);
+	slide_origdata_create_date(t, &sld->orig_data, &sld->sv->v, sizeof(*sld->sv), sld->totsv);
+
 	sld->em = em;
 
 	sld->perc = 0.0f;
@@ -6507,6 +6556,53 @@ static bool createVertSlideVerts(TransInfo *t)
 	return true;
 }
 
+void projectVertSlideData(TransInfo *t, bool is_final)
+{
+	VertSlideData *sld = t->customData;
+	SlideOrigData *sod = &sld->orig_data;
+	TransDataVertSlideVert *sv;
+	BMEditMesh *em = sld->em;
+	int i;
+
+	if (sod->use_origfaces == false) {
+		return;
+	}
+
+	for (i = 0, sv = sld->sv; i < sld->totsv; sv++, i++) {
+		BMIter fiter;
+		BMLoop *l;
+
+		BM_ITER_ELEM (l, &fiter, sv->v, BM_LOOPS_OF_VERT) {
+			BMFace *f_copy;      /* the copy of 'f' */
+			BMFace *f_copy_flip; /* the copy of 'f' or detect if we need to flip to the shorter side. */
+
+			f_copy = BLI_ghash_lookup(sod->origfaces, l->f);
+
+			/* project onto copied projection face */
+			f_copy_flip = f_copy;
+
+			/* only loop data, no vertex data since that contains shape keys,
+			 * and we do not want to mess up other shape keys */
+			BM_loop_interp_from_face(em->bm, l, f_copy_flip, false, false);
+
+			if (is_final) {
+				BM_loop_interp_multires(em->bm, l, f_copy_flip);
+				if (f_copy != f_copy_flip) {
+					BM_loop_interp_multires(em->bm, l, f_copy);
+				}
+			}
+
+			/* make sure face-attributes are correct (e.g. MTexPoly) */
+			BM_elem_attrs_copy(sod->bm_origfaces, em->bm, f_copy, l->f);
+		}
+	}
+}
+
+void freeVertSlideTempFaces(VertSlideData *sld)
+{
+	slide_origdata_free_date(&sld->orig_data);
+}
+
 void freeVertSlideVerts(TransInfo *t)
 {
 	VertSlideData *sld = t->customData;
@@ -6514,6 +6610,9 @@ void freeVertSlideVerts(TransInfo *t)
 	if (!sld)
 		return;
 
+	freeVertSlideTempFaces(sld);
+
+	bmesh_edit_end(sld->em->bm, BMO_OPTYPE_FLAG_UNTAN_MULTIRES);
 
 	if (sld->totsv > 0) {
 		TransDataVertSlideVert *sv = sld->sv;
@@ -6710,7 +6809,7 @@ static void drawVertSlide(const struct bContext *C, TransInfo *t)
 	}
 }
 
-static int doVertSlide(TransInfo *t, float perc)
+static void doVertSlide(TransInfo *t, float perc)
 {
 	VertSlideData *sld = t->customData;
 	TransDataVertSlideVert *svlist = sld->sv, *sv;
@@ -6750,7 +6849,7 @@ static int doVertSlide(TransInfo *t, float perc)
 		}
 	}
 
-	return 1;
+	projectVertSlideData(t, false);
 }
 
 static void applyVertSlide(TransInfo *t, const int UNUSED(mval[2]))
diff --git a/source/blender/editors/transform/transform.h b/source/blender/editors/transform/transform.h
index 0d824be862e..2330ec6e79e 100644
--- a/source/blender/editors/transform/transform.h
+++ b/source/blender/editors/transform/transform.h
@@ -213,18 +213,23 @@ typedef struct TransDataEdgeSlideVert {
 	int loop_nr;
 } TransDataEdgeSlideVert;
 
+
+/* store original data so we can correct UV's and similar when sliding */
+typedef struct SlideOrigData {
+	/* flag that is set when origfaces is initialized */
+	bool use_origfaces;
+	struct GHash    *origfaces;
+	struct BMesh *bm_origfaces;
+} SlideOrigData;
+
 typedef struct EdgeSlideData {
 	TransDataEdgeSlideVert *sv;
 	int totsv;
-	
-	struct GHash *origfaces;
 
 	int mval_start[2], mval_end[2];
 	struct BMEditMesh *em;
 
-	/* flag that is set when origfaces is initialized */
-	bool use_origfaces;
-	struct BMesh *bm_origfaces;
+	SlideOrigData orig_data;
 
 	float perc;
 
@@ -251,6 +256,8 @@ typedef struct VertSlideData {
 
 	struct BMEditMesh *em;
 
+	SlideOrigData orig_data;
+
 	float perc;
 
 	bool is_proportional;
@@ -699,7 +706,9 @@ void freeEdgeSlideTempFaces(EdgeSlideData *sld);
 void freeEdgeSlideVerts(TransInfo *t);
 void projectEdgeSlideData(TransInfo *t, bool is_final);
 
+void freeVertSlideTempFaces(VertSlideData *sld);
 void freeVertSlideVerts(TransInfo *t);
+void projectVertSlideData(TransInfo *t, bool is_final);
 
 
 /* TODO. transform_queries.c */
diff --git a/source/blender/editors/transform/transform_conversions.c b/source/blender/editors/transform/transform_conversions.c
index cf4f1b02832..5deb5ee9635 100644
--- a/source/blender/editors/transform/transform_conversions.c
+++ b/source/blender/editors/transform/transform_conversions.c
@@ -5597,6 +5597,12 @@ void special_aftertrans_update(bContext *C, TransInfo *t)
 					 * during cleanup - psy-fi */
 					freeEdgeSlideTempFaces(sld);
 				}
+				else if (t->mode == TFM_VERT_SLIDE) {
+					/* as above */
+					VertSlideData *sld = t->customData;
+					projectVertSlideData(t, true);
+					freeVertSlideTempFaces(sld);
+				}
 
 				if (t->obedit->type == OB_MESH) {
 					special_aftertrans_update__mesh(C, t);
diff --git a/source/blender/editors/transform/transform_generics.c b/source/blender/editors/transform/transform_generics.c
index fcf789546e8..3000b3e00bc 100644
--- a/source/blender/editors/transform/transform_generics.c
+++ b/source/blender/editors/transform/transform_generics.c
@@ -1874,9 +1874,12 @@ void calculatePropRatio(TransInfo *t)
 	TransData *td = t->data;
 	int i;
 	float dist;
-	short connected = t->flag & T_PROP_CONNECTED;
+	const bool connected = (t->flag & T_PROP_CONNECTED) != 0;
+
+	t->proptext[0] = '\0';
 
 	if (t->flag & T_PROP_EDIT) {
+		const char *pet_id = NULL;
 		for (i = 0; i < t->total; i++, td++) {
 			if (td->flag & TD_SELECTED) {
 				td->factor = 1.0f;
@@ -1937,6 +1940,9 @@ void calculatePropRatio(TransInfo *t)
 					case PROP_RANDOM:
 						td->factor = BLI_frand() * dist;
 						break;
+					case PROP_INVSQUARE:
+						td->factor = dist * (2.0f - dist);
+						break;
 					default:
 						td->factor = 1;
 						break;
@@ -1945,35 +1951,40 @@ void calculatePropRatio(TransInfo *t)
 		}
 		switch (t->prop_mode) {
 			case PROP_SHARP:
-				strcpy(t->proptext, IFACE_("(Sharp)"));
+				pet_id = N_("(Sharp)");
 				break;
 			case PROP_SMOOTH:
-				strcpy(t->proptext, IFACE_("(Smooth)"));
+				pet_id = N_("(Smooth)");
 				break;
 			case PROP_ROOT:
-				strcpy(t->proptext, IFACE_("(Root)"));
+				pet_id = N_("(Root)");
 				break;
 			case PROP_LIN:
-				strcpy(t->proptext, IFACE_("(Linear)"));
+				pet_id = N_("(Linear)");
 				break;
 			case PROP_CONST:
-				strcpy(t->proptext, IFACE_("(Constant)"));
+				pet_id = N_("(Constant)");
 				break;
 			case PROP_SPHERE:
-				strcpy(t->proptext, IFACE_("(Sphere)"));
+				pet_id = N_("(Sphere)");
 				break;
 			case PROP_RANDOM:
-				strcpy(t->proptext, IFACE_("(Random)"));
+				pet_id = N_("(Random)");
+				break;
+			case PROP_INVSQUARE:
+				pet_id = N_("(InvSquare)");
 				break;
 			default:
-				t->proptext[0] = '\0';
 				break;
 		}
+
+		if (pet_id) {
+			BLI_strncpy(t->proptext, IFACE_(pet_id), sizeof(t->proptext));
+		}
 	}
 	else {
 		for (i = 0; i < t->total; i++, td++) {
 			td->factor = 1.0;
 		}
-		t->proptext[0] = '\0';
 	}
 }
diff --git a/source/blender/editors/transform/transform_ops.c b/source/blender/editors/transform/transform_ops.c
index 25dee50a192..1498e2894d4 100644
--- a/source/blender/editors/transform/transform_ops.c
+++ b/source/blender/editors/transform/transform_ops.c
@@ -868,7 +868,7 @@ static void TRANSFORM_OT_vert_slide(struct wmOperatorType *ot)
 
 	RNA_def_float_factor(ot->srna, "value", 0, -10.0f, 10.0f, "Factor", "", -1.0f, 1.0f);
 
-	Transform_Properties(ot, P_MIRROR | P_SNAP);
+	Transform_Properties(ot, P_MIRROR | P_SNAP | P_CORRECT_UV);
 }
 
 static void TRANSFORM_OT_edge_crease(struct wmOperatorType *ot)
diff --git a/source/blender/editors/util/undo.c b/source/blender/editors/util/undo.c
index fac57490b44..ab882a388ad 100644
--- a/source/blender/editors/util/undo.c
+++ b/source/blender/editors/util/undo.c
@@ -580,7 +580,7 @@ static int undo_history_exec(bContext *C, wmOperator *op)
 			WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
 		}
 		else if (undosys == UNDOSYSTEM_IMAPAINT) {
-			ED_undo_paint_step_num(C, UNDO_PAINT_IMAGE, item );
+			ED_undo_paint_step_num(C, UNDO_PAINT_IMAGE, item);
 		}
 		else {
 			ED_viewport_render_kill_jobs(CTX_wm_manager(C), CTX_data_main(C), true);
diff --git a/source/blender/editors/uvedit/uvedit_smart_stitch.c b/source/blender/editors/uvedit/uvedit_smart_stitch.c
index c5931cf2943..4cb1f8943f9 100644
--- a/source/blender/editors/uvedit/uvedit_smart_stitch.c
+++ b/source/blender/editors/uvedit/uvedit_smart_stitch.c
@@ -1601,7 +1601,7 @@ static int stitch_init(bContext *C, wmOperator *op)
 	BMFace *efa;
 	BMLoop *l;
 	BMIter iter, liter;
-	GHashIterator *ghi;
+	GHashIterator gh_iter;
 	UvEdge *all_edges;
 	StitchState *state;
 	Scene *scene = CTX_data_scene(C);
@@ -1748,14 +1748,11 @@ static int stitch_init(bContext *C, wmOperator *op)
 		}
 	}
 
-
-	ghi = BLI_ghashIterator_new(edge_hash);
 	total_edges = BLI_ghash_size(edge_hash);
 	state->edges = edges = MEM_mallocN(sizeof(*edges) * total_edges, "stitch_edges");
 
 	/* I assume any system will be able to at least allocate an iterator :p */
 	if (!edges) {
-		BLI_ghashIterator_free(ghi);
 		state_delete(state);
 		return 0;
 	}
@@ -1763,12 +1760,12 @@ static int stitch_init(bContext *C, wmOperator *op)
 	state->total_separate_edges = total_edges;
 
 	/* fill the edges with data */
-	for (i = 0, BLI_ghashIterator_init(ghi, edge_hash); !BLI_ghashIterator_done(ghi); BLI_ghashIterator_step(ghi)) {
-		edges[i++] = *((UvEdge *)BLI_ghashIterator_getKey(ghi));
+	i = 0;
+	GHASH_ITER (gh_iter, edge_hash) {
+		edges[i++] = *((UvEdge *)BLI_ghashIterator_getKey(&gh_iter));
 	}
 
 	/* cleanup temporary stuff */
-	BLI_ghashIterator_free(ghi);
 	MEM_freeN(all_edges);
 
 	BLI_ghash_free(edge_hash, NULL, NULL);
diff --git a/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp b/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
index da3d55ef563..70de246a8de 100644
--- a/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
+++ b/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
@@ -918,7 +918,7 @@ void BlenderStrokeRenderer::GenerateStrokeMesh(StrokeGroup *group, bool hasTex)
 	BLI_assert(mesh->totedge == edge_index);
 	BLI_assert(mesh->totloop == loop_index);
 	BLI_assert(mesh->totcol == material_index);
-	BKE_mesh_validate(mesh, true);
+	BKE_mesh_validate(mesh, true, true);
 #endif
 }
 
diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp
index 9329bd40c76..edc49eb8004 100644
--- a/source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp
+++ b/source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp
@@ -117,7 +117,7 @@ static PyObject *AdjacencyIterator_iternext(BPy_AdjacencyIterator *self)
 		self->at_start = false;
 	else {
 		self->a_it->increment();
-		if (self->a_it->isEnd()){
+		if (self->a_it->isEnd()) {
 			PyErr_SetNone(PyExc_StopIteration);
 			return NULL;
 		}
diff --git a/source/blender/freestyle/intern/stroke/StrokeRep.cpp b/source/blender/freestyle/intern/stroke/StrokeRep.cpp
index f7857107006..ab06e207331 100644
--- a/source/blender/freestyle/intern/stroke/StrokeRep.cpp
+++ b/source/blender/freestyle/intern/stroke/StrokeRep.cpp
@@ -425,7 +425,7 @@ void Strip::cleanUpSingularities (const vector<StrokeVertex*>& iStrokeVertices)
 				Vec2r avP(0.0, 0.0);
 				for (j = i - timeSinceSingu1; j <= i; j++)
 					avP = Vec2r(avP + _vertices[2 * j]->point2d());
-				avP = Vec2r( 1.0 / float(timeSinceSingu1 + 1) * avP);
+				avP = Vec2r(1.0 / float(timeSinceSingu1 + 1) * avP);
 				for (j = i - timeSinceSingu1; j <= i; j++)
 					_vertices[2 * j]->setPoint2d(avP);
 				//_vertex[2 * j] = _vertex[2 * i];
diff --git a/source/blender/gpu/intern/gpu_codegen.h b/source/blender/gpu/intern/gpu_codegen.h
index c76341afa00..a6da5e018fd 100644
--- a/source/blender/gpu/intern/gpu_codegen.h
+++ b/source/blender/gpu/intern/gpu_codegen.h
@@ -149,7 +149,7 @@ typedef struct GPUInput {
 	GPUNodeLink *link;
 	bool dynamictex;		/* dynamic? */
 	CustomDataType attribtype;	/* attribute type */
-	char attribname[32];	/* attribute name */
+	char attribname[MAX_CUSTOMDATA_LAYER_NAME];	/* attribute name */
 	int attribfirst;		/* this is the first one that is bound */
 	GPUBuiltin builtin;		/* builtin uniform */
 	GPUOpenGLBuiltin oglbuiltin; /* opengl built in varying */
diff --git a/source/blender/gpu/intern/gpu_material.c b/source/blender/gpu/intern/gpu_material.c
index 53e20ec31ca..41049e8430a 100644
--- a/source/blender/gpu/intern/gpu_material.c
+++ b/source/blender/gpu/intern/gpu_material.c
@@ -1768,10 +1768,10 @@ static void gpu_lamp_calc_winmat(GPULamp *lamp)
 		orthographic_m4(lamp->winmat, -wsize, wsize, -wsize, wsize, lamp->d, lamp->clipend);
 	}
 	else {
-		angle= saacos(lamp->spotsi);
-		temp= 0.5f*lamp->size*cosf(angle)/sinf(angle);
-		pixsize= (lamp->d)/temp;
-		wsize= pixsize*0.5f*lamp->size;
+		angle = saacos(lamp->spotsi);
+		temp = 0.5f * lamp->size * cosf(angle) / sinf(angle);
+		pixsize = lamp->d / temp;
+		wsize = pixsize * 0.5f * lamp->size;
 		perspective_m4(lamp->winmat, -wsize, wsize, -wsize, wsize, lamp->d, lamp->clipend);
 	}
 }
diff --git a/source/blender/gpu/intern/gpu_select.c b/source/blender/gpu/intern/gpu_select.c
index 51721426bca..35a39b2d7a1 100644
--- a/source/blender/gpu/intern/gpu_select.c
+++ b/source/blender/gpu/intern/gpu_select.c
@@ -82,7 +82,7 @@ void GPU_select_begin(unsigned int *buffer, unsigned int bufsize, rctf *input, c
 	g_query_state.oldhits = oldhits;
 
 	if (!g_query_state.use_gpu_select) {
-		glSelectBuffer( bufsize, (GLuint *)buffer);
+		glSelectBuffer(bufsize, (GLuint *)buffer);
 		glRenderMode(GL_SELECT);
 		glInitNames();
 		glPushName(-1);
@@ -92,8 +92,8 @@ void GPU_select_begin(unsigned int *buffer, unsigned int bufsize, rctf *input, c
 
 		g_query_state.num_of_queries = ALLOC_QUERIES;
 
-		g_query_state.queries = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.queries) , "gpu selection queries");
-		g_query_state.id = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.id) , "gpu selection ids");
+		g_query_state.queries = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.queries), "gpu selection queries");
+		g_query_state.id = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.id), "gpu selection ids");
 		glGenQueriesARB(g_query_state.num_of_queries, g_query_state.queries);
 
 		glPushAttrib(GL_DEPTH_BUFFER_BIT | GL_VIEWPORT_BIT);
diff --git a/source/blender/gpu/shaders/gpu_shader_material.glsl b/source/blender/gpu/shaders/gpu_shader_material.glsl
index 17f0c20fad8..a1a4a14e857 100644
--- a/source/blender/gpu/shaders/gpu_shader_material.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_material.glsl
@@ -300,7 +300,7 @@ void math_modulo(float val1, float val2, out float outval)
 
 	/* change sign to match C convention, mod in GLSL will take absolute for negative numbers,
 	 * see https://www.opengl.org/sdk/docs/man/html/mod.xhtml */
-	outval = (val1 > 0) ? outval : -outval;
+	outval = (val1 > 0.0) ? outval : -outval;
 }
 
 void math_abs(float val1, out float outval)
diff --git a/source/blender/imbuf/intern/anim_movie.c b/source/blender/imbuf/intern/anim_movie.c
index b8f6e66adfe..ffdecb793aa 100644
--- a/source/blender/imbuf/intern/anim_movie.c
+++ b/source/blender/imbuf/intern/anim_movie.c
@@ -1314,25 +1314,27 @@ struct ImBuf *IMB_anim_absolute(struct anim *anim, int position,
 
 	filter_y = (anim->ib_flags & IB_animdeinterlace);
 
-	if (anim->curtype == 0) {
-		ibuf = anim_getnew(anim);
-		if (ibuf == NULL) {
-			return(NULL);
+	if (preview_size == IMB_PROXY_NONE) {
+		if (anim->curtype == 0) {
+			ibuf = anim_getnew(anim);
+			if (ibuf == NULL) {
+				return(NULL);
+			}
+
+			IMB_freeImBuf(ibuf); /* ???? */
+			ibuf = NULL;
 		}
 
-		IMB_freeImBuf(ibuf); /* ???? */
-		ibuf = NULL;
+		if (position < 0) return(NULL);
+		if (position >= anim->duration) return(NULL);
 	}
-
-	if (position < 0) return(NULL);
-	if (position >= anim->duration) return(NULL);
-
-	if (preview_size != IMB_PROXY_NONE) {
+	else {
 		struct anim *proxy = IMB_anim_open_proxy(anim, preview_size);
 
 		if (proxy) {
 			position = IMB_anim_index_get_frame_index(
 			    anim, tc, position);
+
 			return IMB_anim_absolute(
 			           proxy, position,
 			           IMB_TC_NONE, IMB_PROXY_NONE);
diff --git a/source/blender/imbuf/intern/moviecache.c b/source/blender/imbuf/intern/moviecache.c
index cb789cc8491..29bb35986e8 100644
--- a/source/blender/imbuf/intern/moviecache.c
+++ b/source/blender/imbuf/intern/moviecache.c
@@ -142,15 +142,16 @@ static void moviecache_valfree(void *val)
 
 static void check_unused_keys(MovieCache *cache)
 {
-	GHashIterator *iter;
+	GHashIterator gh_iter;
 
-	iter = BLI_ghashIterator_new(cache->hash);
-	while (!BLI_ghashIterator_done(iter)) {
-		MovieCacheKey *key = BLI_ghashIterator_getKey(iter);
-		MovieCacheItem *item = BLI_ghashIterator_getValue(iter);
-		int remove = 0;
+	BLI_ghashIterator_init(&gh_iter, cache->hash);
+
+	while (!BLI_ghashIterator_done(&gh_iter)) {
+		MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter);
+		MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter);
+		bool remove;
 
-		BLI_ghashIterator_step(iter);
+		BLI_ghashIterator_step(&gh_iter);
 
 		remove = !item->ibuf;
 
@@ -161,8 +162,6 @@ static void check_unused_keys(MovieCache *cache)
 		if (remove)
 			BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree);
 	}
-
-	BLI_ghashIterator_free(iter);
 }
 
 static int compare_int(const void *av, const void *bv)
@@ -473,16 +472,17 @@ void IMB_moviecache_free(MovieCache *cache)
 
 void IMB_moviecache_cleanup(MovieCache *cache, bool (cleanup_check_cb) (ImBuf *ibuf, void *userkey, void *userdata), void *userdata)
 {
-	GHashIterator *iter;
+	GHashIterator gh_iter;
 
 	check_unused_keys(cache);
 
-	iter = BLI_ghashIterator_new(cache->hash);
-	while (!BLI_ghashIterator_done(iter)) {
-		MovieCacheKey *key = BLI_ghashIterator_getKey(iter);
-		MovieCacheItem *item = BLI_ghashIterator_getValue(iter);
+	BLI_ghashIterator_init(&gh_iter, cache->hash);
+
+	while (!BLI_ghashIterator_done(&gh_iter)) {
+		MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter);
+		MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter);
 
-		BLI_ghashIterator_step(iter);
+		BLI_ghashIterator_step(&gh_iter);
 
 		if (cleanup_check_cb(item->ibuf, key->userkey, userdata)) {
 			PRINT("%s: cache '%s' remove item %p\n", __func__, cache->name, item);
@@ -490,8 +490,6 @@ void IMB_moviecache_cleanup(MovieCache *cache, bool (cleanup_check_cb) (ImBuf *i
 			BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree);
 		}
 	}
-
-	BLI_ghashIterator_free(iter);
 }
 
 /* get segments of cached frames. useful for debugging cache policies */
@@ -518,13 +516,12 @@ void IMB_moviecache_get_cache_segments(MovieCache *cache, int proxy, int render_
 		int totframe = BLI_ghash_size(cache->hash);
 		int *frames = MEM_callocN(totframe * sizeof(int), "movieclip cache frames");
 		int a, totseg = 0;
-		GHashIterator *iter;
+		GHashIterator gh_iter;
 
-		iter = BLI_ghashIterator_new(cache->hash);
 		a = 0;
-		while (!BLI_ghashIterator_done(iter)) {
-			MovieCacheKey *key = BLI_ghashIterator_getKey(iter);
-			MovieCacheItem *item = BLI_ghashIterator_getValue(iter);
+		GHASH_ITER(gh_iter, cache->hash) {
+			MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter);
+			MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter);
 			int framenr, curproxy, curflags;
 
 			if (item->ibuf) {
@@ -533,12 +530,8 @@ void IMB_moviecache_get_cache_segments(MovieCache *cache, int proxy, int render_
 				if (curproxy == proxy && curflags == render_flags)
 					frames[a++] = framenr;
 			}
-
-			BLI_ghashIterator_step(iter);
 		}
 
-		BLI_ghashIterator_free(iter);
-
 		qsort(frames, totframe, sizeof(int), compare_int);
 
 		/* count */
diff --git a/source/blender/imbuf/intern/tiff.c b/source/blender/imbuf/intern/tiff.c
index dca10fd7eda..4d58642e9c4 100644
--- a/source/blender/imbuf/intern/tiff.c
+++ b/source/blender/imbuf/intern/tiff.c
@@ -309,8 +309,8 @@ int imb_is_a_tiff(unsigned char *mem)
 	char big_endian[IMB_TIFF_NCB] = { 0x4d, 0x4d, 0x00, 0x2a };
 	char lil_endian[IMB_TIFF_NCB] = { 0x49, 0x49, 0x2a, 0x00 };
 
-	return ( (memcmp(big_endian, mem, IMB_TIFF_NCB) == 0) ||
-	         (memcmp(lil_endian, mem, IMB_TIFF_NCB) == 0) );
+	return ((memcmp(big_endian, mem, IMB_TIFF_NCB) == 0) ||
+	        (memcmp(lil_endian, mem, IMB_TIFF_NCB) == 0));
 }
 
 static void scanline_contig_16bit(float *rectf, const unsigned short *sbuf, int scanline_w, int spp)
diff --git a/source/blender/makesdna/DNA_customdata_types.h b/source/blender/makesdna/DNA_customdata_types.h
index 7fedad2546c..74f5967db13 100644
--- a/source/blender/makesdna/DNA_customdata_types.h
+++ b/source/blender/makesdna/DNA_customdata_types.h
@@ -63,9 +63,10 @@ typedef struct CustomDataExternal {
  * layers, each with a data type (e.g. MTFace, MDeformVert, etc.). */
 typedef struct CustomData {
 	CustomDataLayer *layers;      /* CustomDataLayers, ordered by type */
-	int typemap[41];              /* runtime only! - maps types to indices of first layer of that type,
+	int typemap[42];              /* runtime only! - maps types to indices of first layer of that type,
 	                               * MUST be >= CD_NUMTYPES, but we cant use a define here.
 	                               * Correct size is ensured in CustomData_update_typemap assert() */
+	int pad_i1;
 	int totlayer, maxlayer;       /* number of layers, size of layers array */
 	int totsize;                  /* in editmode, total size of all data layers */
 	struct BLI_mempool *pool;     /* (BMesh Only): Memory pool for allocation of blocks */
@@ -119,8 +120,9 @@ typedef enum CustomDataType {
 	CD_FREESTYLE_FACE   = 38,
 	CD_MLOOPTANGENT     = 39,
 	CD_TESSLOOPNORMAL   = 40,
+	CD_CUSTOMLOOPNORMAL = 41,
 
-	CD_NUMTYPES         = 41
+	CD_NUMTYPES         = 42
 } CustomDataType;
 
 /* Bits for CustomDataMask */
@@ -167,6 +169,7 @@ typedef enum CustomDataType {
 #define CD_MASK_FREESTYLE_FACE	(1LL << CD_FREESTYLE_FACE)
 #define CD_MASK_MLOOPTANGENT    (1LL << CD_MLOOPTANGENT)
 #define CD_MASK_TESSLOOPNORMAL  (1LL << CD_TESSLOOPNORMAL)
+#define CD_MASK_CUSTOMLOOPNORMAL (1LL << CD_CUSTOMLOOPNORMAL)
 
 /* CustomData.flag */
 enum {
diff --git a/source/blender/makesdna/DNA_modifier_types.h b/source/blender/makesdna/DNA_modifier_types.h
index 43d7b45675c..b32b228fda4 100644
--- a/source/blender/makesdna/DNA_modifier_types.h
+++ b/source/blender/makesdna/DNA_modifier_types.h
@@ -83,6 +83,7 @@ typedef enum ModifierType {
 	eModifierType_LaplacianDeform   = 47,
 	eModifierType_Wireframe         = 48,
 	eModifierType_DataTransfer      = 49,
+	eModifierType_NormalEdit        = 50,
 	NUM_MODIFIER_TYPES
 } ModifierType;
 
@@ -535,16 +536,39 @@ typedef struct ArmatureModifierData {
 	char defgrp_name[64];     /* MAX_VGROUP_NAME */
 } ArmatureModifierData;
 
+enum {
+	MOD_HOOK_UNIFORM_SPACE = (1 << 0),
+};
+
+/* same as WarpModifierFalloff */
+typedef enum {
+	eHook_Falloff_None   = 0,
+	eHook_Falloff_Curve  = 1,
+	eHook_Falloff_Sharp  = 2, /* PROP_SHARP */
+	eHook_Falloff_Smooth = 3, /* PROP_SMOOTH */
+	eHook_Falloff_Root   = 4, /* PROP_ROOT */
+	eHook_Falloff_Linear = 5, /* PROP_LIN */
+	eHook_Falloff_Const  = 6, /* PROP_CONST */
+	eHook_Falloff_Sphere = 7, /* PROP_SPHERE */
+	eHook_Falloff_InvSquare = 8, /* PROP_INVSQUARE */
+	/* PROP_RANDOM not used */
+} HookModifierFalloff;
+
 typedef struct HookModifierData {
 	ModifierData modifier;
 
 	struct Object *object;
 	char subtarget[64];     /* optional name of bone target, MAX_ID_NAME-2 */
 
+	char flag;
+	char falloff_type;      /* use enums from WarpModifier (exact same functionality) */
+	char pad[6];
 	float parentinv[4][4];  /* matrix making current transform unmodified */
 	float cent[3];          /* visualization of hook */
 	float falloff;          /* if not zero, falloff is distance where influence zero */
 
+	struct CurveMapping *curfalloff;
+
 	int *indexar;           /* if NULL, it's using vertexgroup */
 	int totindex;
 	float force;
@@ -978,6 +1002,7 @@ typedef enum {
 	eWarp_Falloff_Linear = 5, /* PROP_LIN */
 	eWarp_Falloff_Const  = 6, /* PROP_CONST */
 	eWarp_Falloff_Sphere = 7, /* PROP_SPHERE */
+	eWarp_Falloff_InvSquare = 8, /* PROP_INVSQUARE */
 	/* PROP_RANDOM not used */
 } WarpModifierFalloff;
 
@@ -1419,5 +1444,37 @@ enum {
 	MOD_DATATRANSFER_USE_POLY         = 1 << 31,
 };
 
+/* Set Split Normals modifier */
+typedef struct NormalEditModifierData {
+	ModifierData modifier;
+	char defgrp_name[64];  /* MAX_VGROUP_NAME */
+	struct Object *target;  /* Source of normals, or center of ellipsoid. */
+	short mode;
+	short flag;
+	short mix_mode;
+	char pad[2];
+	float mix_factor;
+	float offset[3];
+} NormalEditModifierData;
+
+/* NormalEditModifierData.mode */
+enum {
+	MOD_NORMALEDIT_MODE_RADIAL        = 0,
+	MOD_NORMALEDIT_MODE_DIRECTIONAL   = 1,
+};
+
+/* NormalEditModifierData.flags */
+enum {
+	MOD_NORMALEDIT_INVERT_VGROUP            = (1 << 0),
+	MOD_NORMALEDIT_USE_DIRECTION_PARALLEL   = (1 << 1),
+};
+
+/* NormalEditModifierData.mix_mode */
+enum {
+	MOD_NORMALEDIT_MIX_COPY = 0,
+	MOD_NORMALEDIT_MIX_ADD  = 1,
+	MOD_NORMALEDIT_MIX_SUB  = 2,
+	MOD_NORMALEDIT_MIX_MUL  = 3,
+};
 
 #endif  /* __DNA_MODIFIER_TYPES_H__ */
diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h
index 5d1793e479a..f08b3ea9590 100644
--- a/source/blender/makesdna/DNA_node_types.h
+++ b/source/blender/makesdna/DNA_node_types.h
@@ -825,6 +825,10 @@ typedef struct NodeTranslateData {
 typedef struct NodePlaneTrackDeformData {
 	char tracking_object[64];
 	char plane_track_name[64];
+	char flag;
+	char motion_blur_samples;
+	char pad[2];
+	float motion_blur_shutter;
 } NodePlaneTrackDeformData;
 
 typedef struct NodeShaderScript {
@@ -1080,4 +1084,11 @@ enum {
 /* viewer and cmposite output */
 #define CMP_NODE_OUTPUT_IGNORE_ALPHA		1
 
+/* Plane track deform node */
+enum {
+	CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR = 1,
+};
+
+#define CMP_NODE_PLANETRACKDEFORM_MBLUR_SAMPLES_MAX 64
+
 #endif
diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h
index de95f53bda1..9992f5c6be7 100644
--- a/source/blender/makesdna/DNA_scene_types.h
+++ b/source/blender/makesdna/DNA_scene_types.h
@@ -1626,7 +1626,8 @@ extern const char *RE_engine_id_CYCLES;
 #define PROP_LIN               4
 #define PROP_CONST             5
 #define PROP_RANDOM            6
-#define PROP_MODE_MAX          7
+#define PROP_INVSQUARE         7
+#define PROP_MODE_MAX          8
 
 /* toolsettings->proportional */
 #define PROP_EDIT_OFF			0
diff --git a/source/blender/makesdna/DNA_space_types.h b/source/blender/makesdna/DNA_space_types.h
index d32fb58f6db..165f6113b6d 100644
--- a/source/blender/makesdna/DNA_space_types.h
+++ b/source/blender/makesdna/DNA_space_types.h
@@ -370,6 +370,8 @@ typedef enum eGraphEdit_Flag {
 	/* normalize curves on display */
 	SIPO_NORMALIZE            = (1 << 14),
 	SIPO_NORMALIZE_FREEZE     = (1 << 15),
+	/* automatically set view on selection */
+	SIPO_AUTO_VIEW_SELECTED   = (1 << 16),
 } eGraphEdit_Flag;
 
 /* SpaceIpo->mode (Graph Editor Mode) */
@@ -462,6 +464,8 @@ typedef enum eScreen_Redraws_Flag {
 	// TIME_CONTINUE_PHYSICS  = (1 << 7), /* UNUSED */
 	TIME_NODES             = (1 << 8),
 	TIME_CLIPS             = (1 << 9),
+
+	TIME_FOLLOW            = (1 << 15),
 } eScreen_Redraws_Flag;
 
 /* time->cache */
diff --git a/source/blender/makesdna/DNA_view3d_types.h b/source/blender/makesdna/DNA_view3d_types.h
index b86da6e99ac..1e952b04e7c 100644
--- a/source/blender/makesdna/DNA_view3d_types.h
+++ b/source/blender/makesdna/DNA_view3d_types.h
@@ -76,10 +76,11 @@ typedef struct BGpic {
 	struct ImageUser iuser;
 	struct MovieClip *clip;
 	struct MovieClipUser cuser;
-	float xof, yof, size, blend;
+	float xof, yof, size, blend, rotation;
 	short view;
 	short flag;
-	short source, pad;
+	short source;
+	char pad[6];
 } BGpic;
 
 /* ********************************* */
@@ -351,7 +352,11 @@ enum {
 
 	/* Camera framing options */
 	V3D_BGPIC_CAMERA_ASPECT = (1 << 5),  /* don't stretch to fit the camera view  */
-	V3D_BGPIC_CAMERA_CROP   = (1 << 6)   /* crop out the image */
+	V3D_BGPIC_CAMERA_CROP   = (1 << 6),  /* crop out the image */
+
+	/* Axis flip options */
+	V3D_BGPIC_FLIP_X        = (1 << 7),
+	V3D_BGPIC_FLIP_Y        = (1 << 8),
 };
 
 #define V3D_BGPIC_EXPANDED (V3D_BGPIC_EXPANDED | V3D_BGPIC_CAMERACLIP)
diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h
index 34c2e5a3f25..a62a06f1613 100644
--- a/source/blender/makesrna/RNA_access.h
+++ b/source/blender/makesrna/RNA_access.h
@@ -494,6 +494,7 @@ extern StructRNA RNA_SequenceEditor;
 extern StructRNA RNA_SequenceElement;
 extern StructRNA RNA_SequenceProxy;
 extern StructRNA RNA_SequenceTransform;
+extern StructRNA RNA_NormalEditModifier;
 extern StructRNA RNA_ShaderNode;
 extern StructRNA RNA_ShaderNodeCameraData;
 extern StructRNA RNA_ShaderNodeCombineRGB;
diff --git a/source/blender/makesrna/intern/CMakeLists.txt b/source/blender/makesrna/intern/CMakeLists.txt
index 0778b14ed25..ec82fcafe76 100644
--- a/source/blender/makesrna/intern/CMakeLists.txt
+++ b/source/blender/makesrna/intern/CMakeLists.txt
@@ -28,8 +28,6 @@ if(CMAKE_COMPILER_IS_GNUCC)
 	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=implicit-function-declaration")
 endif()
 
-# message(STATUS "Configuring makesrna")
-
 # files rna_access.c rna_define.c makesrna.c intentionally excluded.
 set(DEFSRC
 	rna_ID.c
@@ -117,15 +115,32 @@ set(APISRC
 	rna_scene_api.c
 	rna_sensor_api.c
 	rna_sequencer_api.c
+	rna_sound_api.c
 	rna_space_api.c
 	rna_text_api.c
 	rna_ui_api.c
+	rna_vfont_api.c
 	rna_wm_api.c
 )
 
 string(REGEX REPLACE "rna_([a-zA-Z0-9_-]*).c" "${CMAKE_CURRENT_BINARY_DIR}/rna_\\1_gen.c" GENSRC "${DEFSRC}")
 set_source_files_properties(${GENSRC} PROPERTIES GENERATED TRUE)
 
+# --------------------------
+# CFLAGS for Generated Files
+#
+# less strict flags for generated source
+set(GENSRC_CFLAGS)
+if(CMAKE_COMPILER_IS_GNUCC OR (CMAKE_C_COMPILER_ID MATCHES "Clang"))
+	set(GENSRC_CFLAGS "-Wno-missing-prototypes")
+endif()
+
+if(GENSRC_CFLAGS)
+	set_source_files_properties(${GENSRC} PROPERTIES COMPILE_FLAGS "${GENSRC_CFLAGS}")
+endif()
+unset(GENSRC_CFLAGS)
+
+
 set(SRC_RNA_INC
 	../RNA_access.h
 	../RNA_define.h
@@ -314,9 +329,6 @@ add_executable(makesrna ${SRC} ${SRC_RNA_INC} ${SRC_DNA_INC})
 target_link_libraries(makesrna bf_dna)
 target_link_libraries(makesrna bf_dna_blenlib)
 
-# too many warnings with clang
-remove_cc_flag("-Wmissing-prototypes")
-
 # Output rna_*_gen.c
 # note (linux only): with crashes try add this after COMMAND: valgrind --leak-check=full --track-origins=yes
 add_custom_command(
diff --git a/source/blender/makesrna/intern/makesrna.c b/source/blender/makesrna/intern/makesrna.c
index ec285bc448c..14c39862467 100644
--- a/source/blender/makesrna/intern/makesrna.c
+++ b/source/blender/makesrna/intern/makesrna.c
@@ -3325,10 +3325,10 @@ static RNAProcessItem PROCESS_ITEMS[] = {
 	{"rna_test.c", NULL, RNA_def_test},
 	{"rna_text.c", "rna_text_api.c", RNA_def_text},
 	{"rna_timeline.c", NULL, RNA_def_timeline_marker},
-	{"rna_sound.c", NULL, RNA_def_sound},
+	{"rna_sound.c", "rna_sound_api.c", RNA_def_sound},
 	{"rna_ui.c", "rna_ui_api.c", RNA_def_ui},
 	{"rna_userdef.c", NULL, RNA_def_userdef},
-	{"rna_vfont.c", NULL, RNA_def_vfont},
+	{"rna_vfont.c", "rna_vfont_api.c", RNA_def_vfont},
 	{"rna_wm.c", "rna_wm_api.c", RNA_def_wm},
 	{"rna_world.c", NULL, RNA_def_world},
 	{"rna_movieclip.c", NULL, RNA_def_movieclip},
diff --git a/source/blender/makesrna/intern/rna_define.c b/source/blender/makesrna/intern/rna_define.c
index 7773b4c8f23..6db1b46ff21 100644
--- a/source/blender/makesrna/intern/rna_define.c
+++ b/source/blender/makesrna/intern/rna_define.c
@@ -65,15 +65,15 @@ BlenderDefRNA DefRNA = {NULL, {NULL, NULL}, {NULL, NULL}, NULL, 0, 0, 0, 1, 1};
 
 /* Duplicated code since we can't link in blenkernel or blenlib */
 
-/* pedantic check for '.', do this since its a hassle for translators */
+/* pedantic check for final '.', note '...' are allowed though. */
 #ifndef NDEBUG
-#  define DESCR_CHECK(description, id1, id2)                                  \
-	if (description && (description)[0]) {                                    \
-		int i = strlen(description);                                          \
-		if ((description)[i - 1] == '.') {                                    \
-			fprintf(stderr, "%s: '%s' '%s' description ends with a '.' !\n",  \
-			        __func__, id1 ? id1 : "", id2 ? id2 : "");                \
-		}                                                                     \
+#  define DESCR_CHECK(description, id1, id2)                                       \
+	if (description && (description)[0]) {                                         \
+		int i = strlen(description);                                               \
+		if (i > 3 && (description)[i - 1] == '.' && (description)[i - 3] != '.') { \
+			fprintf(stderr, "%s: '%s' '%s' description ends with a '.' !\n",       \
+			        __func__, id1 ? id1 : "", id2 ? id2 : "");                     \
+		}                                                                          \
 	} (void)0
 
 #else
diff --git a/source/blender/makesrna/intern/rna_image_api.c b/source/blender/makesrna/intern/rna_image_api.c
index 90f90ea8632..5fc65ea385c 100644
--- a/source/blender/makesrna/intern/rna_image_api.c
+++ b/source/blender/makesrna/intern/rna_image_api.c
@@ -52,8 +52,6 @@
 #include "BKE_packedFile.h"
 #include "BKE_main.h"
 
-#include "BKE_global.h" /* grr: G.main->name */
-
 #include "IMB_imbuf.h"
 #include "IMB_colormanagement.h"
 
@@ -109,13 +107,13 @@ static void rna_Image_save_render(Image *image, bContext *C, ReportList *reports
 	}
 }
 
-static void rna_Image_save(Image *image, bContext *C, ReportList *reports)
+static void rna_Image_save(Image *image, Main *bmain, bContext *C, ReportList *reports)
 {
 	ImBuf *ibuf = BKE_image_acquire_ibuf(image, NULL, NULL);
 	if (ibuf) {
 		char filename[FILE_MAX];
 		BLI_strncpy(filename, image->name, sizeof(filename));
-		BLI_path_abs(filename, ID_BLEND_PATH(G.main, &image->id));
+		BLI_path_abs(filename, ID_BLEND_PATH(bmain, &image->id));
 
 		if (image->packedfile) {
 			if (writePackedFile(reports, image->name, image->packedfile, 0) != RET_OK) {
@@ -144,7 +142,9 @@ static void rna_Image_save(Image *image, bContext *C, ReportList *reports)
 	WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, image);
 }
 
-static void rna_Image_pack(Image *image, bContext *C, ReportList *reports, int as_png)
+static void rna_Image_pack(
+        Image *image, Main *bmain, bContext *C, ReportList *reports,
+        int as_png, const char *data, int data_len)
 {
 	ImBuf *ibuf = BKE_image_acquire_ibuf(image, NULL, NULL);
 
@@ -152,11 +152,20 @@ static void rna_Image_pack(Image *image, bContext *C, ReportList *reports, int a
 		BKE_report(reports, RPT_ERROR, "Cannot pack edited image from disk, only as internal PNG");
 	}
 	else {
+		if (image->packedfile) {
+			freePackedFile(image->packedfile);
+			image->packedfile = NULL;
+		}
 		if (as_png) {
 			BKE_image_memorypack(image);
 		}
+		else if (data) {
+			char *data_dup = MEM_mallocN(sizeof(*data_dup) * (size_t)data_len, __func__);
+			memcpy(data_dup, data, (size_t)data_len);
+			image->packedfile = newPackedFileMemory(data_dup, data_len);
+		}
 		else {
-			image->packedfile = newPackedFile(reports, image->name, ID_BLEND_PATH(G.main, &image->id));
+			image->packedfile = newPackedFile(reports, image->name, ID_BLEND_PATH(bmain, &image->id));
 		}
 	}
 
@@ -301,12 +310,16 @@ void RNA_api_image(StructRNA *srna)
 
 	func = RNA_def_function(srna, "save", "rna_Image_save");
 	RNA_def_function_ui_description(func, "Save image to its source path");
-	RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
+	RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
 
 	func = RNA_def_function(srna, "pack", "rna_Image_pack");
 	RNA_def_function_ui_description(func, "Pack an image as embedded data into the .blend file");
-	RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
+	RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
 	RNA_def_boolean(func, "as_png", 0, "as_png", "Pack the image as PNG (needed for generated/dirty images)");
+	parm = RNA_def_property(func, "data", PROP_STRING, PROP_BYTESTRING);
+	RNA_def_property_ui_text(parm, "data", "Raw data (bytes, exact content of the embedded file)");
+	RNA_def_int(func, "data_len", 0, 0, INT_MAX,
+	            "data_len", "length of given data (mandatory if data is provided)", 0, INT_MAX);
 
 	func = RNA_def_function(srna, "unpack", "rna_Image_unpack");
 	RNA_def_function_ui_description(func, "Save an image packed in the .blend file to disk");
diff --git a/source/blender/makesrna/intern/rna_internal.h b/source/blender/makesrna/intern/rna_internal.h
index bd1d9698c63..d0be858fe09 100644
--- a/source/blender/makesrna/intern/rna_internal.h
+++ b/source/blender/makesrna/intern/rna_internal.h
@@ -297,6 +297,8 @@ void RNA_api_texture(struct StructRNA *srna);
 void RNA_api_environment_map(struct StructRNA *srna);
 void RNA_api_sequences(BlenderRNA *brna, PropertyRNA *cprop);
 void RNA_api_sequence_elements(BlenderRNA *brna, PropertyRNA *cprop);
+void RNA_api_sound(struct StructRNA *srna);
+void RNA_api_vfont(struct StructRNA *srna);
 
 /* main collection functions */
 void RNA_def_main_cameras(BlenderRNA *brna, PropertyRNA *cprop);
diff --git a/source/blender/makesrna/intern/rna_mesh.c b/source/blender/makesrna/intern/rna_mesh.c
index 3d6eab2bc88..44bae770186 100644
--- a/source/blender/makesrna/intern/rna_mesh.c
+++ b/source/blender/makesrna/intern/rna_mesh.c
@@ -207,6 +207,11 @@ static void rna_MeshAnyLayer_name_set(PointerRNA *ptr, const char *value)
 	rna_cd_layer_name_set(cd, (CustomDataLayer *)ptr->data, value);
 }
 
+static int rna_Mesh_has_custom_normals_get(PointerRNA *ptr)
+{
+	Mesh *me = ptr->data;
+	return (int)BKE_mesh_has_custom_loop_normals(me);
+}
 
 /* -------------------------------------------------------------------- */
 /* Update Callbacks */
@@ -338,6 +343,17 @@ static void rna_MeshLoop_normal_get(PointerRNA *ptr, float *values)
 	}
 }
 
+static void rna_MeshLoop_normal_set(PointerRNA *ptr, const float *values)
+{
+	Mesh *me = rna_mesh(ptr);
+	MLoop *ml = (MLoop *)ptr->data;
+	float (*vec)[3] = CustomData_get(&me->ldata, (int)(ml - me->mloop), CD_NORMAL);
+
+	if (vec) {
+		normalize_v3_v3(*vec, values);
+	}
+}
+
 static void rna_MeshLoop_tangent_get(PointerRNA *ptr, float *values)
 {
 	Mesh *me = rna_mesh(ptr);
@@ -1974,8 +1990,7 @@ static void rna_def_mloop(BlenderRNA *brna)
 	prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
 	RNA_def_property_array(prop, 3);
 	RNA_def_property_range(prop, -1.0f, 1.0f);
-	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-	RNA_def_property_float_funcs(prop, "rna_MeshLoop_normal_get", NULL, NULL);
+	RNA_def_property_float_funcs(prop, "rna_MeshLoop_normal_get", "rna_MeshLoop_normal_set", NULL);
 	RNA_def_property_ui_text(prop, "Normal",
 	                         "Local space unit length split normal vector of this vertex for this polygon "
 	                         "(must be computed beforehand using calc_normals_split or calc_tangents)");
@@ -3186,8 +3201,8 @@ static void rna_def_mesh(BlenderRNA *brna)
 	prop = RNA_def_property(srna, "use_auto_smooth", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_AUTOSMOOTH);
 	RNA_def_property_ui_text(prop, "Auto Smooth",
-	                         "Treat all set-smoothed faces with angles less than the specified angle "
-	                         "as 'smooth', unless they are linked by a sharp edge");
+	                         "Auto smooth (based on smooth/sharp faces/edges and angle between faces), "
+	                         "or use custom split normals data if available");
 	RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
 
 	prop = RNA_def_property(srna, "auto_smooth_angle", PROP_FLOAT, PROP_ANGLE);
@@ -3196,9 +3211,19 @@ static void rna_def_mesh(BlenderRNA *brna)
 	RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 	RNA_def_property_ui_range(prop, DEG2RADF(0.0f), DEG2RADF(180.0f), 1.0, 1);
 	RNA_def_property_ui_text(prop, "Auto Smooth Angle",
-	                         "Maximum angle between face normals that 'Auto Smooth' will operate on");
+	                         "Maximum angle between face normals that will be considered as smooth "
+	                         "(unused if custom split normals data are available)");
 	RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
 
+	RNA_define_verify_sdna(false);
+	prop = RNA_def_property(srna, "has_custom_normals", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "", 0);
+	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Has Custom Normals",
+	                         "True if there are custom split normals data in this mesh");
+	RNA_def_property_boolean_funcs(prop, "rna_Mesh_has_custom_normals_get", NULL);
+	RNA_define_verify_sdna(true);
+
 	prop = RNA_def_property(srna, "show_double_sided", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_TWOSIDED);
 	RNA_def_property_ui_text(prop, "Double Sided", "Render/display the mesh with double or single sided lighting");
diff --git a/source/blender/makesrna/intern/rna_mesh_api.c b/source/blender/makesrna/intern/rna_mesh_api.c
index 015883d87ec..53704e24bff 100644
--- a/source/blender/makesrna/intern/rna_mesh_api.c
+++ b/source/blender/makesrna/intern/rna_mesh_api.c
@@ -61,10 +61,19 @@ static const char *rna_Mesh_unit_test_compare(struct Mesh *mesh, struct Mesh *me
 	return ret;
 }
 
+static void rna_Mesh_create_normals_split(Mesh *mesh)
+{
+	if (!CustomData_has_layer(&mesh->ldata, CD_NORMAL)) {
+		CustomData_add_layer(&mesh->ldata, CD_NORMAL, CD_CALLOC, NULL, mesh->totloop);
+		CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
+	}
+}
+
 static void rna_Mesh_calc_normals_split(Mesh *mesh)
 {
 	float (*r_loopnors)[3];
 	float (*polynors)[3];
+	short (*clnors)[2] = NULL;
 	bool free_polynors = false;
 
 	if (CustomData_has_layer(&mesh->ldata, CD_NORMAL)) {
@@ -76,6 +85,9 @@ static void rna_Mesh_calc_normals_split(Mesh *mesh)
 		CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
 	}
 
+	/* may be NULL */
+	clnors = CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL);
+
 	if (CustomData_has_layer(&mesh->pdata, CD_NORMAL)) {
 		/* This assume that layer is always up to date, not sure this is the case (esp. in Edit mode?)... */
 		polynors = CustomData_get_layer(&mesh->pdata, CD_NORMAL);
@@ -88,9 +100,10 @@ static void rna_Mesh_calc_normals_split(Mesh *mesh)
 		free_polynors = true;
 	}
 
-	BKE_mesh_normals_loop_split(mesh->mvert, mesh->totvert, mesh->medge, mesh->totedge,
-	                            mesh->mloop, r_loopnors, mesh->totloop, mesh->mpoly, polynors, mesh->totpoly,
-	                            (mesh->flag & ME_AUTOSMOOTH) != 0, mesh->smoothresh);
+	BKE_mesh_normals_loop_split(
+	        mesh->mvert, mesh->totvert, mesh->medge, mesh->totedge,
+	        mesh->mloop, r_loopnors, mesh->totloop, mesh->mpoly, (const float (*)[3])polynors, mesh->totpoly,
+	        (mesh->flag & ME_AUTOSMOOTH) != 0, mesh->smoothresh, NULL, clnors, NULL);
 
 	if (free_polynors) {
 		MEM_freeN(polynors);
@@ -139,6 +152,78 @@ static void rna_Mesh_calc_smooth_groups(Mesh *mesh, int use_bitflags, int *r_pol
 	                    r_group_total, use_bitflags);
 }
 
+static void rna_Mesh_normals_split_custom_do(Mesh *mesh, float (*custom_loopnors)[3], const bool use_vertices)
+{
+	float (*polynors)[3];
+	short (*clnors)[2];
+	const int numloops = mesh->totloop;
+	bool free_polynors = false;
+
+	clnors = CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL);
+	if (clnors) {
+		memset(clnors, 0, sizeof(*clnors) * numloops);
+	}
+	else {
+		clnors = CustomData_add_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL, CD_DEFAULT, NULL, numloops);
+	}
+
+	if (CustomData_has_layer(&mesh->pdata, CD_NORMAL)) {
+		polynors = CustomData_get_layer(&mesh->pdata, CD_NORMAL);
+	}
+	else {
+		polynors = MEM_mallocN(sizeof(float[3]) * mesh->totpoly, __func__);
+		BKE_mesh_calc_normals_poly(mesh->mvert, mesh->totvert, mesh->mloop, mesh->mpoly, mesh->totloop, mesh->totpoly,
+		                           polynors, false);
+		free_polynors = true;
+	}
+
+	if (use_vertices) {
+		BKE_mesh_normals_loop_custom_from_vertices_set(
+		        mesh->mvert, custom_loopnors, mesh->totvert, mesh->medge, mesh->totedge, mesh->mloop, mesh->totloop,
+		        mesh->mpoly, (const float (*)[3])polynors, mesh->totpoly, clnors);
+	}
+	else {
+		BKE_mesh_normals_loop_custom_set(
+		        mesh->mvert, mesh->totvert, mesh->medge, mesh->totedge, mesh->mloop, custom_loopnors, mesh->totloop,
+		        mesh->mpoly, (const float (*)[3])polynors, mesh->totpoly, clnors);
+	}
+
+	if (free_polynors) {
+		MEM_freeN(polynors);
+	}
+}
+
+static void rna_Mesh_normals_split_custom_set(Mesh *mesh, ReportList *reports, int normals_len, float *normals)
+{
+	float (*loopnors)[3] = (float (*)[3])normals;
+	const int numloops = mesh->totloop;
+
+	if (normals_len != numloops * 3) {
+		BKE_reportf(reports, RPT_ERROR,
+		            "Number of custom normals is not number of loops (%f / %d)",
+		            (float)normals_len / 3.0f, numloops);
+		return;
+	}
+
+	rna_Mesh_normals_split_custom_do(mesh, loopnors, false);
+}
+
+static void rna_Mesh_normals_split_custom_set_from_vertices(
+        Mesh *mesh, ReportList *reports, int normals_len, float *normals)
+{
+	float (*vertnors)[3] = (float (*)[3])normals;
+	const int numverts = mesh->totvert;
+
+	if (normals_len != numverts * 3) {
+		BKE_reportf(reports, RPT_ERROR,
+		            "Number of custom normals is not number of vertices (%f / %d)",
+		            (float)normals_len / 3.0f, numverts);
+		return;
+	}
+
+	rna_Mesh_normals_split_custom_do(mesh, vertnors, true);
+}
+
 static void rna_Mesh_transform(Mesh *mesh, float *mat, int shape_keys)
 {
 	BKE_mesh_transform(mesh, (float (*)[4])mat, shape_keys);
@@ -152,6 +237,7 @@ void RNA_api_mesh(StructRNA *srna)
 {
 	FunctionRNA *func;
 	PropertyRNA *parm;
+	const int normals_array_dim[] = {1, 3};
 
 	func = RNA_def_function(srna, "transform", "rna_Mesh_transform");
 	RNA_def_function_ui_description(func, "Transform mesh vertices by a matrix");
@@ -162,6 +248,9 @@ void RNA_api_mesh(StructRNA *srna)
 	func = RNA_def_function(srna, "calc_normals", "BKE_mesh_calc_normals");
 	RNA_def_function_ui_description(func, "Calculate vertex normals");
 
+	func = RNA_def_function(srna, "create_normals_split", "rna_Mesh_create_normals_split");
+	RNA_def_function_ui_description(func, "Empty split vertex normals");
+
 	func = RNA_def_function(srna, "calc_normals_split", "rna_Mesh_calc_normals_split");
 	RNA_def_function_ui_description(func, "Calculate split vertex normals, which preserve sharp edges");
 
@@ -192,6 +281,26 @@ void RNA_api_mesh(StructRNA *srna)
 	parm = RNA_def_int(func, "groups", 0, 0, INT_MAX, "groups", "Total number of groups", 0, INT_MAX);
 	RNA_def_property_flag(parm, PROP_OUTPUT);
 
+	func = RNA_def_function(srna, "normals_split_custom_set", "rna_Mesh_normals_split_custom_set");
+	RNA_def_function_ui_description(func,
+	                                "Define custom split normals of this mesh "
+	                                "(use zero-vectors to keep auto ones)");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS);
+	/* TODO, see how array size of 0 works, this shouldnt be used */
+	parm = RNA_def_float_array(func, "normals", 1, NULL, -1.0f, 1.0f, "", "Normals", 0.0f, 0.0f);
+	RNA_def_property_multi_array(parm, 2, normals_array_dim);
+	RNA_def_property_flag(parm, PROP_DYNAMIC | PROP_REQUIRED);
+
+	func = RNA_def_function(srna, "normals_split_custom_set_from_vertices",
+	                        "rna_Mesh_normals_split_custom_set_from_vertices");
+	RNA_def_function_ui_description(func,
+	                                "Define custom split normals of this mesh, from vertices' normals "
+	                                "(use zero-vectors to keep auto ones)");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS);
+	/* TODO, see how array size of 0 works, this shouldnt be used */
+	parm = RNA_def_float_array(func, "normals", 1, NULL, -1.0f, 1.0f, "", "Normals", 0.0f, 0.0f);
+	RNA_def_property_multi_array(parm, 2, normals_array_dim);
+	RNA_def_property_flag(parm, PROP_DYNAMIC | PROP_REQUIRED);
 
 	func = RNA_def_function(srna, "update", "ED_mesh_update");
 	RNA_def_boolean(func, "calc_edges", 0, "Calculate Edges", "Force recalculation of edges");
@@ -207,7 +316,9 @@ void RNA_api_mesh(StructRNA *srna)
 	func = RNA_def_function(srna, "validate", "BKE_mesh_validate");
 	RNA_def_function_ui_description(func, "Validate geometry, return True when the mesh has had "
 	                                "invalid geometry corrected/removed");
-	RNA_def_boolean(func, "verbose", 0, "Verbose", "Output information about the errors found");
+	RNA_def_boolean(func, "verbose", false, "Verbose", "Output information about the errors found");
+	RNA_def_boolean(func, "cleanup_cddata", true, "Cleanup CDData",
+	                "Remove temp/cached cdlayers, like e.g. normals...");
 	parm = RNA_def_boolean(func, "result", 0, "Result", "");
 	RNA_def_function_return(func, parm);
 
diff --git a/source/blender/makesrna/intern/rna_modifier.c b/source/blender/makesrna/intern/rna_modifier.c
index a7e0ed27299..75a1def036d 100644
--- a/source/blender/makesrna/intern/rna_modifier.c
+++ b/source/blender/makesrna/intern/rna_modifier.c
@@ -63,8 +63,9 @@
 
 EnumPropertyItem modifier_type_items[] = {
 	{0, "", 0, N_("Modify"), ""},
-    {eModifierType_DataTransfer, "DATA_TRANSFER", ICON_MOD_DATA_TRANSFER, "Data Transfer", ""},
+	{eModifierType_DataTransfer, "DATA_TRANSFER", ICON_MOD_DATA_TRANSFER, "Data Transfer", ""},
 	{eModifierType_MeshCache, "MESH_CACHE", ICON_MOD_MESHDEFORM, "Mesh Cache", ""},
+	{eModifierType_NormalEdit, "NORMAL_EDIT", ICON_MOD_NORMALEDIT, "Normal Edit", ""},
 	{eModifierType_UVProject, "UV_PROJECT", ICON_MOD_UVPROJECT, "UV Project", ""},
 	{eModifierType_UVWarp, "UV_WARP", ICON_MOD_UVPROJECT, "UV Warp", ""},
 	{eModifierType_WeightVGEdit, "VERTEX_WEIGHT_EDIT", ICON_MOD_VERTEX_WEIGHT, "Vertex Weight Edit", ""},
@@ -134,6 +135,22 @@ EnumPropertyItem modifier_triangulate_ngon_method_items[] = {
 	{0, NULL, 0, NULL, NULL}
 };
 
+#ifndef RNA_RUNTIME
+/* use eWarp_Falloff_*** & eHook_Falloff_***, they're in sync */
+static EnumPropertyItem modifier_warp_falloff_items[] = {
+	{eWarp_Falloff_None,    "NONE", 0, "No Falloff", ""},
+	{eWarp_Falloff_Curve,   "CURVE", 0, "Curve", ""},
+	{eWarp_Falloff_Smooth,  "SMOOTH", ICON_SMOOTHCURVE, "Smooth", ""},
+	{eWarp_Falloff_Sphere,  "SPHERE", ICON_SPHERECURVE, "Sphere", ""},
+	{eWarp_Falloff_Root,    "ROOT", ICON_ROOTCURVE, "Root", ""},
+	{eWarp_Falloff_InvSquare, "INVERSE_SQUARE", ICON_ROOTCURVE, "Inverse Square", ""},
+	{eWarp_Falloff_Sharp,   "SHARP", ICON_SHARPCURVE, "Sharp", ""},
+	{eWarp_Falloff_Linear,  "LINEAR", ICON_LINCURVE, "Linear", ""},
+	{eWarp_Falloff_Const,   "CONSTANT", ICON_NOCURVE, "Constant", ""},
+	{0, NULL, 0, NULL, NULL}
+};
+#endif
+
 /* ***** Data Transfer ***** */
 
 EnumPropertyItem DT_method_vertex_items[] = {
@@ -358,6 +375,8 @@ static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr)
 			return &RNA_WireframeModifier;
 		case eModifierType_DataTransfer:
 			return &RNA_DataTransferModifier;
+		case eModifierType_NormalEdit:
+			return &RNA_NormalEditModifier;
 		/* Default */
 		case eModifierType_None:
 		case eModifierType_ShapeKey:
@@ -432,6 +451,7 @@ RNA_MOD_VGROUP_NAME_SET(LaplacianSmooth, defgrp_name);
 RNA_MOD_VGROUP_NAME_SET(Lattice, name);
 RNA_MOD_VGROUP_NAME_SET(Mask, vgroup);
 RNA_MOD_VGROUP_NAME_SET(MeshDeform, defgrp_name);
+RNA_MOD_VGROUP_NAME_SET(NormalEdit, defgrp_name);
 RNA_MOD_VGROUP_NAME_SET(Shrinkwrap, vgroup_name);
 RNA_MOD_VGROUP_NAME_SET(SimpleDeform, vgroup_name);
 RNA_MOD_VGROUP_NAME_SET(Smooth, defgrp_name);
@@ -518,6 +538,7 @@ RNA_MOD_OBJECT_SET(DataTransfer, ob_source, OB_MESH);
 RNA_MOD_OBJECT_SET(Lattice, object, OB_LATTICE);
 RNA_MOD_OBJECT_SET(Mask, ob_arm, OB_ARMATURE);
 RNA_MOD_OBJECT_SET(MeshDeform, object, OB_MESH);
+RNA_MOD_OBJECT_SET(NormalEdit, target, OB_EMPTY);
 RNA_MOD_OBJECT_SET(Shrinkwrap, target, OB_MESH);
 RNA_MOD_OBJECT_SET(Shrinkwrap, auxTarget, OB_MESH);
 
@@ -1111,18 +1132,6 @@ static void rna_def_modifier_warp(BlenderRNA *brna)
 	StructRNA *srna;
 	PropertyRNA *prop;
 
-	static EnumPropertyItem prop_falloff_items[] = {
-		{eWarp_Falloff_None,    "NONE", 0, "No Falloff", ""},
-		{eWarp_Falloff_Curve,   "CURVE", 0, "Curve", ""},
-		{eWarp_Falloff_Smooth,  "SMOOTH", ICON_SMOOTHCURVE, "Smooth", ""},
-		{eWarp_Falloff_Sphere,  "SPHERE", ICON_SPHERECURVE, "Sphere", ""},
-		{eWarp_Falloff_Root,    "ROOT", ICON_ROOTCURVE, "Root", ""},
-		{eWarp_Falloff_Sharp,   "SHARP", ICON_SHARPCURVE, "Sharp", ""},
-		{eWarp_Falloff_Linear,  "LINEAR", ICON_LINCURVE, "Linear", ""},
-		{eWarp_Falloff_Const,   "CONSTANT", ICON_NOCURVE, "Constant", ""},
-		{0, NULL, 0, NULL, NULL}
-	};
-
 	srna = RNA_def_struct(brna, "WarpModifier", "Modifier");
 	RNA_def_struct_ui_text(srna, "Warp Modifier", "Warp modifier");
 	RNA_def_struct_sdna(srna, "WarpModifierData");
@@ -1145,7 +1154,7 @@ static void rna_def_modifier_warp(BlenderRNA *brna)
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
 	prop = RNA_def_property(srna, "falloff_type", PROP_ENUM, PROP_NONE);
-	RNA_def_property_enum_items(prop, prop_falloff_items);
+	RNA_def_property_enum_items(prop, modifier_warp_falloff_items);
 	RNA_def_property_ui_text(prop, "Falloff Type", "");
 	RNA_def_property_translation_context(prop, BLF_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1677,15 +1686,28 @@ static void rna_def_modifier_hook(BlenderRNA *brna)
 	RNA_def_struct_sdna(srna, "HookModifierData");
 	RNA_def_struct_ui_icon(srna, ICON_HOOK);
 
-	prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_DISTANCE);
+	prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "force");
+	RNA_def_property_range(prop, 0, 1);
+	RNA_def_property_ui_text(prop, "Strength",  "Relative force of the hook");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "falloff_type", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_items(prop, modifier_warp_falloff_items);  /* share the enum */
+	RNA_def_property_ui_text(prop, "Falloff Type", "");
+	RNA_def_property_translation_context(prop, BLF_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "falloff_radius", PROP_FLOAT, PROP_DISTANCE);
+	RNA_def_property_float_sdna(prop, NULL, "falloff");
 	RNA_def_property_range(prop, 0, FLT_MAX);
 	RNA_def_property_ui_range(prop, 0, 100, 100, 2);
-	RNA_def_property_ui_text(prop, "Falloff",  "If not zero, the distance from the hook where influence ends");
+	RNA_def_property_ui_text(prop, "Radius",  "If not zero, the distance from the hook where influence ends");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop = RNA_def_property(srna, "force", PROP_FLOAT, PROP_NONE);
-	RNA_def_property_range(prop, 0, 1);
-	RNA_def_property_ui_text(prop, "Force",  "Relative force of the hook");
+	prop = RNA_def_property(srna, "falloff_curve", PROP_POINTER, PROP_NONE);
+	RNA_def_property_pointer_sdna(prop, NULL, "curfalloff");
+	RNA_def_property_ui_text(prop, "Falloff Curve", "Custom Lamp Falloff Curve");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
 	prop = RNA_def_property(srna, "center", PROP_FLOAT, PROP_NONE);
@@ -1705,6 +1727,11 @@ static void rna_def_modifier_hook(BlenderRNA *brna)
 	                         "Name of Parent Bone for hook (if applicable), also recalculates and clears offset");
 	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
 
+	prop = RNA_def_property(srna, "use_falloff_uniform", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_HOOK_UNIFORM_SPACE);
+	RNA_def_property_ui_text(prop, "Uniform Falloff", "Compensate for non-uniform object scale");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
 	prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
 	RNA_def_property_string_sdna(prop, NULL, "name");
 	RNA_def_property_ui_text(prop, "Vertex Group",
@@ -3176,24 +3203,24 @@ static void rna_def_modifier_uvwarp(BlenderRNA *brna)
 
 	prop = RNA_def_property(srna, "object_from", PROP_POINTER, PROP_NONE);
 	RNA_def_property_pointer_sdna(prop, NULL, "object_src");
-	RNA_def_property_ui_text(prop, "Target", "Object defining offset");
+	RNA_def_property_ui_text(prop, "Object From", "Object defining offset");
 	RNA_def_property_flag(prop, PROP_EDITABLE);
 	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
 
 	prop = RNA_def_property(srna, "bone_from", PROP_STRING, PROP_NONE);
 	RNA_def_property_string_sdna(prop, NULL, "bone_src");
-	RNA_def_property_ui_text(prop, "Sub-Target", "Bone defining offset");
+	RNA_def_property_ui_text(prop, "Bone From", "Bone defining offset");
 	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
 
 	prop = RNA_def_property(srna, "object_to", PROP_POINTER, PROP_NONE);
 	RNA_def_property_pointer_sdna(prop, NULL, "object_dst");
-	RNA_def_property_ui_text(prop, "Target", "Object defining offset");
+	RNA_def_property_ui_text(prop, "Object To", "Object defining offset");
 	RNA_def_property_flag(prop, PROP_EDITABLE);
 	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
 
 	prop = RNA_def_property(srna, "bone_to", PROP_STRING, PROP_NONE);
 	RNA_def_property_string_sdna(prop, NULL, "bone_dst");
-	RNA_def_property_ui_text(prop, "Sub-Target", "Bone defining offset");
+	RNA_def_property_ui_text(prop, "Bone To", "Bone defining offset");
 	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
 
 	prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
@@ -4126,6 +4153,7 @@ static void rna_def_modifier_datatransfer(BlenderRNA *brna)
 	};
 
 	static EnumPropertyItem DT_layer_loop_items[] = {
+		{DT_TYPE_LNOR, "CUSTOM_NORMAL", 0, "Custom Normals", "Transfer custom normals"},
 		{0, NULL, 0, NULL, NULL}
 	};
 	static EnumPropertyItem DT_layer_loop_vcol_items[] = {
@@ -4338,6 +4366,77 @@ static void rna_def_modifier_datatransfer(BlenderRNA *brna)
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 }
 
+static void rna_def_modifier_normaledit(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	static EnumPropertyItem prop_mode_items[] = {
+		{MOD_NORMALEDIT_MODE_RADIAL, "RADIAL", 0, "Radial",
+		        "From an ellipsoid (shape defined by the boundbox's dimensions, target is optional)"},
+		{MOD_NORMALEDIT_MODE_DIRECTIONAL, "DIRECTIONAL", 0, "Directional",
+		        "Normals 'track' (point to) the target object"},
+		{0, NULL, 0, NULL, NULL}
+	};
+
+	static EnumPropertyItem prop_mix_mode_items[] = {
+		{MOD_NORMALEDIT_MIX_COPY, "COPY", 0, "Copy", "Copy new normals (overwrite existing)"},
+		{MOD_NORMALEDIT_MIX_ADD, "ADD", 0, "Add", "Copy sum of new and old normals"},
+		{MOD_NORMALEDIT_MIX_SUB, "SUB", 0, "Subtract", "Copy new normals minus old normals"},
+		{MOD_NORMALEDIT_MIX_MUL, "MUL", 0, "Multiply", "Copy product of old and new normals (*not* cross product)"},
+		{0, NULL, 0, NULL, NULL}
+	};
+
+	srna = RNA_def_struct(brna, "NormalEditModifier", "Modifier");
+	RNA_def_struct_ui_text(srna, "Normal Edit Modifier", "Modifier affecting/generating custom normals");
+	RNA_def_struct_sdna(srna, "NormalEditModifierData");
+	RNA_def_struct_ui_icon(srna, ICON_MOD_NORMALEDIT);
+
+	prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_items(prop, prop_mode_items);
+	RNA_def_property_ui_text(prop, "Mode", "How to affect (generate) normals");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_float_array(srna, "offset", 3, NULL, -FLT_MAX, FLT_MAX, "Offset",
+	                           "Offset from object's center", -100.0f, 100.0f);
+	RNA_def_property_subtype(prop, PROP_COORDS);
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "mix_mode", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_items(prop, prop_mix_mode_items);
+	RNA_def_property_ui_text(prop, "Mix Mode", "How to mix generated normals with existing ones");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_float(srna, "mix_factor", 1.0f, 0.0f, 1.0f, "Mix Factor",
+	                     "How much of generated normals to mix with exiting ones", 0.0f, 1.0f);
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
+	RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
+	RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for selecting/weighting the affected areas");
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_NormalEditModifier_defgrp_name_set");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "use_invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_NORMALEDIT_INVERT_VGROUP);
+	RNA_def_property_ui_text(prop, "Invert", "Invert vertex group influence");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "target", PROP_POINTER, PROP_NONE);
+	RNA_def_property_ui_text(prop, "Target", "Target object used to affect normals");
+	RNA_def_property_pointer_funcs(prop, NULL, "rna_NormalEditModifier_target_set", NULL, NULL);
+	RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
+	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
+
+	prop = RNA_def_property(srna, "use_direction_parallel", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_NORMALEDIT_USE_DIRECTION_PARALLEL);
+	RNA_def_property_boolean_default(prop, true);
+	RNA_def_property_ui_text(prop, "Parallel Normals",
+	                         "Use same direction for all normals, from origin to target's center "
+	                         "(Directional mode only)");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+}
+
 void RNA_def_modifier(BlenderRNA *brna)
 {
 	StructRNA *srna;
@@ -4452,6 +4551,7 @@ void RNA_def_modifier(BlenderRNA *brna)
 	rna_def_modifier_laplaciandeform(brna);
 	rna_def_modifier_wireframe(brna);
 	rna_def_modifier_datatransfer(brna);
+	rna_def_modifier_normaledit(brna);
 }
 
 #endif
diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c
index 7f574c41b1f..8d2a44136e8 100644
--- a/source/blender/makesrna/intern/rna_nodetree.c
+++ b/source/blender/makesrna/intern/rna_nodetree.c
@@ -6231,6 +6231,21 @@ static void def_cmp_planetrackdeform(StructRNA *srna)
 	RNA_def_property_string_sdna(prop, NULL, "plane_track_name");
 	RNA_def_property_ui_text(prop, "Plane Track", "");
 	RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
+
+	prop = RNA_def_property(srna, "use_motion_blur", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR);
+	RNA_def_property_ui_text(prop, "Motion Blur", "Use multi-sampled motion blur of the mask");
+	RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
+
+	prop = RNA_def_property(srna, "motion_blur_samples", PROP_INT, PROP_NONE);
+	RNA_def_property_range(prop, 1, CMP_NODE_PLANETRACKDEFORM_MBLUR_SAMPLES_MAX);
+	RNA_def_property_ui_text(prop, "Samples", "Number of motion blur samples");
+	RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
+
+	prop = RNA_def_property(srna, "motion_blur_shutter", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_range(prop, 0.0, 1.0f);
+	RNA_def_property_ui_text(prop, "Shutter", "Exposure for motion blur as a factor of FPS");
+	RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 }
 
 static void def_cmp_sunbeams(StructRNA *srna)
diff --git a/source/blender/makesrna/intern/rna_scene.c b/source/blender/makesrna/intern/rna_scene.c
index 3e6f85a0a59..772795ef855 100644
--- a/source/blender/makesrna/intern/rna_scene.c
+++ b/source/blender/makesrna/intern/rna_scene.c
@@ -112,6 +112,7 @@ EnumPropertyItem proportional_falloff_items[] = {
 	{PROP_SMOOTH, "SMOOTH", ICON_SMOOTHCURVE, "Smooth", "Smooth falloff"},
 	{PROP_SPHERE, "SPHERE", ICON_SPHERECURVE, "Sphere", "Spherical falloff"},
 	{PROP_ROOT, "ROOT", ICON_ROOTCURVE, "Root", "Root falloff"},
+	{PROP_INVSQUARE, "INVERSE_SQUARE", ICON_ROOTCURVE, "Inverse Square", "Inverse Square falloff"},
 	{PROP_SHARP, "SHARP", ICON_SHARPCURVE, "Sharp", "Sharp falloff"},
 	{PROP_LIN, "LINEAR", ICON_LINCURVE, "Linear", "Linear falloff"},
 	{PROP_CONST, "CONSTANT", ICON_NOCURVE, "Constant", "Constant falloff"},
@@ -3637,8 +3638,8 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
 
 	prop = RNA_def_property(srna, "logic_step_max", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "maxlogicstep");
-	RNA_def_property_ui_range(prop, 1, 5, 1, 1);
-	RNA_def_property_range(prop, 1, 5);
+	RNA_def_property_range(prop, 1, 10000);
+	RNA_def_property_ui_range(prop, 1, 50, 1, 1);
 	RNA_def_property_ui_text(prop, "Max Logic Steps",
 	                         "Maximum number of logic frame per game frame if graphics slows down the game, "
 	                         "higher value allows better synchronization with physics");
@@ -3646,8 +3647,8 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
 
 	prop = RNA_def_property(srna, "physics_step_max", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "maxphystep");
-	RNA_def_property_ui_range(prop, 1, 5, 1, 1);
-	RNA_def_property_range(prop, 1, 5);
+	RNA_def_property_range(prop, 1, 10000);
+	RNA_def_property_ui_range(prop, 1, 50, 1, 1);
 	RNA_def_property_ui_text(prop, "Max Physics Steps",
 	                         "Maximum number of physics step per game frame if graphics slows down the game, "
 	                         "higher value allows physics to keep up with realtime");
@@ -4809,6 +4810,7 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
 	RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 	
 	prop = RNA_def_property(srna, "use_freestyle", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", R_EDGE_FRS);
 	RNA_def_property_ui_text(prop, "Edge", "Draw stylized strokes using Freestyle");
 	RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
diff --git a/source/blender/makesrna/intern/rna_screen.c b/source/blender/makesrna/intern/rna_screen.c
index 7b01acff6a5..86d20e6e239 100644
--- a/source/blender/makesrna/intern/rna_screen.c
+++ b/source/blender/makesrna/intern/rna_screen.c
@@ -413,6 +413,11 @@ static void rna_def_screen(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "All 3D View Editors", "");
 	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
 
+	prop = RNA_def_property(srna, "use_follow", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_FOLLOW);
+	RNA_def_property_ui_text(prop, "Follow", "Follow current frame in editors that update");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_TIME, "rna_Screen_redraw_update");
+
 	prop = RNA_def_property(srna, "use_play_animation_editors", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "redraws_flag", TIME_ALL_ANIM_WIN);
 	RNA_def_property_ui_text(prop, "Animation Editors", "");
diff --git a/source/blender/makesrna/intern/rna_sequencer.c b/source/blender/makesrna/intern/rna_sequencer.c
index 871dd93b525..f628112a19a 100644
--- a/source/blender/makesrna/intern/rna_sequencer.c
+++ b/source/blender/makesrna/intern/rna_sequencer.c
@@ -1178,7 +1178,7 @@ static void rna_def_strip_proxy(BlenderRNA *brna)
 
 	prop = RNA_def_property(srna, "use_overwrite", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_negative_sdna(prop, NULL, "build_flags", SEQ_PROXY_SKIP_EXISTING);
-	RNA_def_property_ui_text(prop, "Overwite", "Overwrite existing proxy files when building");
+	RNA_def_property_ui_text(prop, "Overwrite", "Overwrite existing proxy files when building");
 
 	prop = RNA_def_property(srna, "build_25", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_25);
diff --git a/source/blender/makesrna/intern/rna_sound.c b/source/blender/makesrna/intern/rna_sound.c
index aa39e81d390..4b745c60b5b 100644
--- a/source/blender/makesrna/intern/rna_sound.c
+++ b/source/blender/makesrna/intern/rna_sound.c
@@ -98,6 +98,8 @@ static void rna_def_sound(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Mono",
 	                         "If the file contains multiple audio channels they are rendered to a single one");
 	RNA_def_property_update(prop, 0, "rna_Sound_update");
+
+	RNA_api_sound(srna);
 }
 
 void RNA_def_sound(BlenderRNA *brna)
diff --git a/source/blender/makesrna/intern/rna_sound_api.c b/source/blender/makesrna/intern/rna_sound_api.c
new file mode 100644
index 00000000000..0164daa98d0
--- /dev/null
+++ b/source/blender/makesrna/intern/rna_sound_api.c
@@ -0,0 +1,73 @@
+/*
+ * ***** 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) 2015 by the Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/makesrna/intern/rna_sound_api.c
+ *  \ingroup RNA
+ */
+
+#include "DNA_packedFile_types.h"
+
+#include "RNA_define.h"
+#include "RNA_enum_types.h"
+
+#include "rna_internal.h"
+
+#ifdef RNA_RUNTIME
+
+#include "BKE_packedFile.h"
+
+static void rna_Sound_pack(bSound *sound, Main *bmain, ReportList *reports)
+{
+	sound->packedfile = newPackedFile(reports, sound->name, ID_BLEND_PATH(bmain, &sound->id));
+}
+
+static void rna_Sound_unpack(bSound *sound, Main *bmain, ReportList *reports, int method)
+{
+	if (!sound->packedfile) {
+		BKE_report(reports, RPT_ERROR, "Sound not packed");
+	}
+	else {
+		/* reports its own error on failure */
+		unpackSound(bmain, reports, sound, method);
+	}
+}
+
+#else
+
+void RNA_api_sound(StructRNA *srna)
+{
+	FunctionRNA *func;
+
+	func = RNA_def_function(srna, "pack", "rna_Sound_pack");
+	RNA_def_function_ui_description(func, "Pack the sound into the current blend file");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_MAIN);
+
+	func = RNA_def_function(srna, "unpack", "rna_Sound_unpack");
+	RNA_def_function_ui_description(func, "Unpack the sound to the samples filename");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_MAIN);
+	RNA_def_enum(func, "method", unpack_method_items, PF_USE_LOCAL, "method", "How to unpack");
+}
+
+#endif
diff --git a/source/blender/makesrna/intern/rna_space.c b/source/blender/makesrna/intern/rna_space.c
index 19a507ae8c6..21f3784a6cc 100644
--- a/source/blender/makesrna/intern/rna_space.c
+++ b/source/blender/makesrna/intern/rna_space.c
@@ -1708,7 +1708,22 @@ static void rna_def_background_image(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Size", "Scaling factor for the background image");
 	RNA_def_property_range(prop, 0.0, FLT_MAX);
 	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
-	
+
+	prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
+	RNA_def_property_float_sdna(prop, NULL, "rotation");
+	RNA_def_property_ui_text(prop, "Rotation", "Rotation for the background image");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
+
+	prop = RNA_def_property(srna, "use_flip_x", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", V3D_BGPIC_FLIP_X);
+	RNA_def_property_ui_text(prop, "Flip Horizontally", "Flip the background image horizontally");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
+
+	prop = RNA_def_property(srna, "use_flip_y", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", V3D_BGPIC_FLIP_Y);
+	RNA_def_property_ui_text(prop, "Flip Vertically", "Flip the background image vertically");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
+
 	prop = RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "blend");
 	RNA_def_property_float_funcs(prop, "rna_BackgroundImage_opacity_get", "rna_BackgroundImage_opacity_set", NULL);
@@ -2846,7 +2861,8 @@ static void rna_def_space_dopesheet(BlenderRNA *brna)
 	prop = RNA_def_property(srna, "show_group_colors", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SACTION_NODRAWGCOLORS);
 	RNA_def_property_ui_text(prop, "Show Group Colors",
-	                         "Draw groups and channels with colors matching their corresponding groups");
+	                         "Draw groups and channels with colors matching their corresponding groups "
+	                         "(pose bones only currently)");
 	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_DOPESHEET, NULL);
 	
 	/* editing */
@@ -3008,6 +3024,12 @@ static void rna_def_space_graph(BlenderRNA *brna)
 	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 	RNA_def_property_ui_text(prop, "Has Ghost Curves", "Graph Editor instance has some ghost curves stored");
 
+	/* auto view */
+	prop = RNA_def_property(srna, "use_auto_view_selected", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", SIPO_AUTO_VIEW_SELECTED);
+	RNA_def_property_ui_text(prop, "Auto View Selected", "Automatically adjust view based on selection");
+	RNA_def_property_update(prop, NC_SPACE | ND_SPACE_GRAPH, NULL);
+
 	/* nromalize curves */
 	prop = RNA_def_property(srna, "use_normalization", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", SIPO_NORMALIZE);
diff --git a/source/blender/makesrna/intern/rna_userdef.c b/source/blender/makesrna/intern/rna_userdef.c
index 3f592d98dd3..15ecf70a938 100644
--- a/source/blender/makesrna/intern/rna_userdef.c
+++ b/source/blender/makesrna/intern/rna_userdef.c
@@ -3535,7 +3535,7 @@ static void rna_def_userdef_edit(BlenderRNA *brna)
 	/* Undo */
 	prop = RNA_def_property(srna, "undo_steps", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "undosteps");
-	RNA_def_property_range(prop, 0, 64);
+	RNA_def_property_range(prop, 0, 256);
 	RNA_def_property_int_funcs(prop, NULL, "rna_userdef_undo_steps_set", NULL);
 	RNA_def_property_ui_text(prop, "Undo Steps", "Number of undo steps available (smaller values conserve memory)");
 
diff --git a/source/blender/makesrna/intern/rna_vfont.c b/source/blender/makesrna/intern/rna_vfont.c
index f24f94282b6..0879f4d355d 100644
--- a/source/blender/makesrna/intern/rna_vfont.c
+++ b/source/blender/makesrna/intern/rna_vfont.c
@@ -84,6 +84,8 @@ void RNA_def_vfont(BlenderRNA *brna)
 	prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
 	RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
 	RNA_def_property_ui_text(prop, "Packed File", "");
+
+	RNA_api_vfont(srna);
 }
 
 #endif
diff --git a/source/blender/makesrna/intern/rna_vfont_api.c b/source/blender/makesrna/intern/rna_vfont_api.c
new file mode 100644
index 00000000000..d92e75daf0a
--- /dev/null
+++ b/source/blender/makesrna/intern/rna_vfont_api.c
@@ -0,0 +1,73 @@
+/*
+ * ***** 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) 2015 by the Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/makesrna/intern/rna_vfont_api.c
+ *  \ingroup RNA
+ */
+
+#include "DNA_packedFile_types.h"
+
+#include "RNA_define.h"
+#include "RNA_enum_types.h"
+
+#include "rna_internal.h"
+
+#ifdef RNA_RUNTIME
+
+#include "BKE_packedFile.h"
+
+static void rna_VectorFont_pack(VFont *vfont, Main *bmain, ReportList *reports)
+{
+	vfont->packedfile = newPackedFile(reports, vfont->name, ID_BLEND_PATH(bmain, &vfont->id));
+}
+
+static void rna_VectorFont_unpack(VFont *vfont, ReportList *reports, int method)
+{
+	if (!vfont->packedfile) {
+		BKE_report(reports, RPT_ERROR, "Font not packed");
+	}
+	else {
+		/* reports its own error on failure */
+		unpackVFont(reports, vfont, method);
+	}
+}
+
+#else
+
+void RNA_api_vfont(StructRNA *srna)
+{
+	FunctionRNA *func;
+
+	func = RNA_def_function(srna, "pack", "rna_VectorFont_pack");
+	RNA_def_function_ui_description(func, "Pack the font into the current blend file");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_MAIN);
+
+	func = RNA_def_function(srna, "unpack", "rna_VectorFont_unpack");
+	RNA_def_function_ui_description(func, "Unpack the font to the samples filename");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS);
+	RNA_def_enum(func, "method", unpack_method_items, PF_USE_LOCAL, "method", "How to unpack");
+}
+
+#endif
diff --git a/source/blender/modifiers/CMakeLists.txt b/source/blender/modifiers/CMakeLists.txt
index a93dc76a655..57e927fffed 100644
--- a/source/blender/modifiers/CMakeLists.txt
+++ b/source/blender/modifiers/CMakeLists.txt
@@ -73,6 +73,7 @@ set(SRC
 	intern/MOD_mirror.c
 	intern/MOD_multires.c
 	intern/MOD_none.c
+	intern/MOD_normal_edit.c
 	intern/MOD_ocean.c
 	intern/MOD_particleinstance.c
 	intern/MOD_particlesystem.c
diff --git a/source/blender/modifiers/MOD_modifiertypes.h b/source/blender/modifiers/MOD_modifiertypes.h
index aceee441098..66e613be68a 100644
--- a/source/blender/modifiers/MOD_modifiertypes.h
+++ b/source/blender/modifiers/MOD_modifiertypes.h
@@ -82,6 +82,7 @@ extern ModifierTypeInfo modifierType_MeshCache;
 extern ModifierTypeInfo modifierType_LaplacianDeform;
 extern ModifierTypeInfo modifierType_Wireframe;
 extern ModifierTypeInfo modifierType_DataTransfer;
+extern ModifierTypeInfo modifierType_NormalEdit;
 
 /* MOD_util.c */
 void modifier_type_init(ModifierTypeInfo *types[]);
diff --git a/source/blender/modifiers/intern/MOD_build.c b/source/blender/modifiers/intern/MOD_build.c
index f30529bc40f..1dc1a1f8d64 100644
--- a/source/blender/modifiers/intern/MOD_build.c
+++ b/source/blender/modifiers/intern/MOD_build.c
@@ -86,7 +86,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
 	float frac;
 	MPoly *mpoly_dst;
 	MLoop *ml_dst, *ml_src /*, *mloop_dst */;
-	GHashIterator *hashIter;
+	GHashIterator gh_iter;
 	/* maps vert indices in old mesh to indices in new mesh */
 	GHash *vertHash = BLI_ghash_int_new("build ve apply gh");
 	/* maps edge indices in new mesh to indices in old mesh */
@@ -230,15 +230,11 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
 	                            BLI_ghash_size(edgeHash), 0, numLoops_dst, numFaces_dst);
 
 	/* copy the vertices across */
-	for (hashIter = BLI_ghashIterator_new(vertHash);
-	     BLI_ghashIterator_done(hashIter) == false;
-	     BLI_ghashIterator_step(hashIter)
-	     )
-	{
+	GHASH_ITER (gh_iter, vertHash) {
 		MVert source;
 		MVert *dest;
-		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
-		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
+		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(&gh_iter));
+		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(&gh_iter));
 
 		source = mvert_src[oldIndex];
 		dest = CDDM_get_vert(result, newIndex);
@@ -246,7 +242,6 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
 		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++) {
diff --git a/source/blender/modifiers/intern/MOD_hook.c b/source/blender/modifiers/intern/MOD_hook.c
index f6d7c03df32..2b512a6ba25 100644
--- a/source/blender/modifiers/intern/MOD_hook.c
+++ b/source/blender/modifiers/intern/MOD_hook.c
@@ -43,6 +43,7 @@
 #include "BKE_cdderivedmesh.h"
 #include "BKE_modifier.h"
 #include "BKE_deform.h"
+#include "BKE_colortools.h"
 
 
 #include "depsgraph_private.h"
@@ -55,6 +56,9 @@ static void initData(ModifierData *md)
 	HookModifierData *hmd = (HookModifierData *) md;
 
 	hmd->force = 1.0;
+	hmd->curfalloff = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+	hmd->falloff_type = eHook_Falloff_Smooth;
+	hmd->flag = 0;
 }
 
 static void copyData(ModifierData *md, ModifierData *target)
@@ -64,6 +68,8 @@ static void copyData(ModifierData *md, ModifierData *target)
 
 	modifier_copyData_generic(md, target);
 
+	thmd->curfalloff = curvemapping_copy(hmd->curfalloff);
+
 	thmd->indexar = MEM_dupallocN(hmd->indexar);
 }
 
@@ -83,6 +89,8 @@ static void freeData(ModifierData *md)
 {
 	HookModifierData *hmd = (HookModifierData *) md;
 
+	curvemapping_free(hmd->curfalloff);
+
 	if (hmd->indexar) MEM_freeN(hmd->indexar);
 }
 
@@ -120,32 +128,172 @@ static void updateDepgraph(ModifierData *md, DagForest *forest,
 	}
 }
 
-static float hook_falloff(const float co_1[3], const float co_2[3], const float falloff_squared, float fac)
+struct HookData_cb {
+	float (*vertexCos)[3];
+
+	MDeformVert *dvert;
+	int defgrp_index;
+
+	struct CurveMapping *curfalloff;
+
+	char  falloff_type;
+	float falloff;
+	float falloff_sq;
+	float fac_orig;
+
+	unsigned int use_falloff        : 1;
+	unsigned int use_uniform        : 1;
+
+	float cent[3];
+
+	float mat_uniform[3][3];
+	float mat[4][4];
+};
+
+static float hook_falloff(
+        const struct HookData_cb *hd,
+        const float len_sq)
+{
+	BLI_assert(hd->falloff_sq);
+	if (len_sq > hd->falloff_sq) {
+		return 0.0f;
+	}
+	else if (len_sq > 0.0f) {
+		float fac;
+
+		if (hd->falloff_type == eHook_Falloff_Const) {
+			fac = 1.0f;
+			goto finally;
+		}
+		else if (hd->falloff_type == eHook_Falloff_InvSquare) {
+			/* avoid sqrt below */
+			fac = 1.0f - (len_sq / hd->falloff_sq);
+			goto finally;
+		}
+
+		fac = 1.0f - (sqrtf(len_sq) / hd->falloff);
+
+		/* closely match PROP_SMOOTH and similar */
+		switch (hd->falloff_type) {
+#if 0
+			case eHook_Falloff_None:
+				fac = 1.0f;
+				break;
+#endif
+			case eHook_Falloff_Curve:
+				fac = curvemapping_evaluateF(hd->curfalloff, 0, fac);
+				break;
+			case eHook_Falloff_Sharp:
+				fac = fac * fac;
+				break;
+			case eHook_Falloff_Smooth:
+				fac = 3.0f * fac * fac - 2.0f * fac * fac * fac;
+				break;
+			case eHook_Falloff_Root:
+				fac = sqrtf(fac);
+				break;
+			case eHook_Falloff_Linear:
+				/* pass */
+				break;
+#if 0
+			case eHook_Falloff_Const:
+				fac = 1.0f;
+				break;
+#endif
+			case eHook_Falloff_Sphere:
+				fac = sqrtf(2 * fac - fac * fac);
+				break;
+#if 0
+			case eHook_Falloff_InvSquare:
+				fac = fac * (2.0f - fac);
+				break;
+#endif
+		}
+
+finally:
+		return fac * hd->fac_orig;
+	}
+	else {
+		return hd->fac_orig;
+	}
+}
+
+static void hook_co_apply(struct HookData_cb *hd, const int j)
 {
-	if (falloff_squared) {
-		float len_squared = len_squared_v3v3(co_1, co_2);
-		if (len_squared > falloff_squared) {
-			return 0.0f;
+	float *co = hd->vertexCos[j];
+	float fac;
+
+	if (hd->use_falloff) {
+		float len_sq;
+
+		if (hd->use_uniform) {
+			float co_uniform[3];
+			mul_v3_m3v3(co_uniform, hd->mat_uniform, co);
+			len_sq = len_squared_v3v3(hd->cent, co_uniform);
 		}
-		else if (len_squared > 0.0f) {
-			return fac * (1.0f - (len_squared / falloff_squared));
+		else {
+			len_sq = len_squared_v3v3(hd->cent, co);
 		}
+
+		fac = hook_falloff(hd, len_sq);
 	}
+	else {
+		fac = hd->fac_orig;
+	}
+
+	if (fac) {
+		if (hd->dvert) {
+			fac *= defvert_find_weight(&hd->dvert[j], hd->defgrp_index);
+		}
 
-	return fac;
+		if (fac) {
+			float co_tmp[3];
+			mul_v3_m4v3(co_tmp, hd->mat, co);
+			interp_v3_v3v3(co, co, co_tmp, fac);
+		}
+	}
 }
 
 static void deformVerts_do(HookModifierData *hmd, Object *ob, DerivedMesh *dm,
                            float (*vertexCos)[3], int numVerts)
 {
 	bPoseChannel *pchan = BKE_pose_channel_find_name(hmd->object->pose, hmd->subtarget);
-	float vec[3], mat[4][4], dmat[4][4];
+	float dmat[4][4];
 	int i, *index_pt;
-	const float falloff_squared = hmd->falloff * hmd->falloff; /* for faster comparisons */
-	
-	MDeformVert *dvert;
-	int defgrp_index, max_dvert;
+	struct HookData_cb hd;
 	
+	if (hmd->curfalloff == NULL) {
+		/* should never happen, but bad lib linking could cause it */
+		hmd->curfalloff = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+	}
+
+	if (hmd->curfalloff) {
+		curvemapping_initialize(hmd->curfalloff);
+	}
+
+	/* Generic data needed for applying per-vertex calculations (initialize all members) */
+	hd.vertexCos = vertexCos;
+	modifier_get_vgroup(ob, dm, hmd->name, &hd.dvert, &hd.defgrp_index);
+
+	hd.curfalloff = hmd->curfalloff;
+
+	hd.falloff_type = hmd->falloff_type;
+	hd.falloff = (hmd->falloff_type == eHook_Falloff_None) ? 0.0f : hmd->falloff;
+	hd.falloff_sq = SQUARE(hd.falloff);
+	hd.fac_orig = hmd->force;
+
+	hd.use_falloff = (hd.falloff_sq != 0.0f);
+	hd.use_uniform = (hmd->flag & MOD_HOOK_UNIFORM_SPACE) != 0;
+
+	if (hd.use_uniform) {
+		copy_m3_m4(hd.mat_uniform, hmd->parentinv);
+		mul_v3_m3v3(hd.cent, hd.mat_uniform, hmd->cent);
+	}
+	else {
+		unit_m3(hd.mat_uniform);  /* unused */
+		copy_v3_v3(hd.cent, hmd->cent);
+	}
+
 	/* get world-space matrix of target, corrected for the space the verts are in */
 	if (hmd->subtarget[0] && pchan) {
 		/* bone target if there's a matching pose-channel */
@@ -156,10 +304,9 @@ static void deformVerts_do(HookModifierData *hmd, Object *ob, DerivedMesh *dm,
 		copy_m4_m4(dmat, hmd->object->obmat);
 	}
 	invert_m4_m4(ob->imat, ob->obmat);
-	mul_m4_series(mat, ob->imat, dmat, hmd->parentinv);
+	mul_m4_series(hd.mat, ob->imat, dmat, hmd->parentinv);
+	/* --- done with 'hd' init --- */
 
-	modifier_get_vgroup(ob, dm, hmd->name, &dvert, &defgrp_index);
-	max_dvert = (dvert) ? numVerts : 0;
 
 	/* Regarding index range checking below.
 	 *
@@ -168,13 +315,11 @@ static void deformVerts_do(HookModifierData *hmd, Object *ob, DerivedMesh *dm,
 	 * 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 */
@@ -185,16 +330,7 @@ static void deformVerts_do(HookModifierData *hmd, Object *ob, DerivedMesh *dm,
 					
 					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);
-								}
-							}
+							hook_co_apply(&hd, j);
 						}
 					}
 				}
@@ -203,34 +339,14 @@ static void deformVerts_do(HookModifierData *hmd, Object *ob, DerivedMesh *dm,
 		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);
-						}
-					}
+					hook_co_apply(&hd, *index_pt);
 				}
 			}
 		}
 	}
-	else if (dvert) {  /* vertex group hook */
-		const float fac_orig = hmd->force;
-		
-		for (i = 0; i < max_dvert; i++, dvert++) {
-			float fac;
-			float *co = vertexCos[i];
-			
-			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);
-				}
-			}
+	else if (hd.dvert) {  /* vertex group hook */
+		for (i = 0; i < numVerts; i++) {
+			hook_co_apply(&hd, i);
 		}
 	}
 }
diff --git a/source/blender/modifiers/intern/MOD_mask.c b/source/blender/modifiers/intern/MOD_mask.c
index 254ca0bda08..174f3df73d4 100644
--- a/source/blender/modifiers/intern/MOD_mask.c
+++ b/source/blender/modifiers/intern/MOD_mask.c
@@ -99,7 +99,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	const bool found_test = (mmd->flag & MOD_MASK_INV) == 0;
 	DerivedMesh *result = NULL;
 	GHash *vertHash = NULL, *edgeHash, *polyHash;
-	GHashIterator *hashIter;
+	GHashIterator gh_iter;
 	MDeformVert *dvert, *dv;
 	int numPolys = 0, numLoops = 0, numEdges = 0, numVerts = 0;
 	int maxVerts, maxEdges, maxPolys;
@@ -291,14 +291,11 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 	
 	/* using ghash-iterators, map data into new mesh */
 	/* vertices */
-	for (hashIter = BLI_ghashIterator_new(vertHash);
-	     BLI_ghashIterator_done(hashIter) == false;
-	     BLI_ghashIterator_step(hashIter))
-	{
+	GHASH_ITER (gh_iter, vertHash) {
 		MVert source;
 		MVert *dest;
-		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
-		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
+		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(&gh_iter));
+		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(&gh_iter));
 		
 		dm->getVert(dm, oldIndex, &source);
 		dest = &mvert_new[newIndex];
@@ -306,17 +303,13 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
 		*dest = source;
 	}
-	BLI_ghashIterator_free(hashIter);
 		
 	/* edges */
-	for (hashIter = BLI_ghashIterator_new(edgeHash);
-	     BLI_ghashIterator_done(hashIter) == false;
-	     BLI_ghashIterator_step(hashIter))
-	{
+	GHASH_ITER (gh_iter, edgeHash) {
 		MEdge source;
 		MEdge *dest;
-		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
-		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
+		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(&gh_iter));
+		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(&gh_iter));
 		
 		dm->getEdge(dm, oldIndex, &source);
 		dest = &medge_new[newIndex];
@@ -327,15 +320,11 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		DM_copy_edge_data(dm, result, oldIndex, newIndex, 1);
 		*dest = source;
 	}
-	BLI_ghashIterator_free(hashIter);
 	
 	/* faces */
-	for (hashIter = BLI_ghashIterator_new(polyHash);
-	     BLI_ghashIterator_done(hashIter) == false;
-	     BLI_ghashIterator_step(hashIter))
-	{
-		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
-		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
+	GHASH_ITER (gh_iter, polyHash) {
+		int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(&gh_iter));
+		int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(&gh_iter));
 		MPoly *source = &mpoly[oldIndex];
 		MPoly *dest = &mpoly_new[newIndex];
 		int oldLoopIndex = source->loopstart;
@@ -354,8 +343,6 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 		}
 	}
 
-	BLI_ghashIterator_free(hashIter);
-
 	MEM_freeN(loop_mapping);
 
 	/* why is this needed? - campbell */
diff --git a/source/blender/modifiers/intern/MOD_normal_edit.c b/source/blender/modifiers/intern/MOD_normal_edit.c
new file mode 100644
index 00000000000..58ef850bb4f
--- /dev/null
+++ b/source/blender/modifiers/intern/MOD_normal_edit.c
@@ -0,0 +1,501 @@
+/*
+ * ***** 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.
+ *
+ * Contributor(s): Bastien Montagne
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ */
+
+/** \file blender/modifiers/intern/MOD_normal_edit.c
+ *  \ingroup modifiers
+ */
+
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_object_types.h"
+#include "DNA_meshdata_types.h"
+#include "DNA_mesh_types.h"
+
+#include "BLI_math.h"
+#include "BLI_utildefines.h"
+#include "BLI_bitmap.h"
+
+#include "BKE_cdderivedmesh.h"
+#include "BKE_mesh.h"
+#include "BKE_deform.h"
+
+#include "depsgraph_private.h"
+
+#include "MOD_util.h"
+
+
+static void generate_vert_coordinates(
+        DerivedMesh *dm, Object *ob, Object *ob_center, const float offset[3],
+        const int num_verts, float (*r_cos)[3], float r_size[3])
+{
+	float min_co[3], max_co[3];
+	float diff[3];
+	bool do_diff = false;
+
+	INIT_MINMAX(min_co, max_co);
+
+	dm->getVertCos(dm, r_cos);
+
+	/* Get size (i.e. deformation of the spheroid generating normals), either from target object, or own geometry. */
+	if (ob_center) {
+		copy_v3_v3(r_size, ob_center->size);
+	}
+	else {
+		minmax_v3v3_v3_array(min_co, max_co, r_cos, num_verts);
+		/* Set size. */
+		sub_v3_v3v3(r_size, max_co, min_co);
+	}
+
+	/* Error checks - we do not want one or more of our sizes to be null! */
+	if (is_zero_v3(r_size)) {
+		r_size[0] = r_size[1] = r_size[2] = 1.0f;
+	}
+	else {
+		CLAMP_MIN(r_size[0], FLT_EPSILON);
+		CLAMP_MIN(r_size[1], FLT_EPSILON);
+		CLAMP_MIN(r_size[2], FLT_EPSILON);
+	}
+
+	if (ob_center) {
+		/* Translate our coordinates so that center of ob_center is at (0, 0, 0). */
+		float mat[4][4];
+
+		/* Get ob_center coordinates in ob local coordinates. */
+		invert_m4_m4(mat, ob_center->obmat);
+		mul_m4_m4m4(mat, mat, ob->obmat);
+		copy_v3_v3(diff, mat[3]);
+
+		do_diff = true;
+	}
+	else if (!is_zero_v3(offset)) {
+		negate_v3_v3(diff, offset);
+
+		do_diff = true;
+	}
+	/* Else, no need to change coordinates! */
+
+	if (do_diff) {
+		int i = num_verts;
+		while (i--) {
+			add_v3_v3(r_cos[i], diff);
+		}
+	}
+}
+
+/* Note this modifies nos_new in-place. */
+static void mix_normals(
+        const float mix_factor, MDeformVert *dvert, const int defgrp_index, const bool use_invert_vgroup,
+        const short mix_mode,
+        const int num_verts, MLoop *mloop, float (*nos_old)[3], float (*nos_new)[3], const int num_loops)
+{
+	/* Mix with org normals... */
+	float *facs = NULL, *wfac;
+	float (*no_new)[3], (*no_old)[3];
+	int i;
+
+	if (dvert) {
+		facs = MEM_mallocN(sizeof(*facs) * (size_t)num_loops, __func__);
+		BKE_defvert_extract_vgroup_to_loopweights(
+		            dvert, defgrp_index, num_verts, mloop, num_loops, facs, use_invert_vgroup);
+	}
+
+	for (i = num_loops, no_new = nos_new, no_old = nos_old, wfac = facs; i--; no_new++, no_old++, wfac++) {
+		const float fac = facs ? *wfac * mix_factor : mix_factor;
+
+		switch (mix_mode) {
+			case MOD_NORMALEDIT_MIX_ADD:
+				add_v3_v3(*no_new, *no_old);
+				normalize_v3(*no_new);
+				break;
+			case MOD_NORMALEDIT_MIX_SUB:
+				sub_v3_v3(*no_new, *no_old);
+				normalize_v3(*no_new);
+				break;
+			case MOD_NORMALEDIT_MIX_MUL:
+				mul_v3_v3(*no_new, *no_old);
+				normalize_v3(*no_new);
+				break;
+			case MOD_NORMALEDIT_MIX_COPY:
+				break;
+		}
+		interp_v3_v3v3_slerp_safe(*no_new, *no_old, *no_new, fac);
+	}
+
+	MEM_SAFE_FREE(facs);
+}
+
+static void normalEditModifier_do_radial(
+        NormalEditModifierData *smd, Object *ob, DerivedMesh *dm,
+        short (*clnors)[2], float (*loopnors)[3], float (*polynors)[3],
+        const short mix_mode, const float mix_factor,
+        MDeformVert *dvert, const int defgrp_index, const bool use_invert_vgroup,
+        MVert *mvert, const int num_verts, MEdge *medge, const int num_edges,
+        MLoop *mloop, const int num_loops, MPoly *mpoly, const int num_polys)
+{
+	int i;
+
+	float (*cos)[3] = MEM_mallocN(sizeof(*cos) * num_verts, __func__);
+	float (*nos)[3] = MEM_mallocN(sizeof(*nos) * num_loops, __func__);
+	float size[3];
+
+	BLI_bitmap *done_verts = BLI_BITMAP_NEW((size_t)num_verts, __func__);
+
+	generate_vert_coordinates(dm, ob, smd->target, smd->offset, num_verts, cos, size);
+
+	/**
+	 * size gives us our spheroid coefficients ``(A, B, C)``.
+	 * Then, we want to find out for each vert its (a, b, c) triple (proportional to (A, B, C) one).
+	 *
+	 * Ellipsoid basic equation: ``(x^2/a^2) + (y^2/b^2) + (z^2/c^2) = 1.``
+	 * Since we want to find (a, b, c) matching this equation and proportional to (A, B, C), we can do:
+	 * <pre>
+	 *     m = B / A
+	 *     n = C / A
+	 * </pre>
+	 *
+	 * hence:
+	 * <pre>
+	 *     (x^2/a^2) + (y^2/b^2) + (z^2/c^2) = 1
+	 *  -> b^2*c^2*x^2 + a^2*c^2*y^2 + a^2*b^2*z^2 = a^2*b^2*c^2
+	 *     b = ma
+	 *     c = na
+	 *  -> m^2*a^2*n^2*a^2*x^2 + a^2*n^2*a^2*y^2 + a^2*m^2*a^2*z^2 = a^2*m^2*a^2*n^2*a^2
+	 *  -> m^2*n^2*a^4*x^2 + n^2*a^4*y^2 + m^2*a^4*z^2 = m^2*n^2*a^6
+	 *  -> a^2 = (m^2*n^2*x^2 + n^2y^2 + m^2z^2) / (m^2*n^2) = x^2 + (y^2 / m^2) + (z^2 / n^2)
+	 *  -> b^2 = (m^2*n^2*x^2 + n^2y^2 + m^2z^2) / (n^2)     = (m^2 * x^2) + y^2 + (m^2 * z^2 / n^2)
+	 *  -> c^2 = (m^2*n^2*x^2 + n^2y^2 + m^2z^2) / (m^2)     = (n^2 * x^2) + (n^2 * y^2 / m^2) + z^2
+	 * </pre>
+	 *
+	 * All we have to do now is compute normal of the spheroid at that point:
+	 * <pre>
+	 *     n = (x / a^2, y / b^2, z / c^2)
+	 * </pre>
+	 * And we are done!
+	 */
+	{
+		const float a = size[0], b = size[1], c = size[2];
+		const float m2 = (b * b) / (a * a);
+		const float n2 = (c * c) / (a * a);
+
+		MLoop *ml;
+		float (*no)[3];
+
+		/* We reuse cos to now store the ellipsoid-normal of the verts! */
+		for (i = num_loops, ml = mloop, no = nos; i-- ; ml++, no++) {
+			const int vidx = ml->v;
+			float *co = cos[vidx];
+
+			if (!BLI_BITMAP_TEST(done_verts, vidx)) {
+				const float x2 = co[0] * co[0];
+				const float y2 = co[1] * co[1];
+				const float z2 = co[2] * co[2];
+				const float a2 = x2 + (y2 / m2) + (z2 / n2);
+				const float b2 = (m2 * x2) + y2 + (m2 * z2 / n2);
+				const float c2 = (n2 * x2) + (n2 * y2 / m2) + z2;
+
+				co[0] /= a2;
+				co[1] /= b2;
+				co[2] /= c2;
+				normalize_v3(co);
+
+				BLI_BITMAP_ENABLE(done_verts, vidx);
+			}
+			copy_v3_v3(*no, co);
+		}
+	}
+
+	if (loopnors) {
+		mix_normals(mix_factor, dvert, defgrp_index, use_invert_vgroup,
+		            mix_mode, num_verts, mloop, loopnors, nos, num_loops);
+	}
+
+	BKE_mesh_normals_loop_custom_set(mvert, num_verts, medge, num_edges, mloop, nos, num_loops,
+	                                 mpoly, (const float(*)[3])polynors, num_polys, clnors);
+
+	MEM_freeN(cos);
+	MEM_freeN(nos);
+	MEM_freeN(done_verts);
+}
+
+static void normalEditModifier_do_directional(
+        NormalEditModifierData *smd, Object *ob, DerivedMesh *dm,
+        short (*clnors)[2], float (*loopnors)[3], float (*polynors)[3],
+        const short mix_mode, const float mix_factor,
+        MDeformVert *dvert, const int defgrp_index, const bool use_invert_vgroup,
+        MVert *mvert, const int num_verts, MEdge *medge, const int num_edges,
+        MLoop *mloop, const int num_loops, MPoly *mpoly, const int num_polys)
+{
+	const bool use_parallel_normals = (smd->flag & MOD_NORMALEDIT_USE_DIRECTION_PARALLEL) != 0;
+
+	float (*cos)[3] = MEM_mallocN(sizeof(*cos) * num_verts, __func__);
+	float (*nos)[3] = MEM_mallocN(sizeof(*nos) * num_loops, __func__);
+
+	float target_co[3];
+	int i;
+
+	dm->getVertCos(dm, cos);
+
+	/* Get target's center coordinates in ob local coordinates. */
+	{
+		float mat[4][4];
+
+		invert_m4_m4(mat, ob->obmat);
+		mul_m4_m4m4(mat, mat, smd->target->obmat);
+		copy_v3_v3(target_co, mat[3]);
+	}
+
+	if (use_parallel_normals) {
+		float no[3];
+
+		sub_v3_v3v3(no, target_co, smd->offset);
+		normalize_v3(no);
+
+		for (i = num_loops; i--; ) {
+			copy_v3_v3(nos[i], no);
+		}
+	}
+	else {
+		BLI_bitmap *done_verts = BLI_BITMAP_NEW((size_t)num_verts, __func__);
+		MLoop *ml;
+		float (*no)[3];
+
+		/* We reuse cos to now store the 'to target' normal of the verts! */
+		for (i = num_loops, no = nos, ml = mloop; i--; no++, ml++) {
+			const int vidx = ml->v;
+			float *co = cos[vidx];
+
+			if (!BLI_BITMAP_TEST(done_verts, vidx)) {
+				sub_v3_v3v3(co, target_co, co);
+				normalize_v3(co);
+
+				BLI_BITMAP_ENABLE(done_verts, vidx);
+			}
+
+			copy_v3_v3(*no, co);
+		}
+
+		MEM_freeN(done_verts);
+	}
+
+	if (loopnors) {
+		mix_normals(mix_factor, dvert, defgrp_index, use_invert_vgroup,
+		            mix_mode, num_verts, mloop, loopnors, nos, num_loops);
+	}
+
+	BKE_mesh_normals_loop_custom_set(mvert, num_verts, medge, num_edges, mloop, nos, num_loops,
+	                                 mpoly, (const float(*)[3])polynors, num_polys, clnors);
+
+	MEM_freeN(cos);
+	MEM_freeN(nos);
+}
+
+static bool is_valid_target(NormalEditModifierData *smd)
+{
+	if (smd->mode == MOD_NORMALEDIT_MODE_RADIAL) {
+		return true;
+	}
+	else if ((smd->mode == MOD_NORMALEDIT_MODE_DIRECTIONAL) && smd->target) {
+		return true;
+	}
+	modifier_setError((ModifierData *)smd, "Invalid target settings");
+	return false;
+}
+
+static void normalEditModifier_do(NormalEditModifierData *smd, Object *ob, DerivedMesh *dm)
+{
+	Mesh *me = ob->data;
+
+	const int num_verts = dm->getNumVerts(dm);
+	const int num_edges = dm->getNumEdges(dm);
+	const int num_loops = dm->getNumLoops(dm);
+	const int num_polys = dm->getNumPolys(dm);
+	MVert *mvert = dm->getVertArray(dm);
+	MEdge *medge = dm->getEdgeArray(dm);
+	MLoop *mloop = dm->getLoopArray(dm);
+	MPoly *mpoly = dm->getPolyArray(dm);
+
+	const bool use_invert_vgroup = ((smd->flag & MOD_NORMALEDIT_INVERT_VGROUP) != 0);
+	const bool use_current_clnors = !((smd->mix_mode == MOD_NORMALEDIT_MIX_COPY) &&
+	                                  (smd->mix_factor == 1.0f) &&
+	                                  (smd->defgrp_name[0] == '\0'));
+
+	int defgrp_index;
+	MDeformVert *dvert;
+
+	float (*loopnors)[3] = NULL;
+	short (*clnors)[2];
+
+	float (*polynors)[3];
+	bool free_polynors = false;
+
+	/* Do not run that modifier at all if autosmooth is disabled! */
+	if (!is_valid_target(smd) || !num_loops) {
+		return;
+	}
+
+	if (!(me->flag & ME_AUTOSMOOTH)) {
+		modifier_setError((ModifierData *)smd, "Enable 'Auto Smooth' option in mesh settings");
+		return;
+	}
+
+
+	if (use_current_clnors) {
+		dm->calcLoopNormals(dm, true, me->smoothresh);
+		loopnors = dm->getLoopDataArray(dm, CD_NORMAL);
+	}
+
+	clnors = CustomData_duplicate_referenced_layer(&dm->loopData, CD_CUSTOMLOOPNORMAL, num_loops);
+	if (!clnors) {
+		DM_add_loop_layer(dm, CD_CUSTOMLOOPNORMAL, CD_CALLOC, NULL);
+		clnors = dm->getLoopDataArray(dm, CD_CUSTOMLOOPNORMAL);
+	}
+
+	polynors = dm->getPolyDataArray(dm, CD_NORMAL);
+	if (!polynors) {
+		polynors = MEM_mallocN(sizeof(*polynors) * num_polys, __func__);
+		BKE_mesh_calc_normals_poly(mvert, num_verts, mloop, mpoly, num_loops, num_polys, polynors, false);
+		free_polynors = true;
+	}
+
+	modifier_get_vgroup(ob, dm, smd->defgrp_name, &dvert, &defgrp_index);
+
+	if (smd->mode == MOD_NORMALEDIT_MODE_RADIAL) {
+		normalEditModifier_do_radial(
+		            smd, ob, dm, clnors, loopnors, polynors,
+		            smd->mix_mode, smd->mix_factor, dvert, defgrp_index, use_invert_vgroup,
+		            mvert, num_verts, medge, num_edges, mloop, num_loops, mpoly, num_polys);
+	}
+	else if (smd->mode == MOD_NORMALEDIT_MODE_DIRECTIONAL) {
+		normalEditModifier_do_directional(
+		            smd, ob, dm, clnors, loopnors, polynors,
+		            smd->mix_mode, smd->mix_factor, dvert, defgrp_index, use_invert_vgroup,
+		            mvert, num_verts, medge, num_edges, mloop, num_loops, mpoly, num_polys);
+	}
+
+	if (free_polynors) {
+		MEM_freeN(polynors);
+	}
+}
+
+static void initData(ModifierData *md)
+{
+	NormalEditModifierData *smd = (NormalEditModifierData *)md;
+
+	smd->mode = MOD_NORMALEDIT_MODE_RADIAL;
+
+	smd->mix_mode = MOD_NORMALEDIT_MIX_COPY;
+	smd->mix_factor = 1.0f;
+}
+
+static void copyData(ModifierData *md, ModifierData *target)
+{
+	modifier_copyData_generic(md, target);
+}
+
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+{
+	NormalEditModifierData *smd = (NormalEditModifierData *)md;
+	CustomDataMask dataMask = CD_CUSTOMLOOPNORMAL;
+
+	/* Ask for vertexgroups if we need them. */
+	if (smd->defgrp_name[0]) {
+		dataMask |= (CD_MASK_MDEFORMVERT);
+	}
+
+	return dataMask;
+}
+
+static bool dependsOnNormals(ModifierData *UNUSED(md))
+{
+	return true;
+}
+
+static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk, void *userData)
+{
+	NormalEditModifierData *smd = (NormalEditModifierData *) md;
+
+	walk(userData, ob, &smd->target);
+}
+
+static void foreachIDLink(ModifierData *md, Object *ob, IDWalkFunc walk, void *userData)
+{
+	NormalEditModifierData *smd = (NormalEditModifierData *) md;
+
+	walk(userData, ob, (ID **)&smd->target);
+}
+
+static bool isDisabled(ModifierData *md, int UNUSED(useRenderParams))
+{
+	NormalEditModifierData *smd = (NormalEditModifierData *)md;
+
+	return !is_valid_target(smd);
+}
+
+static void updateDepgraph(ModifierData *md, DagForest *forest, struct Scene *UNUSED(scene),
+                           Object *UNUSED(ob), DagNode *obNode)
+{
+	NormalEditModifierData *smd = (NormalEditModifierData *) md;
+
+	if (smd->target) {
+		DagNode *Node = dag_get_node(forest, smd->target);
+
+		dag_add_relation(forest, Node, obNode, DAG_RL_OB_DATA, "NormalEdit Modifier");
+	}
+}
+
+static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *dm, ModifierApplyFlag UNUSED(flag))
+{
+	normalEditModifier_do((NormalEditModifierData *)md, ob, dm);
+	return dm;
+}
+
+ModifierTypeInfo modifierType_NormalEdit = {
+	/* name */              "Set Split Normals",
+	/* structName */        "NormalEditModifierData",
+	/* structSize */        sizeof(NormalEditModifierData),
+	/* type */              eModifierTypeType_Constructive,
+	/* flags */             eModifierTypeFlag_AcceptsMesh |
+	                        eModifierTypeFlag_AcceptsCVs |
+	                        eModifierTypeFlag_SupportsMapping |
+	                        eModifierTypeFlag_SupportsEditmode |
+	                        eModifierTypeFlag_EnableInEditmode,
+	/* copyData */          copyData,
+	/* deformVerts */       NULL,
+	/* deformMatrices */    NULL,
+	/* deformVertsEM */     NULL,
+	/* deformMatricesEM */  NULL,
+	/* applyModifier */     applyModifier,
+	/* applyModifierEM */   NULL,
+	/* initData */          initData,
+	/* requiredDataMask */  requiredDataMask,
+	/* freeData */          NULL,
+	/* isDisabled */        isDisabled,
+	/* updateDepgraph */    updateDepgraph,
+	/* dependsOnTime */     NULL,
+	/* dependsOnNormals */  dependsOnNormals,
+	/* foreachObjectLink */ foreachObjectLink,
+	/* foreachIDLink */     foreachIDLink,
+	/* foreachTexLink */    NULL,
+};
diff --git a/source/blender/modifiers/intern/MOD_util.c b/source/blender/modifiers/intern/MOD_util.c
index fe83166c09f..c23c22b5fec 100644
--- a/source/blender/modifiers/intern/MOD_util.c
+++ b/source/blender/modifiers/intern/MOD_util.c
@@ -305,5 +305,6 @@ void modifier_type_init(ModifierTypeInfo *types[])
 	INIT_TYPE(LaplacianDeform);
 	INIT_TYPE(Wireframe);
 	INIT_TYPE(DataTransfer);
+	INIT_TYPE(NormalEdit);
 #undef INIT_TYPE
 }
diff --git a/source/blender/modifiers/intern/MOD_warp.c b/source/blender/modifiers/intern/MOD_warp.c
index ed0d18fc484..3eb34e56700 100644
--- a/source/blender/modifiers/intern/MOD_warp.c
+++ b/source/blender/modifiers/intern/MOD_warp.c
@@ -265,6 +265,9 @@ static void warpModifier_do(WarpModifierData *wmd, Object *ob,
 				case eWarp_Falloff_Sphere:
 					fac = sqrtf(2 * fac - fac * fac);
 					break;
+				case eWarp_Falloff_InvSquare:
+					fac = fac * (2.0f - fac);
+					break;
 			}
 
 			fac *= weight;
diff --git a/source/blender/modifiers/intern/MOD_wireframe.c b/source/blender/modifiers/intern/MOD_wireframe.c
index 8b611f9e6da..aa5e6116516 100644
--- a/source/blender/modifiers/intern/MOD_wireframe.c
+++ b/source/blender/modifiers/intern/MOD_wireframe.c
@@ -74,7 +74,7 @@ static bool dependsOnNormals(ModifierData *UNUSED(md))
 	return true;
 }
 
-static DerivedMesh *WireframeModifier_do( WireframeModifierData *wmd, Object *ob, DerivedMesh *dm)
+static DerivedMesh *WireframeModifier_do(WireframeModifierData *wmd, Object *ob, DerivedMesh *dm)
 {
 	DerivedMesh *result;
 	BMesh *bm;
diff --git a/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.c b/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.c
index 7a15d6364dc..415427c360f 100644
--- a/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.c
+++ b/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.c
@@ -47,7 +47,8 @@ static bNodeSocketTemplate cmp_node_planetrackdeform_out[] = {
 static void init(bNodeTree *UNUSED(ntree), bNode *node)
 {
 	NodePlaneTrackDeformData *data = MEM_callocN(sizeof(NodePlaneTrackDeformData), "node plane track deform data");
-
+	data->motion_blur_samples = 16;
+	data->motion_blur_shutter = 0.5f;
 	node->storage = data;
 }
 
diff --git a/source/blender/nodes/texture/nodes/node_texture_math.c b/source/blender/nodes/texture/nodes/node_texture_math.c
index 1984ee506e0..19bc16fb82d 100644
--- a/source/blender/nodes/texture/nodes/node_texture_math.c
+++ b/source/blender/nodes/texture/nodes/node_texture_math.c
@@ -195,6 +195,10 @@ static void valuefn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor
 			break;
 		}
 	}
+
+	if (node->custom2 & SHD_MATH_CLAMP) {
+		CLAMP(*out, 0.0f, 1.0f);
+	}
 }
 
 static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out)
diff --git a/source/blender/render/intern/source/bake_api.c b/source/blender/render/intern/source/bake_api.c
index 90deac2de32..48ef29150d3 100644
--- a/source/blender/render/intern/source/bake_api.c
+++ b/source/blender/render/intern/source/bake_api.c
@@ -444,7 +444,7 @@ bool RE_bake_pixels_populate_from_objects(
 	size_t i;
 	int primitive_id;
 	float u, v;
-	float imat_low [4][4];
+	float imat_low[4][4];
 	bool is_cage = me_cage != NULL;
 	bool result = true;
 
diff --git a/source/blender/render/intern/source/convertblender.c b/source/blender/render/intern/source/convertblender.c
index 1a8c4681862..ba778ec30e9 100644
--- a/source/blender/render/intern/source/convertblender.c
+++ b/source/blender/render/intern/source/convertblender.c
@@ -3316,7 +3316,7 @@ static void init_render_mesh(Render *re, ObjectRen *obr, int timeoffset)
 							v2= mface->v2;
 							v3= reverse_verts==0 ? mface->v3 : mface->v1;
 							v4= mface->v4;
-							flag= mface->flag & ME_SMOOTH;
+							flag = do_autosmooth ? ME_SMOOTH : mface->flag & ME_SMOOTH;
 
 							vlr= RE_findOrAddVlak(obr, obr->totvlak++);
 							vlr->v1= RE_findOrAddVert(obr, vertofs+v1);
diff --git a/source/blender/render/intern/source/sss.c b/source/blender/render/intern/source/sss.c
index 8ea3a753283..890b0445ecc 100644
--- a/source/blender/render/intern/source/sss.c
+++ b/source/blender/render/intern/source/sss.c
@@ -1031,14 +1031,12 @@ void make_sss_tree(Render *re)
 void free_sss(Render *re)
 {
 	if (re->sss_hash) {
-		GHashIterator *it= BLI_ghashIterator_new(re->sss_hash);
+		GHashIterator gh_iter;
 
-		while (!BLI_ghashIterator_done(it)) {
-			sss_free_tree(BLI_ghashIterator_getValue(it));
-			BLI_ghashIterator_step(it);
+		GHASH_ITER (gh_iter, re->sss_hash) {
+			sss_free_tree(BLI_ghashIterator_getValue(&gh_iter));
 		}
 
-		BLI_ghashIterator_free(it);
 		BLI_ghash_free(re->sss_hash, NULL, NULL);
 		re->sss_hash= NULL;
 	}
diff --git a/source/blender/windowmanager/intern/wm.c b/source/blender/windowmanager/intern/wm.c
index a6a3c6b0a28..34069e0b873 100644
--- a/source/blender/windowmanager/intern/wm.c
+++ b/source/blender/windowmanager/intern/wm.c
@@ -250,15 +250,14 @@ void WM_uilisttype_init(void)
 
 void WM_uilisttype_free(void)
 {
-	GHashIterator *iter = BLI_ghashIterator_new(uilisttypes_hash);
+	GHashIterator gh_iter;
 
-	for (; !BLI_ghashIterator_done(iter); BLI_ghashIterator_step(iter)) {
-		uiListType *ult = BLI_ghashIterator_getValue(iter);
+	GHASH_ITER (gh_iter, uilisttypes_hash) {
+		uiListType *ult = BLI_ghashIterator_getValue(&gh_iter);
 		if (ult->ext.free) {
 			ult->ext.free(ult->ext.data);
 		}
 	}
-	BLI_ghashIterator_free(iter);
 
 	BLI_ghash_free(uilisttypes_hash, NULL, MEM_freeN);
 	uilisttypes_hash = NULL;
@@ -309,15 +308,14 @@ void WM_menutype_init(void)
 
 void WM_menutype_free(void)
 {
-	GHashIterator *iter = BLI_ghashIterator_new(menutypes_hash);
+	GHashIterator gh_iter;
 
-	for (; !BLI_ghashIterator_done(iter); BLI_ghashIterator_step(iter)) {
-		MenuType *mt = BLI_ghashIterator_getValue(iter);
+	GHASH_ITER (gh_iter, menutypes_hash) {
+		MenuType *mt = BLI_ghashIterator_getValue(&gh_iter);
 		if (mt->ext.free) {
 			mt->ext.free(mt->ext.data);
 		}
 	}
-	BLI_ghashIterator_free(iter);
 
 	BLI_ghash_free(menutypes_hash, NULL, MEM_freeN);
 	menutypes_hash = NULL;
diff --git a/source/blender/windowmanager/intern/wm_event_system.c b/source/blender/windowmanager/intern/wm_event_system.c
index 62f46cc78a3..4b8af999205 100644
--- a/source/blender/windowmanager/intern/wm_event_system.c
+++ b/source/blender/windowmanager/intern/wm_event_system.c
@@ -729,7 +729,7 @@ static int wm_operator_exec(bContext *C, wmOperator *op, const bool repeat, cons
 	/* XXX Disabled the repeat check to address part 2 of #31840.
 	 *     Carefully checked all calls to wm_operator_exec and WM_operator_repeat, don't see any reason
 	 *     why this was needed, but worth to note it in case something turns bad. (mont29) */
-	if (retval & (OPERATOR_FINISHED | OPERATOR_CANCELLED)/* && repeat == 0 */)
+	if (retval & (OPERATOR_FINISHED | OPERATOR_CANCELLED) /* && repeat == 0 */)
 		wm_operator_reports(C, op, retval, false);
 	
 	if (retval & OPERATOR_FINISHED) {
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index aa3788bbc90..c0f8709b0f7 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -1677,7 +1677,7 @@ int WM_operator_ui_popup(bContext *C, wmOperator *op, int width, int height)
 /**
  * For use by #WM_operator_props_popup_call, #WM_operator_props_popup only.
  *
- * \note operator menu needs undo flag enabled , for redo callback */
+ * \note operator menu needs undo flag enabled, for redo callback */
 static int wm_operator_props_popup_ex(bContext *C, wmOperator *op,
                                       const bool do_call, const bool do_redo)
 {
@@ -3816,8 +3816,8 @@ void WM_OT_straightline_gesture(wmOperatorType *ot)
 
 /* *********************** radial control ****************** */
 
-#define WM_RADIAL_CONTROL_DISPLAY_SIZE 200
-#define WM_RADIAL_CONTROL_DISPLAY_MIN_SIZE 35
+#define WM_RADIAL_CONTROL_DISPLAY_SIZE (200 * U.pixelsize)
+#define WM_RADIAL_CONTROL_DISPLAY_MIN_SIZE (35 * U.pixelsize)
 #define WM_RADIAL_CONTROL_DISPLAY_WIDTH (WM_RADIAL_CONTROL_DISPLAY_SIZE - WM_RADIAL_CONTROL_DISPLAY_MIN_SIZE)
 #define WM_RADIAL_CONTROL_HEADER_LENGTH 180
 #define WM_RADIAL_MAX_STR 6
@@ -3868,7 +3868,7 @@ static void radial_control_set_initial_mouse(RadialControl *rc, const wmEvent *e
 		case PROP_DISTANCE:
 		case PROP_PERCENTAGE:
 		case PROP_PIXEL:
-			d[0] = rc->initial_value;
+			d[0] = rc->initial_value * U.pixelsize;
 			break;
 		case PROP_FACTOR:
 			d[0] = (1 - rc->initial_value) * WM_RADIAL_CONTROL_DISPLAY_WIDTH + WM_RADIAL_CONTROL_DISPLAY_MIN_SIZE;
@@ -3977,8 +3977,8 @@ static void radial_control_paint_cursor(bContext *C, int x, int y, void *customd
 		case PROP_DISTANCE:
 		case PROP_PERCENTAGE:
 		case PROP_PIXEL:
-			r1 = rc->current_value;
-			r2 = rc->initial_value;
+			r1 = rc->current_value * U.pixelsize;
+			r2 = rc->initial_value * U.pixelsize;
 			tex_radius = r1;
 			alpha = 0.75;
 			break;
@@ -4003,11 +4003,6 @@ static void radial_control_paint_cursor(bContext *C, int x, int y, void *customd
 			break;
 	}
 
-	/* adjust for DPI, like BKE_brush_size_get */
-	r1 *= U.pixelsize;
-	r2 *= U.pixelsize;
-	tex_radius *= U.pixelsize;
-
 	/* Keep cursor in the original place */
 	x = rc->initial_mouse[0] - ar->winrct.xmin;
 	y = rc->initial_mouse[1] - ar->winrct.ymin;
@@ -4425,6 +4420,7 @@ static int radial_control_modal(bContext *C, wmOperator *op, const wmEvent *even
 						case PROP_PIXEL:
 							new_value = dist;
 							if (snap) new_value = ((int)new_value + 5) / 10 * 10;
+							new_value /= U.pixelsize;
 							break;
 						case PROP_FACTOR:
 							new_value = (WM_RADIAL_CONTROL_DISPLAY_SIZE - dist) / WM_RADIAL_CONTROL_DISPLAY_WIDTH;
diff --git a/source/gameengine/GameLogic/SCA_IScene.cpp b/source/gameengine/GameLogic/SCA_IScene.cpp
index 3ca4b6607b3..b6ce1d86ba7 100644
--- a/source/gameengine/GameLogic/SCA_IScene.cpp
+++ b/source/gameengine/GameLogic/SCA_IScene.cpp
@@ -114,7 +114,7 @@ void SCA_IScene::RemoveDebugProperty(class CValue *gameobj,
 								  const STR_String &name)
 {
 	vector<SCA_DebugProp*>::iterator it = m_debugList.begin();
-	while(it != m_debugList.end()) {
+	while (it != m_debugList.end()) {
 		STR_String debugname = (*it)->m_name;
 		CValue *debugobj = (*it)->m_obj;
 
diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp
index e8b68d20e84..6d4b5564e19 100644
--- a/source/gameengine/Ketsji/KX_GameObject.cpp
+++ b/source/gameengine/Ketsji/KX_GameObject.cpp
@@ -77,6 +77,8 @@ typedef unsigned long uint_ptr;
 #include "BL_Action.h"
 
 #include "PyObjectPlus.h" /* python stuff */
+#include "BLI_utildefines.h"
+#include "python_utildefines.h"
 
 // This file defines relationships between parents and children
 // in the game engine.
@@ -1498,7 +1500,7 @@ void KX_GameObject::RegisterCollisionCallbacks()
 			pe->AddSensor(spc);
 	}
 }
-void KX_GameObject::RunCollisionCallbacks(KX_GameObject *collider)
+void KX_GameObject::RunCollisionCallbacks(KX_GameObject *collider, const MT_Vector3 &point, const MT_Vector3 &normal)
 {
 	#ifdef WITH_PYTHON
 	Py_ssize_t len;
@@ -1506,15 +1508,50 @@ void KX_GameObject::RunCollisionCallbacks(KX_GameObject *collider)
 
 	if (collision_callbacks && (len=PyList_GET_SIZE(collision_callbacks)))
 	{
-		PyObject* args = Py_BuildValue("(O)", collider->GetProxy()); // save python creating each call
+		// Argument tuples are created lazily, only when they are needed.
+		PyObject *args_3 = NULL;
+		PyObject *args_1 = NULL; // Only for compatibility with pre-2.74 callbacks that take 1 argument.
+
 		PyObject *func;
 		PyObject *ret;
+		int co_argcount;
 
 		// Iterate the list and run the callbacks
 		for (Py_ssize_t pos=0; pos < len; pos++)
 		{
 			func = PyList_GET_ITEM(collision_callbacks, pos);
-			ret = PyObject_Call(func, args, NULL);
+
+			// Get the number of arguments, supporting functions, methods and generic callables.
+			if (PyMethod_Check(func)) {
+				// Take away the 'self' argument for methods.
+				co_argcount = ((PyCodeObject *)PyFunction_GET_CODE(PyMethod_GET_FUNCTION(func)))->co_argcount - 1;
+			} else if (PyFunction_Check(func)) {
+				co_argcount = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_argcount;
+			} else {
+				// We'll just assume the callable takes the correct number of arguments.
+				co_argcount = 3;
+			}
+
+			// Check whether the function expects the colliding object only,
+			// or also the point and normal.
+			if (co_argcount <= 1) {
+				// One argument, or *args (which gives co_argcount == 0)
+				if (args_1 == NULL) {
+					args_1 = PyTuple_New(1);
+					PyTuple_SET_ITEMS(args_1, collider->GetProxy());
+				}
+				ret = PyObject_Call(func, args_1, NULL);
+			} else {
+				// More than one argument, assume we can give point & normal.
+				if (args_3 == NULL) {
+					args_3 = PyTuple_New(3);
+					PyTuple_SET_ITEMS(args_3,
+					                  collider->GetProxy(),
+					                  PyObjectFrom(point),
+					                  PyObjectFrom(normal));
+				}
+				ret = PyObject_Call(func, args_3, NULL);
+			}
 
 			if (ret == NULL) {
 				PyErr_Print();
@@ -1525,7 +1562,8 @@ void KX_GameObject::RunCollisionCallbacks(KX_GameObject *collider)
 			}
 		}
 
-		Py_DECREF(args);
+		if (args_3) Py_DECREF(args_3);
+		if (args_1) Py_DECREF(args_1);
 	}
 	#endif
 }
diff --git a/source/gameengine/Ketsji/KX_GameObject.h b/source/gameengine/Ketsji/KX_GameObject.h
index 4538679303f..5800cbc6834 100644
--- a/source/gameengine/Ketsji/KX_GameObject.h
+++ b/source/gameengine/Ketsji/KX_GameObject.h
@@ -919,7 +919,7 @@ public:
 
 	void RegisterCollisionCallbacks();
 	void UnregisterCollisionCallbacks();
-	void RunCollisionCallbacks(KX_GameObject *collider);
+	void RunCollisionCallbacks(KX_GameObject *collider, const MT_Vector3 &point, const MT_Vector3 &normal);
 	/**
 	 * Stop making progress
 	 */
diff --git a/source/gameengine/Ketsji/KX_TouchEventManager.cpp b/source/gameengine/Ketsji/KX_TouchEventManager.cpp
index 7ec379eec26..eb774960d41 100644
--- a/source/gameengine/Ketsji/KX_TouchEventManager.cpp
+++ b/source/gameengine/Ketsji/KX_TouchEventManager.cpp
@@ -60,7 +60,7 @@ bool	KX_TouchEventManager::NewHandleCollision(void* object1, void* object2, cons
 	PHY_IPhysicsController* obj1 = static_cast<PHY_IPhysicsController*>(object1);
 	PHY_IPhysicsController* obj2 = static_cast<PHY_IPhysicsController*>(object2);
 	
-	m_newCollisions.insert(std::pair<PHY_IPhysicsController*, PHY_IPhysicsController*>(obj1, obj2));
+	m_newCollisions.insert(NewCollision(obj1, obj2, coll_data));
 		
 	return false;
 }
@@ -209,9 +209,11 @@ void KX_TouchEventManager::NextFrame()
 				}
 			}
 			// Run python callbacks
-			kxObj1->RunCollisionCallbacks(kxObj2);
-			kxObj2->RunCollisionCallbacks(kxObj1);
+			PHY_CollData *colldata = cit->colldata;
+			kxObj1->RunCollisionCallbacks(kxObj2, colldata->m_point1, colldata->m_normal);
+			kxObj2->RunCollisionCallbacks(kxObj1, colldata->m_point2, -colldata->m_normal);
 
+			delete cit->colldata;
 		}
 			
 		m_newCollisions.clear();
@@ -219,3 +221,19 @@ void KX_TouchEventManager::NextFrame()
 		for (it.begin();!it.end();++it)
 			(*it)->Activate(m_logicmgr);
 	}
+
+
+KX_TouchEventManager::NewCollision::NewCollision(PHY_IPhysicsController *first,
+                                                 PHY_IPhysicsController *second,
+                                                 const PHY_CollData *colldata)
+    : first(first), second(second), colldata(new PHY_CollData(*colldata))
+{}
+
+KX_TouchEventManager::NewCollision::NewCollision(const NewCollision &to_copy)
+	: first(to_copy.first), second(to_copy.second), colldata(to_copy.colldata)
+{}
+
+bool KX_TouchEventManager::NewCollision::operator<(const NewCollision &other) const
+{
+	return first < other.first || second < other.second || colldata < other.colldata;
+}
diff --git a/source/gameengine/Ketsji/KX_TouchEventManager.h b/source/gameengine/Ketsji/KX_TouchEventManager.h
index bd4903c1545..d9c6fdad307 100644
--- a/source/gameengine/Ketsji/KX_TouchEventManager.h
+++ b/source/gameengine/Ketsji/KX_TouchEventManager.h
@@ -45,7 +45,29 @@ class PHY_IPhysicsEnvironment;
 
 class KX_TouchEventManager : public SCA_EventManager
 {
-	typedef std::pair<PHY_IPhysicsController*, PHY_IPhysicsController*> NewCollision;
+	/**
+	 * Contains two colliding objects and the first contact point.
+	 */
+	class NewCollision {
+	public:
+		PHY_IPhysicsController *first;
+		PHY_IPhysicsController *second;
+		PHY_CollData *colldata;
+
+		/**
+	     * Creates a copy of the given PHY_CollData; freeing that copy should be done by the owner of
+	     * the NewCollision object.
+	     *
+	     * This allows us to efficiently store NewCollision objects in a std::set without creating more
+	     * copies of colldata, as the NewCollision copy constructor reuses the pointer and doesn't clone
+	     * it again. */
+		NewCollision(PHY_IPhysicsController *first,
+		             PHY_IPhysicsController *second,
+		             const PHY_CollData *colldata);
+		NewCollision(const NewCollision &to_copy);
+		bool operator<(const NewCollision &other) const;
+	};
+
 	PHY_IPhysicsEnvironment*	m_physEnv;
 	
 	std::set<NewCollision> m_newCollisions;
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
index bcdc6f471ec..c43a3f782a7 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
@@ -2261,6 +2261,7 @@ void	CcdPhysicsEnvironment::CallbackTriggers()
 	int numManifolds = dispatcher->getNumManifolds();
 	for (int i=0;i<numManifolds;i++)
 	{
+		bool colliding_ctrl0 = true;
 		btPersistentManifold* manifold = dispatcher->getManifoldByIndexInternal(i);
 		int numContacts = manifold->getNumContacts();
 		if (!numContacts) continue;
@@ -2289,12 +2290,27 @@ void	CcdPhysicsEnvironment::CallbackTriggers()
 		if (iter == m_triggerControllers.end())
 		{
 			iter = m_triggerControllers.find(ctrl1);
+			colliding_ctrl0 = false;
 		}
 
 		if (iter != m_triggerControllers.end())
 		{
+			static PHY_CollData coll_data;
+			const btManifoldPoint &cp = manifold->getContactPoint(0);
+
+			/* Make sure that "point1" is always on the object we report on, and
+			 * "point2" on the other object. Also ensure the normal is oriented
+			 * correctly. */
+			btVector3 point1 = colliding_ctrl0 ? cp.m_positionWorldOnA : cp.m_positionWorldOnB;
+			btVector3 point2 = colliding_ctrl0 ? cp.m_positionWorldOnB : cp.m_positionWorldOnA;
+			btVector3 normal = colliding_ctrl0 ? -cp.m_normalWorldOnB : cp.m_normalWorldOnB;
+
+			coll_data.m_point1 = MT_Vector3(point1.m_floats);
+			coll_data.m_point2 = MT_Vector3(point2.m_floats);
+			coll_data.m_normal = MT_Vector3(normal.m_floats);
+
 			m_triggerCallbacks[PHY_OBJECT_RESPONSE](m_triggerCallbacksUserPtrs[PHY_OBJECT_RESPONSE],
-				ctrl0,ctrl1,0);
+				ctrl0, ctrl1, &coll_data);
 		}
 		// Bullet does not refresh the manifold contact point for object without contact response
 		// may need to remove this when a newer Bullet version is integrated