Fix second issue introduced in refactoring/cleanup of weighted normals.

'degenerated too short normals' check was probably a bit too aggressive,
moved it back to more common 1e-6 value.

README.md

@@ -0,0 +1,30 @@
+# soc-2017-normal-tools
+
+Clone of my GSoC branch hosted at Blender's git servers [soc-2017-normal-tools](https://git.blender.org/gitweb/gitweb.cgi/blender.git/shortlog/refs/heads/soc-2017-normal-tools)
+
+
+
+### Phabricator tracker
+
+https://developer.blender.org/diffusion/B/browse/soc-2017-normal-tools/
+
+### Proposal 
+
+https://wiki.blender.org/index.php/User:RohanRathi/GSoC_2017/Proposal
+
+### Weekly Reports
+
+https://wiki.blender.org/index.php/User:RohanRathi/GSoC_2017/Reports
+
+### Blender Artists thread 
+
+https://blenderartists.org/forum/showthread.php?427746-GSoC-2017-Normal-Editing-Tools
+
+### User Documentation
+
+https://wiki.blender.org/index.php/User:RohanRathi/GSoC_2017/User_Documentation
+
+
+
+
+Do note that this branch does not include any other work not associated with Normal editing.

release/scripts/modules/bpy_extras/keyconfig_utils.py

@@ -56,6 +56,7 @@ KM_HIERARCHY = [
         ('Particle', 'EMPTY', 'WINDOW', []),
 
         ('Knife Tool Modal Map', 'EMPTY', 'WINDOW', []),
+        ('Custom Normals Modal Map', 'EMPTY', 'WINDOW', []),
         ('Paint Stroke Modal', 'EMPTY', 'WINDOW', []),
         ('Paint Curve', 'EMPTY', 'WINDOW', []),
 

release/scripts/startup/bl_operators/mesh.py

@@ -203,57 +203,7 @@ class MeshSelectPrev(Operator):
         return {'FINISHED'}
 
 
-# XXX This is hackish (going forth and back from Object mode...), to be redone once we have proper support of
-#     custom normals in BMesh/edit mode.
-class MehsSetNormalsFromFaces(Operator):
-    """Set the custom vertex normals from the selected faces ones"""
-    bl_idname = "mesh.set_normals_from_faces"
-    bl_label = "Set Normals From Faces"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return (context.mode == 'EDIT_MESH' and context.edit_object.data.polygons)
-
-    def execute(self, context):
-        import mathutils
-
-        bpy.ops.object.mode_set(mode='OBJECT')
-        obj = context.active_object
-        me = obj.data
-
-        v2nors = {}
-        for p in me.polygons:
-            if not p.select:
-                continue
-            for lidx, vidx in zip(p.loop_indices, p.vertices):
-                assert(me.loops[lidx].vertex_index == vidx)
-                v2nors.setdefault(vidx, []).append(p.normal)
-
-        for nors in v2nors.values():
-            nors[:] = [sum(nors, mathutils.Vector((0, 0, 0))).normalized()]
-
-        if not me.has_custom_normals:
-            me.create_normals_split()
-        me.calc_normals_split()
-
-        normals = []
-        for l in me.loops:
-            nor = v2nors.get(l.vertex_index, [None])[0]
-            if nor is None:
-                nor = l.normal
-            normals.append(nor.to_tuple())
-
-        me.normals_split_custom_set(normals)
-
-        me.free_normals_split()
-        bpy.ops.object.mode_set(mode='EDIT')
-
-        return {'FINISHED'}
-
-
 classes = (
-    MehsSetNormalsFromFaces,
     MeshMirrorUV,
     MeshSelectNext,
     MeshSelectPrev,

release/scripts/startup/bl_ui/properties_data_modifier.py

@@ -1549,6 +1549,22 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         if md.rest_source == 'BIND':
             layout.operator("object.correctivesmooth_bind", text="Unbind" if is_bind else "Bind")
 
+    def WEIGHTED_NORMAL(self, layout, ob, md):
+        layout.label("Weighting Mode:")
+        split = layout.split(align=True)
+        col = split.column(align=True)
+        col.prop(md, "mode", text="")
+        col.prop(md, "weight", text="Weight")
+        col.prop(md, "keep_sharp")
+
+        col = split.column(align=True)
+        row = col.row(align=True)
+        row.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
+        row.active = bool(md.vertex_group)
+        row.prop(md, "invert_vertex_group", text="", icon='ARROW_LEFTRIGHT')
+        col.prop(md, "thresh", text="Threshold")
+        col.prop(md, "face_influence")
+
 
 classes = (
     DATA_PT_modifiers,

release/scripts/startup/bl_ui/space_view3d_toolbar.py

@@ -441,11 +441,59 @@ class VIEW3D_PT_tools_shading(View3DPanel, Panel):
         props.clear = True
         row.operator("mesh.mark_sharp", text="Sharp").use_verts = True
 
+
+class VIEW3D_PT_tools_normal(View3DPanel, Panel):
+    bl_category = "Shading / UVs"
+    bl_context = "mesh_edit"
+    bl_label = "Normal Tools"
+
+    def draw(self, context):
+        layout = self.layout
+        toolsettings = context.tool_settings
+
         col = layout.column(align=True)
-        col.label(text="Normals:")
+        col.label(text="Vertex Normals:")
         col.operator("mesh.normals_make_consistent", text="Recalculate")
         col.operator("mesh.flip_normals", text="Flip Direction")
+
+        layout.separator()
+        layout.label(text="Custom Normals:")
+
+        col = layout.column(align=True)
         col.operator("mesh.set_normals_from_faces", text="Set From Faces")
+        col.operator("transform.rotate_normal", text="Rotate")
+        col.operator("mesh.point_normals", text="Point To...")
+
+        row = layout.row(align=True)
+        row.operator("mesh.merge_normals", text="Merge")
+        row.operator("mesh.split_normals", text="Split")
+
+        col = layout.column(align=True)
+        col.operator_menu_enum("mesh.average_normals", "average_type")
+
+        col = layout.column(align=True)
+        col.label(text="Normal Vector:")
+        col.prop(toolsettings, "normal_vector", text="")
+
+        row = col.row(align=True)
+        row.operator("mesh.normals_tools", text="Copy").mode = 'COPY'
+        row.operator("mesh.normals_tools", text="Paste").mode = 'PASTE'
+
+        row = col.row(align=True)
+        row.operator("mesh.normals_tools", text="Multiply").mode = 'MULTIPLY'
+        row.operator("mesh.normals_tools", text="Add").mode = 'ADD'
+
+        col.operator("mesh.normals_tools", text="Reset").mode = 'RESET'
+
+        col = layout.column(align=True)
+        col.operator("mesh.smoothen_normals", text="Smoothen")
+
+        col = layout.column(align=True)
+        col.label(text="Face Strength:")
+        row = col.row(align=True)
+        row.prop(toolsettings, "face_strength", text="")
+        row.operator("mesh.mod_weighted_strength", text="", icon = "FACESEL").set = False
+        row.operator("mesh.mod_weighted_strength", text="", icon = "ZOOMIN").set = True
 
 
 class VIEW3D_PT_tools_uvs(View3DPanel, Panel):
@@ -2073,6 +2121,7 @@ classes = (
     VIEW3D_PT_tools_meshweight,
     VIEW3D_PT_tools_add_mesh_edit,
     VIEW3D_PT_tools_shading,
+	VIEW3D_PT_tools_normal,
     VIEW3D_PT_tools_uvs,
     VIEW3D_PT_tools_meshedit_options,
     VIEW3D_PT_tools_transform_curve,

source/blender/blenkernel/BKE_editmesh.h

@@ -93,6 +93,7 @@ void        BKE_editmesh_update_linked_customdata(BMEditMesh *em);
 void        BKE_editmesh_color_free(BMEditMesh *em);
 void        BKE_editmesh_color_ensure(BMEditMesh *em, const char htype);
 float     (*BKE_editmesh_vertexCos_get_orco(BMEditMesh *em, int *r_numVerts))[3];
+void		BKE_editmesh_lnorspace_update(BMEditMesh *em);
 
 /* editderivedmesh.c */
 /* should really be defined in editmesh.c, but they use 'EditDerivedBMesh' */

source/blender/blenkernel/BKE_mesh.h

@@ -222,6 +222,8 @@ typedef struct MLoopNorSpace {
 	 *     - BMLoop pointers. */
 	struct LinkNode *loops;
 	char flags;
+
+	void *user_data;  /* To be used for extended processing related to loop normal spaces (aka smooth fans). */
 } MLoopNorSpace;
 /**
  * MLoopNorSpace.flags
@@ -237,6 +239,7 @@ typedef struct MLoopNorSpaceArray {
 	MLoopNorSpace **lspacearr;    /* MLoop aligned array */
 	struct LinkNode *loops_pool;  /* Allocated once, avoids to call BLI_linklist_prepend_arena() for each loop! */
 	char data_type;               /* Whether we store loop indices, or pointers to BMLoop. */
+	int num_spaces;               /* Number of clnors spaces defined in this array. */
 	struct MemArena *mem;
 } MLoopNorSpaceArray;
 /**

source/blender/blenkernel/intern/editderivedmesh.c

@@ -214,7 +214,7 @@ static void emDM_calcLoopNormalsSpaceArray(
 	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);
+	                          r_lnors_spacearr, clnors_data, cd_loop_clnors_offset, false);
 #ifdef DEBUG_CLNORS
 	if (r_lnors_spacearr) {
 		int i;

source/blender/blenkernel/intern/editmesh.c

@@ -264,3 +264,26 @@ float (*BKE_editmesh_vertexCos_get_orco(BMEditMesh *em, int *r_numVerts))[3]
 
 	return orco;
 }
+
+void BKE_editmesh_lnorspace_update(BMEditMesh *em)
+{
+	BMesh *bm = em->bm;
+
+	/* We need to create clnors data is none exist yet, otherwise there is no way to edit them. */
+	/* Similar code to MESH_OT_customdata_custom_splitnormals_add operator, we want to keep same shading
+	 * in case we were using autosmooth so far... */
+	/* Note: there is a problem here, which is that is someone starts a normal editing operation on previously
+	 * autosmooth-ed mesh, and cancel that operation, generated clnors data remain, with related sharp edges
+	 * (and hence autosmooth is 'lost').
+	 * Not sure how critical this is, and how to fix that issue? */
+	if (!CustomData_has_layer(&bm->ldata, CD_CUSTOMLOOPNORMAL)) {
+		Mesh *me = em->ob->data;
+		if (me->flag & ME_AUTOSMOOTH) {
+			BM_edges_sharp_from_angle_set(bm, me->smoothresh);
+
+			me->drawflag |= ME_DRAWSHARP;
+		}
+	}
+
+	BM_lnorspace_update(bm);
+}

source/blender/blenkernel/intern/mesh_evaluate.c

@@ -455,6 +455,8 @@ void BKE_lnor_spacearr_init(MLoopNorSpaceArray *lnors_spacearr, const int numLoo
 		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);
+
+		lnors_spacearr->num_spaces = 0;
 	}
 	BLI_assert(ELEM(data_type, MLNOR_SPACEARR_BMLOOP_PTR, MLNOR_SPACEARR_LOOP_INDEX));
 	lnors_spacearr->data_type = data_type;
@@ -462,21 +464,24 @@ void BKE_lnor_spacearr_init(MLoopNorSpaceArray *lnors_spacearr, const int numLoo
 
 void BKE_lnor_spacearr_clear(MLoopNorSpaceArray *lnors_spacearr)
 {
-	BLI_memarena_clear(lnors_spacearr->mem);
+	lnors_spacearr->num_spaces = 0;
 	lnors_spacearr->lspacearr = NULL;
 	lnors_spacearr->loops_pool = NULL;
+	BLI_memarena_clear(lnors_spacearr->mem);
 }
 
 void BKE_lnor_spacearr_free(MLoopNorSpaceArray *lnors_spacearr)
 {
-	BLI_memarena_free(lnors_spacearr->mem);
+	lnors_spacearr->num_spaces = 0;
 	lnors_spacearr->lspacearr = NULL;
 	lnors_spacearr->loops_pool = NULL;
+	BLI_memarena_free(lnors_spacearr->mem);
 	lnors_spacearr->mem = NULL;
 }
 
 MLoopNorSpace *BKE_lnor_space_create(MLoopNorSpaceArray *lnors_spacearr)
 {
+	lnors_spacearr->num_spaces++;
 	return BLI_memarena_calloc(lnors_spacearr->mem, sizeof(MLoopNorSpace));
 }
 

source/blender/bmesh/bmesh_class.h

@@ -38,6 +38,8 @@ struct BMEdge;
 struct BMLoop;
 struct BMFace;
 
+struct MLoopNorSpaceArray;
+
 struct BLI_mempool;
 
 /* note: it is very important for BMHeader to start with two
@@ -236,6 +238,9 @@ typedef struct BMesh {
 	struct BLI_mempool *looplistpool;
 #endif
 
+	struct MLoopNorSpaceArray *lnor_spacearr;  /* Stores MLoopNorSpaceArray for this BMesh */
+	char spacearr_dirty;
+
 	/* should be copy of scene select mode */
 	/* stored in BMEditMesh too, this is a bit confusing,
 	 * make sure they're in sync!
@@ -263,9 +268,33 @@ enum {
 	BM_FACE = 8
 };
 
+typedef struct BMLoopNorEditData {
+	int loop_index;
+	BMLoop *loop;
+	float niloc[3];
+	float nloc[3];
+	float *loc;
+	short *clnors_data;
+} BMLoopNorEditData;
+
+typedef struct BMLoopNorEditDataArray {
+	BMLoopNorEditData *lnor_editdata;
+	/* This one has full amount of loops, used to map loop index to actual BMLoopNorEditData struct. */
+	BMLoopNorEditData **lidx_to_lnor_editdata;
+
+	int cd_custom_normal_offset;
+	int totloop;
+} BMLoopNorEditDataArray;
+
 #define BM_ALL (BM_VERT | BM_EDGE | BM_LOOP | BM_FACE)
 #define BM_ALL_NOLOOP (BM_VERT | BM_EDGE | BM_FACE)
 
+enum {
+	BM_SPACEARR_DIRTY = 1 << 0,
+	BM_SPACEARR_DIRTY_ALL = 1 << 1,
+	BM_SPACEARR_BMO_SET = 1 << 2,
+};
+
 /* args for _Generic */
 #define _BM_GENERIC_TYPE_ELEM_NONCONST \
 	void *, BMVert *, BMEdge *, BMLoop *, BMFace *, \

source/blender/bmesh/intern/bmesh_mesh.c

@@ -30,6 +30,7 @@
 
 #include "DNA_listBase.h"
 #include "DNA_object_types.h"
+#include "DNA_scene_types.h"
 
 #include "BLI_linklist_stack.h"
 #include "BLI_listbase.h"
@@ -260,6 +261,11 @@ void BM_mesh_data_free(BMesh *bm)
 
 	BLI_freelistN(&bm->selected);
 
+	if (bm->lnor_spacearr) {
+		BKE_lnor_spacearr_free(bm->lnor_spacearr);
+		MEM_freeN(bm->lnor_spacearr);
+	}
+
 	BMO_error_clear(bm);
 }
 
@@ -313,6 +319,10 @@ void BM_mesh_free(BMesh *bm)
  * Helpers for #BM_mesh_normals_update and #BM_verts_calc_normal_vcos
  */
 
+/* We use that existing internal API flag, assuming no other tool using it would run concurrently to clnors editing. */
+/* XXX Should we rather add a new internal flag? */
+#define BM_LNORSPACE_UPDATE _FLAG_MF
+
 typedef struct BMEdgesCalcVectorsData {
 	/* Read-only data. */
 	const float (*vcos)[3];
@@ -638,7 +648,8 @@ bool BM_loop_check_cyclic_smooth_fan(BMLoop *l_curr)
  * 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)
+        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2],
+        const int cd_loop_clnors_offset, const bool do_rebuild)
 {
 	BMIter fiter;
 	BMFace *f_curr;
@@ -694,6 +705,11 @@ static void bm_mesh_loops_calc_normals(
 
 		l_curr = l_first = BM_FACE_FIRST_LOOP(f_curr);
 		do {
+			if (do_rebuild && !BM_ELEM_API_FLAG_TEST(l_curr, BM_LNORSPACE_UPDATE) &&
+			    !(bm->spacearr_dirty & BM_SPACEARR_DIRTY_ALL))
+			{
+				continue;
+			}
 			/* A smooth edge, we have to check for cyclic smooth fan case.
 			 * If we find a new, never-processed cyclic smooth fan, we can do it now using that loop/edge as
 			 * 'entry point', otherwise we can skip it. */
@@ -894,7 +910,10 @@ static void bm_mesh_loops_calc_normals(
 								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");
+
+								/* Prints continuously when merge custom normals, so commenting. */
+								/* printf("Invalid clnors in this fan!\n"); */
+
 								while ((clnor = BLI_SMALLSTACK_POP(clnors))) {
 									//print_v2("org clnor", clnor);
 									clnor[0] = (short)clnors_avg[0];
@@ -1009,7 +1028,8 @@ void BM_mesh_loop_normals_update(
 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)
+        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2],
+        const int cd_loop_clnors_offset, const bool do_rebuild)
 {
 	const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
 
@@ -1019,7 +1039,8 @@ void BM_loops_calc_normal_vcos(
 		bm_mesh_edges_sharp_tag(bm, vnos, fnos, r_lnos, has_clnors ? (float)M_PI : split_angle, false);
 
 		/* 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, r_lnors_spacearr, clnors_data, cd_loop_clnors_offset);
+		bm_mesh_loops_calc_normals(
+		            bm, vcos, fnos, r_lnos, r_lnors_spacearr, clnors_data, cd_loop_clnors_offset, do_rebuild);
 	}
 	else {
 		BLI_assert(!r_lnors_spacearr);
@@ -1041,6 +1062,380 @@ void BM_edges_sharp_from_angle_set(BMesh *bm, const float split_angle)
 	bm_mesh_edges_sharp_tag(bm, NULL, NULL, NULL, split_angle, true);
 }
 
+void BM_lnorspacearr_store(BMesh *bm, float (*r_lnors)[3])
+{
+	BLI_assert(bm->lnor_spacearr != NULL);
+
+	if (!CustomData_has_layer(&bm->ldata, CD_CUSTOMLOOPNORMAL)) {
+		BM_data_layer_add(bm, &bm->ldata, CD_CUSTOMLOOPNORMAL);
+	}
+
+	int cd_loop_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
+
+	BM_loops_calc_normal_vcos(
+	            bm, NULL, NULL, NULL, true, M_PI, r_lnors, bm->lnor_spacearr, NULL, cd_loop_clnors_offset, false);
+	bm->spacearr_dirty &= ~(BM_SPACEARR_DIRTY | BM_SPACEARR_DIRTY_ALL);
+}
+
+/* will change later */
+#define CLEAR_SPACEARRAY_THRESHOLD(x) ((x) / 2)
+
+void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all)
+{
+	if (bm->spacearr_dirty & BM_SPACEARR_DIRTY_ALL) {
+		return;
+	}
+	if (do_invalidate_all || bm->totvertsel > CLEAR_SPACEARRAY_THRESHOLD(bm->totvert)) {
+		bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL;
+		return;
+	}
+	if (bm->lnor_spacearr == NULL) {
+		bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL;
+		return;
+	}
+
+	BMVert *v;
+	BMLoop *l;
+	BMIter viter, liter;
+	/* Note: we could use temp tag of BMItem for that, but probably better not use it in such a low-level func?
+	 * --mont29 */
+	BLI_bitmap *done_verts = BLI_BITMAP_NEW(bm->totvert, __func__);
+
+	BM_mesh_elem_index_ensure(bm, BM_VERT);
+
+	/* When we affect a given vertex, we may affect following smooth fans:
+	 *     - all smooth fans of said vertex;
+	 *     - all smooth fans of all immediate loop-neighbors vertices;
+	 * This can be simplified as 'all loops of selected vertices and their immediate neighbors'
+	 * need to be tagged for update.
+	 */
+	BM_ITER_MESH(v, &viter, bm, BM_VERTS_OF_MESH) {
+		if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
+			BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
+				BM_ELEM_API_FLAG_ENABLE(l, BM_LNORSPACE_UPDATE);
+
+				/* Note that we only handle unselected neighbor vertices here, main loop will take care of
+				 * selected ones. */
+				if (!BM_elem_flag_test(l->prev->v, BM_ELEM_SELECT) &&
+				    !BLI_BITMAP_TEST(done_verts, BM_elem_index_get(l->prev->v)))
+				{
+					BMLoop *l_prev;
+					BMIter liter_prev;
+					BM_ITER_ELEM(l_prev, &liter_prev, l->prev->v, BM_LOOPS_OF_VERT) {
+						BM_ELEM_API_FLAG_ENABLE(l_prev, BM_LNORSPACE_UPDATE);
+					}
+					BLI_BITMAP_ENABLE(done_verts, BM_elem_index_get(l_prev->v));
+				}
+
+				if (!BM_elem_flag_test(l->next->v, BM_ELEM_SELECT) &&
+				    !BLI_BITMAP_TEST(done_verts, BM_elem_index_get(l->next->v)))
+				{
+					BMLoop *l_next;
+					BMIter liter_next;
+					BM_ITER_ELEM(l_next, &liter_next, l->next->v, BM_LOOPS_OF_VERT) {
+						BM_ELEM_API_FLAG_ENABLE(l_next, BM_LNORSPACE_UPDATE);
+					}
+					BLI_BITMAP_ENABLE(done_verts, BM_elem_index_get(l_next->v));
+				}
+			}
+
+			BLI_BITMAP_ENABLE(done_verts, BM_elem_index_get(v));
+		}
+	}
+
+	MEM_freeN(done_verts);
+	bm->spacearr_dirty |= BM_SPACEARR_DIRTY;
+}
+
+void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
+{
+	BLI_assert(bm->lnor_spacearr != NULL);
+
+	if (!(bm->spacearr_dirty & (BM_SPACEARR_DIRTY | BM_SPACEARR_DIRTY_ALL))) {
+		return;
+	}
+	BMFace *f;
+	BMLoop *l;
+	BMIter fiter, liter;
+
+	float (*r_lnors)[3] = MEM_callocN(sizeof(*r_lnors) * bm->totloop, __func__);
+	float (*oldnors)[3] = preserve_clnor ? MEM_mallocN(sizeof(*oldnors) * bm->totloop, __func__) : NULL;
+
+	int cd_loop_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
+
+	BM_mesh_elem_index_ensure(bm, BM_LOOP);
+
+	if (preserve_clnor) {
+		BLI_assert(bm->lnor_spacearr->lspacearr != NULL);
+
+		BM_ITER_MESH(f, &fiter, bm, BM_FACES_OF_MESH) {
+			BM_ITER_ELEM(l, &liter, f, BM_LOOPS_OF_FACE) {
+				if (BM_ELEM_API_FLAG_TEST(l, BM_LNORSPACE_UPDATE) || bm->spacearr_dirty & BM_SPACEARR_DIRTY_ALL) {
+					short(*clnor)[2] = BM_ELEM_CD_GET_VOID_P(l, cd_loop_clnors_offset);
+					int l_index = BM_elem_index_get(l);
+
+					BKE_lnor_space_custom_data_to_normal(bm->lnor_spacearr->lspacearr[l_index], *clnor, oldnors[l_index]);
+				}
+			}
+		}
+	}
+
+	if (bm->spacearr_dirty & BM_SPACEARR_DIRTY_ALL) {
+		BKE_lnor_spacearr_clear(bm->lnor_spacearr);
+	}
+	BM_loops_calc_normal_vcos(
+	            bm, NULL, NULL, NULL, true, M_PI, r_lnors, bm->lnor_spacearr, NULL, cd_loop_clnors_offset, true);
+	MEM_freeN(r_lnors);
+
+	BM_ITER_MESH(f, &fiter, bm, BM_FACES_OF_MESH) {
+		BM_ITER_ELEM(l, &liter, f, BM_LOOPS_OF_FACE) {
+			if (BM_ELEM_API_FLAG_TEST(l, BM_LNORSPACE_UPDATE) || bm->spacearr_dirty & BM_SPACEARR_DIRTY_ALL) {
+				if (preserve_clnor) {
+					short(*clnor)[2] = BM_ELEM_CD_GET_VOID_P(l, cd_loop_clnors_offset);
+					int l_index = BM_elem_index_get(l);
+					BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], oldnors[l_index], *clnor);
+				}
+				BM_ELEM_API_FLAG_DISABLE(l, BM_LNORSPACE_UPDATE);
+			}
+		}
+	}
+
+	MEM_SAFE_FREE(oldnors);
+	bm->spacearr_dirty &= ~(BM_SPACEARR_DIRTY | BM_SPACEARR_DIRTY_ALL);
+
+#ifndef NDEBUG
+	BM_lnorspace_err(bm);
+#endif
+}
+
+void BM_lnorspace_update(BMesh *bm)
+{
+	if (bm->lnor_spacearr == NULL) {
+		bm->lnor_spacearr = MEM_callocN(sizeof(*bm->lnor_spacearr), __func__);
+	}
+	if (bm->lnor_spacearr->lspacearr == NULL) {
+		float (*lnors)[3] = MEM_callocN(sizeof(*lnors) * bm->totloop, __func__);
+
+		BM_lnorspacearr_store(bm, lnors);
+
+		MEM_freeN(lnors);
+	}
+	else if(bm->spacearr_dirty & (BM_SPACEARR_DIRTY | BM_SPACEARR_DIRTY_ALL)){
+		BM_lnorspace_rebuild(bm, false);
+	}
+}
+
+/**
+ * Auxillary function only used by rebuild to detect if any spaces were not marked as invalid.
+ * Reports error if any of the lnor spaces change after rebuilding, meaning that all the possible
+ * lnor spaces to be rebuilt were not correctly marked.
+ */
+#ifndef NDEBUG
+void BM_lnorspace_err(BMesh *bm)
+{
+	bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL;
+	bool clear = true;
+
+	MLoopNorSpaceArray *temp = MEM_callocN(sizeof(*temp), __func__);
+	temp->lspacearr = NULL;
+
+	BKE_lnor_spacearr_init(temp, bm->totloop, MLNOR_SPACEARR_BMLOOP_PTR);
+	
+	int cd_loop_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
+	float (*lnors)[3] = MEM_callocN(sizeof(*lnors) * bm->totloop, __func__);
+	BM_loops_calc_normal_vcos(bm, NULL, NULL, NULL, true, M_PI, lnors, temp, NULL, cd_loop_clnors_offset, true);
+
+	for (int i = 0; i < bm->totloop; i++) {
+		int j = 0;
+		j += compare_ff(temp->lspacearr[i]->ref_alpha, bm->lnor_spacearr->lspacearr[i]->ref_alpha, 1e-4f);
+		j += compare_ff(temp->lspacearr[i]->ref_beta, bm->lnor_spacearr->lspacearr[i]->ref_beta, 1e-4f);
+		j += compare_v3v3(temp->lspacearr[i]->vec_lnor, bm->lnor_spacearr->lspacearr[i]->vec_lnor, 1e-4f);
+		j += compare_v3v3(temp->lspacearr[i]->vec_ortho, bm->lnor_spacearr->lspacearr[i]->vec_ortho, 1e-4f);
+		j += compare_v3v3(temp->lspacearr[i]->vec_ref, bm->lnor_spacearr->lspacearr[i]->vec_ref, 1e-4f);
+
+		if (j != 5) {
+			clear = false;
+			break;
+		}
+	}
+	BKE_lnor_spacearr_free(temp);
+	MEM_freeN(temp);
+	MEM_freeN(lnors);
+	BLI_assert(clear);
+
+	bm->spacearr_dirty &= ~BM_SPACEARR_DIRTY_ALL;
+}
+#endif
+
+static void bm_loop_normal_mark_indiv_do_loop(
+        BMLoop *l, BLI_bitmap *loops, MLoopNorSpaceArray *lnor_spacearr, int *totloopsel)
+{
+	if (l != NULL) {
+		const int l_idx = BM_elem_index_get(l);
+
+		if (!BLI_BITMAP_TEST(loops, BM_elem_index_get(l))) {
+			/* If vert and face selected share a loop, mark it for editing. */
+			BLI_BITMAP_ENABLE(loops, l_idx);
+			(*totloopsel)++;
+
+			/* Mark all loops in same loop normal space (aka smooth fan). */
+			if ((lnor_spacearr->lspacearr[l_idx]->flags & MLNOR_SPACE_IS_SINGLE) == 0) {
+				for (LinkNode *node = lnor_spacearr->lspacearr[l_idx]->loops; node; node = node->next) {
+					const int lfan_idx = BM_elem_index_get((BMLoop *)node->link);
+					if (!BLI_BITMAP_TEST(loops, lfan_idx)) {
+						BLI_BITMAP_ENABLE(loops, lfan_idx);
+						(*totloopsel)++;
+					}
+				}
+			}
+		}
+	}
+}
+
+/* Mark the individual clnors to be edited, if multiple selection methods are used. */
+static int bm_loop_normal_mark_indiv(BMesh *bm, BLI_bitmap *loops)
+{
+	BMEditSelection *ese, *ese_prev;
+	int totloopsel = 0;
+
+	BM_mesh_elem_index_ensure(bm, BM_LOOP);
+
+	BLI_assert(bm->lnor_spacearr != NULL);
+	BLI_assert(bm->lnor_spacearr->data_type == MLNOR_SPACEARR_BMLOOP_PTR);
+
+	/* Goes from last selected to the first selected element. */
+	for (ese = bm->selected.last; ese; ese = ese->prev) {
+		if (ese->htype == BM_FACE) {
+			ese_prev = ese;
+			/* If current face is selected, then any verts to be edited must have been selected before it. */
+			while ((ese_prev = ese_prev->prev)) {
+				if (ese_prev->htype == BM_VERT) {
+					bm_loop_normal_mark_indiv_do_loop(
+					            BM_face_vert_share_loop((BMFace *)ese->ele, (BMVert *)ese_prev->ele),
+					            loops, bm->lnor_spacearr, &totloopsel);
+				}
+				else if (ese_prev->htype == BM_EDGE) {
+					bm_loop_normal_mark_indiv_do_loop(
+					            BM_face_vert_share_loop((BMFace *)ese->ele, ((BMEdge *)ese_prev->ele)->v1),
+					            loops, bm->lnor_spacearr, &totloopsel);
+
+					bm_loop_normal_mark_indiv_do_loop(
+					            BM_face_vert_share_loop((BMFace *)ese->ele, ((BMEdge *)ese_prev->ele)->v2),
+					            loops, bm->lnor_spacearr, &totloopsel);
+				}
+			}
+		}
+	}
+
+	return totloopsel;
+}
+
+static void loop_normal_editdata_init(BMesh *bm, BMLoopNorEditData *lnor_ed, BMVert *v, BMLoop *l, const int offset)
+{
+	BLI_assert(bm->lnor_spacearr != NULL);
+	BLI_assert(bm->lnor_spacearr->lspacearr != NULL);
+
+	const int l_index = BM_elem_index_get(l);
+	short *clnors_data = BM_ELEM_CD_GET_VOID_P(l, offset);
+
+	lnor_ed->loop_index = l_index;
+	lnor_ed->loop = l;
+
+	float custom_normal[3];
+	BKE_lnor_space_custom_data_to_normal(bm->lnor_spacearr->lspacearr[l_index], clnors_data, custom_normal);
+
+	lnor_ed->clnors_data = clnors_data;
+	copy_v3_v3(lnor_ed->nloc, custom_normal);
+	copy_v3_v3(lnor_ed->niloc, custom_normal);
+
+	lnor_ed->loc = v->co;
+}
+
+BMLoopNorEditDataArray *BM_loop_normal_editdata_array_init(BMesh *bm)
+{
+	BMLoop *l;
+	BMVert *v;
+	BMIter liter, viter;
+
+	bool verts = (bm->selectmode & SCE_SELECT_VERTEX) != 0;
+	bool edges = (bm->selectmode & SCE_SELECT_EDGE) != 0;
+	bool faces = (bm->selectmode & SCE_SELECT_FACE) != 0;
+	int totloopsel = 0;
+
+	BLI_assert(bm->spacearr_dirty == 0);
+
+	BMLoopNorEditDataArray *lnors_ed_arr = MEM_mallocN(sizeof(*lnors_ed_arr), __func__);
+	lnors_ed_arr->lidx_to_lnor_editdata = MEM_callocN(sizeof(*lnors_ed_arr->lidx_to_lnor_editdata) * bm->totloop, __func__);
+
+	if (!CustomData_has_layer(&bm->ldata, CD_CUSTOMLOOPNORMAL)) {
+		BM_data_layer_add(bm, &bm->ldata, CD_CUSTOMLOOPNORMAL);
+	}
+	const int cd_custom_normal_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
+
+	BM_mesh_elem_index_ensure(bm, BM_LOOP);
+
+	BLI_bitmap *loops = BLI_BITMAP_NEW(bm->totloop, __func__);
+	if (faces && (verts || edges)) {
+		/* More than one selection mode, check for individual normals to edit. */
+		totloopsel = bm_loop_normal_mark_indiv(bm, loops);
+	}
+
+	if (totloopsel) {
+		BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata = MEM_mallocN(sizeof(*lnor_ed) * totloopsel, __func__);
+
+		BM_ITER_MESH(v, &viter, bm, BM_VERTS_OF_MESH) {
+			BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
+				if (BLI_BITMAP_TEST(loops, BM_elem_index_get(l))) {
+					loop_normal_editdata_init(bm, lnor_ed, v, l, cd_custom_normal_offset);
+					lnors_ed_arr->lidx_to_lnor_editdata[BM_elem_index_get(l)] = lnor_ed;
+					lnor_ed++;
+				}
+			}
+		}
+		lnors_ed_arr->totloop = totloopsel;
+	}
+	else {  /* If multiple selection modes are inactive OR no such loop is found, fall back to editing all loops. */
+		totloopsel = BM_total_loop_select(bm);
+		BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata = MEM_mallocN(sizeof(*lnor_ed) * totloopsel, __func__);
+
+		BM_ITER_MESH(v, &viter, bm, BM_VERTS_OF_MESH) {
+			if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
+				BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
+					loop_normal_editdata_init(bm, lnor_ed, v, l, cd_custom_normal_offset);
+					lnors_ed_arr->lidx_to_lnor_editdata[BM_elem_index_get(l)] = lnor_ed;
+					lnor_ed++;
+				}
+			}
+		}
+		lnors_ed_arr->totloop = totloopsel;
+	}
+
+	MEM_freeN(loops);
+	lnors_ed_arr->cd_custom_normal_offset = cd_custom_normal_offset;
+	return lnors_ed_arr;
+}
+
+void BM_loop_normal_editdata_array_free(BMLoopNorEditDataArray *lnors_ed_arr)
+{
+	MEM_SAFE_FREE(lnors_ed_arr->lnor_editdata);
+	MEM_SAFE_FREE(lnors_ed_arr->lidx_to_lnor_editdata);
+	MEM_freeN(lnors_ed_arr);
+}
+
+int BM_total_loop_select(BMesh *bm)
+{
+	int r_sel = 0;
+	BMVert *v;
+	BMIter viter;
+
+	BM_ITER_MESH(v, &viter, bm, BM_VERTS_OF_MESH) {
+		if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
+			r_sel += BM_vert_face_count(v);
+		}
+	}
+	return r_sel;
+}
+
 static void UNUSED_FUNCTION(bm_mdisps_space_set)(Object *ob, BMesh *bm, int from, int to)
 {
 	/* switch multires data out of tangent space */
@@ -1141,6 +1536,7 @@ void bmesh_edit_end(BMesh *bm, BMOpTypeFlag type_flag)
 
 	/* compute normals, clear temp flags and flush selections */
 	if (type_flag & BMO_OPTYPE_FLAG_NORMALS_CALC) {
+		bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL;
 		BM_mesh_normals_update(bm);
 	}
 
@@ -1157,6 +1553,9 @@ void bmesh_edit_end(BMesh *bm, BMOpTypeFlag type_flag)
 	if ((type_flag & BMO_OPTYPE_FLAG_SELECT_VALIDATE) == 0) {
 		bm->selected = select_history;
 	}
+	if (type_flag & BMO_OPTYPE_FLAG_INVALIDATE_CLNOR_ALL) {
+		bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL;
+	}
 }
 
 void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)

source/blender/bmesh/intern/bmesh_mesh.h

@@ -29,6 +29,7 @@
 
 struct BMAllocTemplate;
 struct MLoopNorSpaceArray;
+struct BMLoopNorEditDataArray;
 
 void   BM_mesh_elem_toolflags_ensure(BMesh *bm);
 void   BM_mesh_elem_toolflags_clear(BMesh *bm);
@@ -50,9 +51,22 @@ void BM_verts_calc_normal_vcos(BMesh *bm, const float (*fnos)[3], const float (*
 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);
+        struct MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2],
+        const int cd_loop_clnors_offset, const bool do_rebuild);
 
 bool BM_loop_check_cyclic_smooth_fan(BMLoop *l_curr);
+void BM_lnorspacearr_store(BMesh *bm, float (*r_lnors)[3]);
+void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all);
+void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor);
+void BM_lnorspace_update(BMesh *bm);
+#ifndef NDEBUG
+void BM_lnorspace_err(BMesh *bm);
+#endif
+
+/* Loop Generics */
+struct BMLoopNorEditDataArray *BM_loop_normal_editdata_array_init(BMesh *bm);
+void BM_loop_normal_editdata_array_free(struct BMLoopNorEditDataArray *lnors_ed_arr);
+int BM_total_loop_select(BMesh *bm);
 
 
 void BM_edges_sharp_from_angle_set(BMesh *bm, const float split_angle);

source/blender/bmesh/intern/bmesh_operator_api.h

@@ -244,6 +244,7 @@ typedef enum {
 	BMO_OPTYPE_FLAG_NORMALS_CALC        = (1 << 1),
 	BMO_OPTYPE_FLAG_SELECT_FLUSH        = (1 << 2),
 	BMO_OPTYPE_FLAG_SELECT_VALIDATE     = (1 << 3),
+	BMO_OPTYPE_FLAG_INVALIDATE_CLNOR_ALL = (1 << 4),
 } BMOpTypeFlag;
 
 typedef struct BMOperator {

source/blender/editors/include/ED_screen.h

@@ -171,6 +171,7 @@ int     ED_operator_object_active_editable_font(struct bContext *C);
 int     ED_operator_editmesh(struct bContext *C);
 int     ED_operator_editmesh_view3d(struct bContext *C);
 int     ED_operator_editmesh_region_view3d(struct bContext *C);
+int     ED_operator_editmesh_auto_smooth(struct bContext *C);
 int     ED_operator_editarmature(struct bContext *C);
 int     ED_operator_editcurve(struct bContext *C);
 int     ED_operator_editcurve_3d(struct bContext *C);

source/blender/editors/include/ED_transform.h

@@ -88,6 +88,7 @@ enum TfmMode {
 	TFM_VERT_SLIDE,
 	TFM_SEQ_SLIDE,
 	TFM_BONE_ENVELOPE_DIST,
+	TFM_NORMAL_ROTATION,
 };
 
 /* TRANSFORM CONTEXTS */
@@ -150,6 +151,7 @@ int BIF_countTransformOrientation(const struct bContext *C);
 #define P_NO_TEXSPACE   (1 << 11)
 #define P_CENTER        (1 << 12)
 #define P_GPENCIL_EDIT  (1 << 13)
+#define P_CLNOR_INVALIDATE (1 << 14)
 
 void Transform_Properties(struct wmOperatorType *ot, int flags);
 

source/blender/editors/mesh/editmesh_undo.c

@@ -589,6 +589,8 @@ static void undomesh_to_editmesh(UndoMesh *um, BMEditMesh *em, Mesh *obmesh)
 	bm->selectmode = um->selectmode;
 	em->ob = ob;
 
+	bm->spacearr_dirty = BM_SPACEARR_DIRTY_ALL;
+
 	/* T35170: Restore the active key on the RealMesh. Otherwise 'fake' offset propagation happens
 	 *         if the active is a basis for any other. */
 	if (key && (key->type == KEY_RELATIVE)) {

source/blender/editors/mesh/editmesh_utils.c

@@ -1349,7 +1349,10 @@ void EDBM_update_generic(BMEditMesh *em, const bool do_tessface, const bool is_d
 		/* in debug mode double check we didn't need to recalculate */
 		BLI_assert(BM_mesh_elem_table_check(em->bm) == true);
 	}
-
+	if (em->bm->spacearr_dirty & BM_SPACEARR_BMO_SET) {
+		BM_lnorspace_invalidate(em->bm, false);
+		em->bm->spacearr_dirty &= ~BM_SPACEARR_BMO_SET;
+	}
 	/* don't keep stale derivedMesh data around, see: [#38872] */
 	BKE_editmesh_free_derivedmesh(em);
 

source/blender/editors/mesh/mesh_intern.h

@@ -229,6 +229,16 @@ void MESH_OT_duplicate(struct wmOperatorType *ot);
 void MESH_OT_merge(struct wmOperatorType *ot);
 void MESH_OT_remove_doubles(struct wmOperatorType *ot);
 void MESH_OT_poke(struct wmOperatorType *ot);
+void MESH_OT_point_normals(struct wmOperatorType *ot);
+void MESH_OT_merge_normals(struct wmOperatorType *ot);
+void MESH_OT_split_normals(struct wmOperatorType *ot);
+void MESH_OT_normals_tools(struct wmOperatorType *ot);
+void MESH_OT_set_normals_from_faces(struct wmOperatorType *ot);
+void MESH_OT_average_normals(struct wmOperatorType *ot);
+void MESH_OT_smoothen_normals(struct wmOperatorType *ot);
+void MESH_OT_mod_weighted_strength(struct wmOperatorType *ot);
+
+struct wmKeyMap *point_normals_modal_keymap(wmKeyConfig *keyconf);
 
 #ifdef WITH_FREESTYLE
 void MESH_OT_mark_freestyle_edge(struct wmOperatorType *ot);

source/blender/editors/mesh/mesh_ops.c

@@ -192,6 +192,15 @@ void ED_operatortypes_mesh(void)
 	WM_operatortype_append(MESH_OT_symmetrize);
 	WM_operatortype_append(MESH_OT_symmetry_snap);
 
+	WM_operatortype_append(MESH_OT_point_normals);
+	WM_operatortype_append(MESH_OT_merge_normals);
+	WM_operatortype_append(MESH_OT_split_normals);
+	WM_operatortype_append(MESH_OT_normals_tools);
+	WM_operatortype_append(MESH_OT_set_normals_from_faces);
+	WM_operatortype_append(MESH_OT_average_normals);
+	WM_operatortype_append(MESH_OT_smoothen_normals);
+	WM_operatortype_append(MESH_OT_mod_weighted_strength);
+
 #ifdef WITH_GAMEENGINE
 	WM_operatortype_append(MESH_OT_navmesh_make);
 	WM_operatortype_append(MESH_OT_navmesh_face_copy);
@@ -423,6 +432,8 @@ void ED_keymap_mesh(wmKeyConfig *keyconf)
 	WM_keymap_add_item(keymap, "MESH_OT_split", YKEY, KM_PRESS, 0, 0);
 	WM_keymap_add_item(keymap, "MESH_OT_vert_connect_path", JKEY, KM_PRESS, 0, 0);
 
+	WM_keymap_add_item(keymap, "MESH_OT_point_normals", LKEY, KM_PRESS, KM_ALT, 0);
+
 	/* Vertex Slide */
 	WM_keymap_add_item(keymap, "TRANSFORM_OT_vert_slide", VKEY, KM_PRESS, KM_SHIFT, 0);
 	/* use KM_CLICK because same key is used for tweaks */
@@ -466,5 +477,6 @@ void ED_keymap_mesh(wmKeyConfig *keyconf)
 	ED_keymap_proportional_editmode(keyconf, keymap, true);
 
 	knifetool_modal_keymap(keyconf);
+	point_normals_modal_keymap(keyconf);
 }
 

source/blender/editors/screen/screen_ops.c

@@ -46,6 +46,7 @@
 #include "DNA_gpencil_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_meta_types.h"
+#include "DNA_mesh_types.h"
 #include "DNA_mask_types.h"
 #include "DNA_node_types.h"
 #include "DNA_userdef_types.h"
@@ -353,6 +354,15 @@ int ED_operator_editmesh_region_view3d(bContext *C)
 	return 0;
 }
 
+int ED_operator_editmesh_auto_smooth(bContext *C)
+{
+	Object *obedit = CTX_data_edit_object(C);
+	if (obedit && obedit->type == OB_MESH && (((Mesh *)(obedit->data))->flag & ME_AUTOSMOOTH)) {
+		return NULL != BKE_editmesh_from_object(obedit);
+	}
+	return 0;
+}
+
 int ED_operator_editarmature(bContext *C)
 {
 	Object *obedit = CTX_data_edit_object(C);

source/blender/editors/space_outliner/outliner_draw.c

@@ -1181,6 +1181,7 @@ static void tselem_draw_icon(uiBlock *block, int xmax, float x, float y, TreeSto
 					case eModifierType_DataTransfer:
 						UI_icon_draw(x, y, ICON_MOD_DATA_TRANSFER); break;
 					case eModifierType_NormalEdit:
+					case eModifierType_WeightedNormal:
 						UI_icon_draw(x, y, ICON_MOD_NORMALEDIT); break;
 					/* Default */
 					case eModifierType_None:

source/blender/editors/transform/transform.c

@@ -41,6 +41,7 @@
 #include "DNA_armature_types.h"
 #include "DNA_constraint_types.h"
 #include "DNA_mask_types.h"
+#include "DNA_mesh_types.h"
 #include "DNA_movieclip_types.h"
 #include "DNA_scene_types.h"  /* PET modes */
 
@@ -62,6 +63,7 @@
 #include "BKE_particle.h"
 #include "BKE_unit.h"
 #include "BKE_mask.h"
+#include "BKE_mesh.h"
 #include "BKE_report.h"
 
 #include "BIF_gl.h"
@@ -86,6 +88,7 @@
 #include "UI_resources.h"
 
 #include "RNA_access.h"
+#include "RNA_define.h"
 
 #include "BLF_api.h"
 #include "BLT_translation.h"
@@ -106,6 +109,7 @@ static void postInputRotation(TransInfo *t, float values[3]);
 static void ElementRotation(TransInfo *t, TransData *td, float mat[3][3], const short around);
 static void initSnapSpatial(TransInfo *t, float r_snap[3]);
 
+static void storeCustomLNorValue(TransInfo *t, BMesh *bm);
 
 /* Transform Callbacks */
 static void initBend(TransInfo *t);
@@ -131,6 +135,9 @@ static void applyToSphere(TransInfo *t, const int mval[2]);
 static void initRotation(TransInfo *t);
 static void applyRotation(TransInfo *t, const int mval[2]);
 
+static void initNormalRotation(TransInfo *t);
+static void applyNormalRotation(TransInfo *t, const int mval[2]);
+
 static void initShrinkFatten(TransInfo *t);
 static void applyShrinkFatten(TransInfo *t, const int mval[2]);
 
@@ -1465,6 +1472,20 @@ int transformEvent(TransInfo *t, const wmEvent *event)
 					handled = true;
 				}
 				break;
+			case NKEY:
+				if (ELEM(t->mode, TFM_ROTATION)) {
+					if (t->obedit && t->obedit->type == OB_MESH) {
+						if (((Mesh *)(t->obedit->data))->flag & ME_AUTOSMOOTH) {
+							restoreTransObjects(t);
+							resetTransModal(t);
+							resetTransRestrictions(t);
+							initNormalRotation(t);
+							t->redraw = TREDRAW_HARD;
+							handled = true;
+						}
+					}
+				}
+				break;
 			default:
 				break;
 		}
@@ -2303,6 +2324,9 @@ bool initTransform(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
 		case TFM_SEQ_SLIDE:
 			initSeqSlide(t);
 			break;
+		case TFM_NORMAL_ROTATION:
+			initNormalRotation(t);
+			break;
 	}
 
 	if (t->state == TRANS_CANCEL) {
@@ -2359,6 +2383,34 @@ bool initTransform(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
 		t->flag |= T_AUTOVALUES;
 	}
 
+	if ((prop = RNA_struct_find_property(op->ptr, "preserve_clnor"))) {
+		if (t->obedit && t->obedit->type == OB_MESH && (((Mesh *)(t->obedit->data))->flag & ME_AUTOSMOOTH)) {
+			BMEditMesh *em = BKE_editmesh_from_object(t->obedit);
+			bool do_skip = false;
+
+			/* Currently only used for two of three most frequent transform ops, can include more ops.
+			 * Note that scaling cannot be included here, non-uniform scaling will affect normals. */
+			if (ELEM(t->mode, TFM_TRANSLATION, TFM_ROTATION)) {
+				if (em->bm->totvertsel == em->bm->totvert) {
+					/* No need to invalidate if whole mesh is selected. */
+					do_skip = true;
+				}
+			}
+
+			if (t->flag & T_MODAL) {
+				RNA_property_boolean_set(op->ptr, prop, false);
+			}
+			else if (!do_skip) {
+				const bool preserve_clnor = RNA_property_boolean_get(op->ptr, prop);
+				if (preserve_clnor) {
+					BKE_editmesh_lnorspace_update(em);
+					t->flag |= T_CLNOR_REBUILD;
+				}
+				BM_lnorspace_invalidate(em->bm, true);
+			}
+		}
+	}
+
 	t->context = NULL;
 
 	return 1;
@@ -2419,6 +2471,10 @@ int transformEnd(bContext *C, TransInfo *t)
 			restoreTransObjects(t); // calls recalcData()
 		}
 		else {
+			if (t->flag & T_CLNOR_REBUILD) {
+				BMEditMesh *em = BKE_editmesh_from_object(t->obedit);
+				BM_lnorspace_rebuild(em->bm, true);
+			}
 			exit_code = OPERATOR_FINISHED;
 		}
 
@@ -3714,6 +3770,28 @@ static void initRotation(TransInfo *t)
 	copy_v3_v3(t->axis_orig, t->axis);
 }
 
+/* Used by Transform Rotation and Transform Normal Rotation */
+static void headerRotation(TransInfo *t, char str[UI_MAX_DRAW_STR], float final)
+{
+	size_t ofs = 0;
+
+	if (hasNumInput(&t->num)) {
+		char c[NUM_STR_REP_LEN];
+
+		outputNumInput(&(t->num), c, &t->scene->unit);
+
+		ofs += BLI_snprintf(str + ofs, UI_MAX_DRAW_STR - ofs, IFACE_("Rot: %s %s %s"), &c[0], t->con.text, t->proptext);
+	}
+	else {
+		ofs += BLI_snprintf(str + ofs, UI_MAX_DRAW_STR - ofs, IFACE_("Rot: %.2f%s %s"),
+		                    RAD2DEGF(final), t->con.text, t->proptext);
+	}
+
+	if (t->flag & T_PROP_EDIT_ALL) {
+		ofs += BLI_snprintf(str + ofs, UI_MAX_DRAW_STR - ofs, IFACE_(" Proportional size: %.2f"), t->prop_size);
+	}
+}
+
 /**
  * Applies values of rotation to `td->loc` and `td->ext->quat`
  * based on a rotation matrix (mat) and a pivot (center).
@@ -3979,7 +4057,6 @@ static void applyRotationValue(TransInfo *t, float angle, float axis[3])
 static void applyRotation(TransInfo *t, const int UNUSED(mval[2]))
 {
 	char str[UI_MAX_DRAW_STR];
-	size_t ofs = 0;
 
 	float final;
 
@@ -4002,21 +4079,7 @@ static void applyRotation(TransInfo *t, const int UNUSED(mval[2]))
 
 	t->values[0] = final;
 
-	if (hasNumInput(&t->num)) {
+	headerRotation(t, str, final);
-		char c[NUM_STR_REP_LEN];
-		
-		outputNumInput(&(t->num), c, &t->scene->unit);
-		
-		ofs += BLI_snprintf(str + ofs, sizeof(str) - ofs, IFACE_("Rot: %s %s %s"), &c[0], t->con.text, t->proptext);
-	}
-	else {
-		ofs += BLI_snprintf(str + ofs, sizeof(str) - ofs, IFACE_("Rot: %.2f%s %s"),
-		                    RAD2DEGF(final), t->con.text, t->proptext);
-	}
-	
-	if (t->flag & T_PROP_EDIT_ALL) {
-		ofs += BLI_snprintf(str + ofs, sizeof(str) - ofs, IFACE_(" Proportional size: %.2f"), t->prop_size);
-	}
 
 	applyRotationValue(t, final, t->axis);
 	
@@ -4142,6 +4205,122 @@ static void applyTrackball(TransInfo *t, const int UNUSED(mval[2]))
 /** \} */
 
 
+/* -------------------------------------------------------------------- */
+/* Transform (Normal Rotation) */
+
+/** \name Transform Normal Rotation
+* \{ */
+
+static void storeCustomLNorValue(TransInfo *t, BMesh *bm)
+{
+	BMLoopNorEditDataArray *lnors_ed_arr = BM_loop_normal_editdata_array_init(bm);
+	BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata;
+
+	t->custom.mode.data = lnors_ed_arr;
+	t->custom.mode.free_cb = freeCustomNormalArray;
+}
+
+void freeCustomNormalArray(TransInfo *t, TransCustomData *custom_data)
+{
+	BMLoopNorEditDataArray *lnors_ed_arr = custom_data->data;
+
+	if (t->state == TRANS_CANCEL) {
+		BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata;
+		BMEditMesh *em = BKE_editmesh_from_object(t->obedit);
+		BMesh *bm = em->bm;
+
+		for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {  /* Restore custom loop normal on cancel */
+			BKE_lnor_space_custom_normal_to_data(
+			            bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], lnor_ed->niloc, lnor_ed->clnors_data);
+		}
+	}
+
+	BM_loop_normal_editdata_array_free(lnors_ed_arr);
+
+	t->custom.mode.data = NULL;
+	t->custom.mode.free_cb = NULL;
+}
+
+static void initNormalRotation(TransInfo *t)
+{
+	t->mode = TFM_NORMAL_ROTATION;
+	t->transform = applyNormalRotation;
+
+	setInputPostFct(&t->mouse, postInputRotation);
+	initMouseInputMode(t, &t->mouse, INPUT_ANGLE);
+
+	t->idx_max = 0;
+	t->num.idx_max = 0;
+	t->snap[0] = 0.0f;
+	t->snap[1] = DEG2RAD(5.0);
+	t->snap[2] = DEG2RAD(1.0);
+
+	copy_v3_fl(t->num.val_inc, t->snap[2]);
+	t->num.unit_sys = t->scene->unit.system;
+	t->num.unit_use_radians = (t->scene->unit.system_rotation == USER_UNIT_ROT_RADIANS);
+	t->num.unit_type[0] = B_UNIT_ROTATION;
+
+	BMEditMesh *em = BKE_editmesh_from_object(t->obedit);
+	BMesh *bm = em->bm;
+
+	BKE_editmesh_lnorspace_update(em);
+
+	storeCustomLNorValue(t, bm);
+
+	negate_v3_v3(t->axis, t->viewinv[2]);
+	normalize_v3(t->axis);
+
+	copy_v3_v3(t->axis_orig, t->axis);
+}
+
+/* Works by getting custom normal from clnor_data, transform, then store */
+static void applyNormalRotation(TransInfo *t, const int UNUSED(mval[2]))
+{
+	BMEditMesh *em = BKE_editmesh_from_object(t->obedit);
+	BMesh *bm = em->bm;
+	char str[UI_MAX_DRAW_STR];
+
+	if ((t->con.mode & CON_APPLY) && t->con.applyRot) {
+		t->con.applyRot(t, NULL, t->axis, NULL);
+	}
+	else {
+		/* reset axis if constraint is not set */
+		copy_v3_v3(t->axis, t->axis_orig);
+	}
+
+	BMLoopNorEditDataArray *lnors_ed_arr = t->custom.mode.data;
+	BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata;
+
+	float axis[3];
+	float mat[3][3];
+	float angle = t->values[0];
+	copy_v3_v3(axis, t->axis);
+
+	snapGridIncrement(t, &angle);
+
+	applySnapping(t, &angle);
+
+	applyNumInput(&t->num, &angle);
+
+	headerRotation(t, str, angle);
+
+	axis_angle_normalized_to_mat3(mat, axis, angle);
+
+	for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
+        mul_v3_m3v3(lnor_ed->nloc, mat, lnor_ed->niloc);
+
+		BKE_lnor_space_custom_normal_to_data(
+		            bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], lnor_ed->nloc, lnor_ed->clnors_data);
+	}
+
+	recalcData(t);
+
+	ED_area_headerprint(t->sa, str);
+}
+
+/** \} */
+
+
 /* -------------------------------------------------------------------- */
 /* Transform (Translation) */
 

source/blender/editors/transform/transform.h

@@ -536,6 +536,8 @@ typedef struct TransInfo {
 	/** #TransInfo.center has been set, don't change it. */
 #define T_OVERRIDE_CENTER	(1 << 25)
 
+#define T_CLNOR_REBUILD		(1 << 26)
+
 /* TransInfo->modifiers */
 #define	MOD_CONSTRAINT_SELECT	0x01
 #define	MOD_PRECISION			0x02
@@ -798,6 +800,8 @@ bool applyTransformOrientation(const struct bContext *C, float mat[3][3], char r
 int getTransformOrientation_ex(const struct bContext *C, float normal[3], float plane[3], const short around);
 int getTransformOrientation(const struct bContext *C, float normal[3], float plane[3]);
 
+void freeCustomNormalArray(TransInfo *t, TransCustomData *custom_data);
+
 void freeEdgeSlideTempFaces(EdgeSlideData *sld);
 void freeEdgeSlideVerts(TransInfo *t, TransCustomData *custom_data);
 void projectEdgeSlideData(TransInfo *t, bool is_final);

source/blender/editors/transform/transform_generics.c

@@ -1072,6 +1072,9 @@ void resetTransModal(TransInfo *t)
 	else if (t->mode == TFM_VERT_SLIDE) {
 		freeVertSlideVerts(t, &t->custom.mode);
 	}
+	else if (t->mode == TFM_NORMAL_ROTATION) {
+		freeCustomNormalArray(t, &t->custom.mode);
+	}
 }
 
 void resetTransRestrictions(TransInfo *t)

source/blender/editors/transform/transform_ops.c

@@ -81,6 +81,7 @@ static const char OP_VERT_SLIDE[] = "TRANSFORM_OT_vert_slide";
 static const char OP_EDGE_CREASE[] = "TRANSFORM_OT_edge_crease";
 static const char OP_EDGE_BWEIGHT[] = "TRANSFORM_OT_edge_bevelweight";
 static const char OP_SEQ_SLIDE[] = "TRANSFORM_OT_seq_slide";
+static const char OP_NORMAL_ROTATION[] = "TRANSFORM_OT_rotate_normal";
 
 static void TRANSFORM_OT_translate(struct wmOperatorType *ot);
 static void TRANSFORM_OT_rotate(struct wmOperatorType *ot);
@@ -99,6 +100,7 @@ static void TRANSFORM_OT_vert_slide(struct wmOperatorType *ot);
 static void TRANSFORM_OT_edge_crease(struct wmOperatorType *ot);
 static void TRANSFORM_OT_edge_bevelweight(struct wmOperatorType *ot);
 static void TRANSFORM_OT_seq_slide(struct wmOperatorType *ot);
+static void TRANSFORM_OT_rotate_normal(struct wmOperatorType *ot);
 
 static TransformModeItem transform_modes[] =
 {
@@ -119,6 +121,7 @@ static TransformModeItem transform_modes[] =
 	{OP_EDGE_CREASE, TFM_CREASE, TRANSFORM_OT_edge_crease},
 	{OP_EDGE_BWEIGHT, TFM_BWEIGHT, TRANSFORM_OT_edge_bevelweight},
 	{OP_SEQ_SLIDE, TFM_SEQ_SLIDE, TRANSFORM_OT_seq_slide},
+	{OP_NORMAL_ROTATION, TFM_NORMAL_ROTATION, TRANSFORM_OT_rotate_normal},
 	{NULL, 0}
 };
 
@@ -495,6 +498,39 @@ static int transform_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 	}
 }
 
+static bool transform_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
+{
+	const char *prop_id = RNA_property_identifier(prop);
+
+	/* Only show preserve_clnor option if requested (kinda hackish, we need to take that decision based on context... */
+	if (STREQ(prop_id, "preserve_clnor")) {
+		return RNA_boolean_get(ptr, "show_preserve_clnor");;
+	}
+
+	/* Else, show it! */
+	return true;
+}
+
+static void transform_ui(bContext *C, wmOperator *op)
+{
+	uiLayout *layout = op->layout;
+	wmWindowManager *wm = CTX_wm_manager(C);
+	PointerRNA ptr;
+	Object *obedit = CTX_data_edit_object(C);
+
+	PropertyRNA *prop = RNA_struct_find_property(op->ptr, "show_preserve_clnor");
+	if (prop) {
+		RNA_property_boolean_set(
+		            op->ptr, prop,
+		            (obedit && obedit->type == OB_MESH && (((Mesh *)(obedit->data))->flag & ME_AUTOSMOOTH)));
+	}
+
+	RNA_pointer_create(&wm->id, op->type->srna, op->properties, &ptr);
+
+	/* Main auto-draw call */
+	uiDefAutoButsRNA(layout, &ptr, transform_draw_check_prop, '\0');
+}
+
 void Transform_Properties(struct wmOperatorType *ot, int flags)
 {
 	PropertyRNA *prop;
@@ -580,6 +616,12 @@ void Transform_Properties(struct wmOperatorType *ot, int flags)
 		prop = RNA_def_boolean(ot->srna, "use_accurate", 0, "Accurate", "Use accurate transformation");
 		RNA_def_property_flag(prop, PROP_HIDDEN);
 	}
+
+	if (flags & P_CLNOR_INVALIDATE) {
+		RNA_def_boolean(ot->srna, "preserve_clnor", false, "Preserve Normals", "Keep custom normals during transform");
+		prop = RNA_def_boolean(ot->srna, "show_preserve_clnor", false, "Show Preserve Normals", "");
+		RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
+	}
 }
 
 static void TRANSFORM_OT_translate(struct wmOperatorType *ot)
@@ -596,10 +638,11 @@ static void TRANSFORM_OT_translate(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_vector_xyz(ot->srna, "value", 3, NULL, -FLT_MAX, FLT_MAX, "Vector", "", -FLT_MAX, FLT_MAX);
 
-	Transform_Properties(ot, P_CONSTRAINT | P_PROPORTIONAL | P_MIRROR | P_ALIGN_SNAP | P_OPTIONS | P_GPENCIL_EDIT);
+	Transform_Properties(ot, P_CONSTRAINT | P_PROPORTIONAL | P_MIRROR | P_ALIGN_SNAP | P_OPTIONS | P_GPENCIL_EDIT | P_CLNOR_INVALIDATE);
 }
 
 static void TRANSFORM_OT_resize(struct wmOperatorType *ot)
@@ -616,12 +659,12 @@ static void TRANSFORM_OT_resize(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_vector(ot->srna, "value", 3, VecOne, -FLT_MAX, FLT_MAX, "Vector", "", -FLT_MAX, FLT_MAX);
 
 	Transform_Properties(
-	        ot, P_CONSTRAINT | P_PROPORTIONAL | P_MIRROR | P_GEO_SNAP | P_OPTIONS | P_GPENCIL_EDIT | P_CENTER);
+	        ot, P_CONSTRAINT | P_PROPORTIONAL | P_MIRROR | P_GEO_SNAP | P_OPTIONS | P_GPENCIL_EDIT | P_CENTER | P_CLNOR_INVALIDATE);}
-}
 
 static int skin_resize_poll(bContext *C)
 {
@@ -647,6 +690,7 @@ static void TRANSFORM_OT_skin_resize(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = skin_resize_poll;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_vector(ot->srna, "value", 3, VecOne, -FLT_MAX, FLT_MAX, "Vector", "", -FLT_MAX, FLT_MAX);
 
@@ -667,12 +711,12 @@ static void TRANSFORM_OT_trackball(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
 	/* Maybe we could use float_vector_xyz here too? */
 	RNA_def_float_rotation(ot->srna, "value", 2, NULL, -FLT_MAX, FLT_MAX, "Angle", "", -FLT_MAX, FLT_MAX);
 
-	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_GPENCIL_EDIT | P_CENTER);
+	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_GPENCIL_EDIT | P_CENTER | P_CLNOR_INVALIDATE);}
-}
 
 static void TRANSFORM_OT_rotate(struct wmOperatorType *ot)
 {
@@ -688,12 +732,12 @@ static void TRANSFORM_OT_rotate(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_rotation(ot->srna, "value", 0, NULL, -FLT_MAX, FLT_MAX, "Angle", "", -M_PI * 2, M_PI * 2);
 
 	Transform_Properties(
-	        ot, P_AXIS | P_CONSTRAINT | P_PROPORTIONAL | P_MIRROR | P_GEO_SNAP | P_GPENCIL_EDIT | P_CENTER);
+	        ot, P_AXIS | P_CONSTRAINT | P_PROPORTIONAL | P_MIRROR | P_GEO_SNAP | P_GPENCIL_EDIT | P_CENTER | P_CLNOR_INVALIDATE);}
-}
 
 static void TRANSFORM_OT_tilt(struct wmOperatorType *ot)
 {
@@ -712,6 +756,7 @@ static void TRANSFORM_OT_tilt(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_editcurve_3d;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_rotation(ot->srna, "value", 0, NULL, -FLT_MAX, FLT_MAX, "Angle", "", -M_PI * 2, M_PI * 2);
 
@@ -732,11 +777,11 @@ static void TRANSFORM_OT_bend(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_region_view3d_active;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_rotation(ot->srna, "value", 1, NULL, -FLT_MAX, FLT_MAX, "Angle", "", -M_PI * 2, M_PI * 2);
 
-	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_GPENCIL_EDIT | P_CENTER);
+	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_GPENCIL_EDIT | P_CENTER | P_CLNOR_INVALIDATE);}
-}
 
 static void TRANSFORM_OT_shear(struct wmOperatorType *ot)
 {
@@ -752,10 +797,11 @@ static void TRANSFORM_OT_shear(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
 	RNA_def_float(ot->srna, "value", 0, -FLT_MAX, FLT_MAX, "Offset", "", -FLT_MAX, FLT_MAX);
 
-	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_GPENCIL_EDIT);
+	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_GPENCIL_EDIT | P_CLNOR_INVALIDATE);
 	// XXX Shear axis?
 }
 
@@ -773,11 +819,11 @@ static void TRANSFORM_OT_push_pull(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
 	RNA_def_float(ot->srna, "value", 0, -FLT_MAX, FLT_MAX, "Distance", "", -FLT_MAX, FLT_MAX);
 
-	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_CENTER);
+	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_CENTER | P_CLNOR_INVALIDATE);}
-}
 
 static void TRANSFORM_OT_shrink_fatten(struct wmOperatorType *ot)
 {
@@ -793,12 +839,13 @@ static void TRANSFORM_OT_shrink_fatten(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_editmesh;
+	ot->ui     = transform_ui;
 
 	RNA_def_float(ot->srna, "value", 0, -FLT_MAX, FLT_MAX, "Offset", "", -FLT_MAX, FLT_MAX);
 
 	RNA_def_boolean(ot->srna, "use_even_offset", true, "Offset Even", "Scale the offset to give more even thickness");
 
-	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP);
+	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_CLNOR_INVALIDATE);
 }
 
 static void TRANSFORM_OT_tosphere(struct wmOperatorType *ot)
@@ -816,11 +863,11 @@ static void TRANSFORM_OT_tosphere(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_factor(ot->srna, "value", 0, 0, 1, "Factor", "", 0, 1);
 
-	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_GPENCIL_EDIT | P_CENTER);
+	Transform_Properties(ot, P_PROPORTIONAL | P_MIRROR | P_SNAP | P_GPENCIL_EDIT | P_CENTER | P_CLNOR_INVALIDATE);}
-}
 
 static void TRANSFORM_OT_mirror(struct wmOperatorType *ot)
 {
@@ -836,9 +883,9 @@ static void TRANSFORM_OT_mirror(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
-	Transform_Properties(ot, P_CONSTRAINT | P_PROPORTIONAL | P_GPENCIL_EDIT | P_CENTER);
+	Transform_Properties(ot, P_CONSTRAINT | P_PROPORTIONAL | P_GPENCIL_EDIT | P_CENTER | P_CLNOR_INVALIDATE);}
-}
 
 static void TRANSFORM_OT_edge_slide(struct wmOperatorType *ot)
 {
@@ -856,6 +903,7 @@ static void TRANSFORM_OT_edge_slide(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_editmesh_region_view3d;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_factor(ot->srna, "value", 0, -10.0f, 10.0f, "Factor", "", -1.0f, 1.0f);
 
@@ -868,7 +916,7 @@ static void TRANSFORM_OT_edge_slide(struct wmOperatorType *ot)
 	RNA_def_boolean(ot->srna, "use_clamp", true, "Clamp",
 	                "Clamp within the edge extents");
 
-	Transform_Properties(ot, P_MIRROR | P_SNAP | P_CORRECT_UV);
+	Transform_Properties(ot, P_MIRROR | P_SNAP | P_CORRECT_UV | P_CLNOR_INVALIDATE);
 }
 
 static void TRANSFORM_OT_vert_slide(struct wmOperatorType *ot)
@@ -885,6 +933,7 @@ static void TRANSFORM_OT_vert_slide(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_editmesh_region_view3d;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_factor(ot->srna, "value", 0, -10.0f, 10.0f, "Factor", "", -1.0f, 1.0f);
 	RNA_def_boolean(ot->srna, "use_even", false, "Even",
@@ -894,7 +943,7 @@ static void TRANSFORM_OT_vert_slide(struct wmOperatorType *ot)
 	RNA_def_boolean(ot->srna, "use_clamp", true, "Clamp",
 	                "Clamp within the edge extents");
 
-	Transform_Properties(ot, P_MIRROR | P_SNAP | P_CORRECT_UV);
+	Transform_Properties(ot, P_MIRROR | P_SNAP | P_CORRECT_UV | P_CLNOR_INVALIDATE);
 }
 
 static void TRANSFORM_OT_edge_crease(struct wmOperatorType *ot)
@@ -911,6 +960,7 @@ static void TRANSFORM_OT_edge_crease(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_editmesh;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_factor(ot->srna, "value", 0, -1.0f, 1.0f, "Factor", "", -1.0f, 1.0f);
 
@@ -952,6 +1002,7 @@ static void TRANSFORM_OT_edge_bevelweight(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_editmesh;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_factor(ot->srna, "value", 0, -1.0f, 1.0f, "Factor", "", -1.0f, 1.0f);
 
@@ -972,12 +1023,34 @@ static void TRANSFORM_OT_seq_slide(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_sequencer_active;
+	ot->ui     = transform_ui;
 
 	RNA_def_float_vector_xyz(ot->srna, "value", 2, NULL, -FLT_MAX, FLT_MAX, "Vector", "", -FLT_MAX, FLT_MAX);
 
 	Transform_Properties(ot, P_SNAP);
 }
 
+static void TRANSFORM_OT_rotate_normal(struct wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Normal Rotate";
+	ot->description = "Rotate split normal of selected items";
+	ot->idname = OP_NORMAL_ROTATION;
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
+
+	/* api callbacks */
+	ot->invoke = transform_invoke;
+	ot->exec   = transform_exec;
+	ot->modal  = transform_modal;
+	ot->cancel = transform_cancel;
+	ot->poll   = ED_operator_editmesh_auto_smooth;
+	ot->ui     = transform_ui;
+
+	RNA_def_float_rotation(ot->srna, "value", 0, NULL, -FLT_MAX, FLT_MAX, "Angle", "", -M_PI * 2, M_PI * 2);
+
+	Transform_Properties(ot, P_AXIS | P_CONSTRAINT | P_MIRROR);
+}
+
 static void TRANSFORM_OT_transform(struct wmOperatorType *ot)
 {
 	PropertyRNA *prop;
@@ -994,6 +1067,7 @@ static void TRANSFORM_OT_transform(struct wmOperatorType *ot)
 	ot->modal  = transform_modal;
 	ot->cancel = transform_cancel;
 	ot->poll   = ED_operator_screenactive;
+	ot->ui     = transform_ui;
 
 	prop = RNA_def_enum(ot->srna, "mode", rna_enum_transform_mode_types, TFM_TRANSLATION, "Mode", "");
 	RNA_def_property_flag(prop, PROP_HIDDEN);

source/blender/makesdna/DNA_modifier_types.h

@@ -87,6 +87,7 @@ typedef enum ModifierType {
 	eModifierType_CorrectiveSmooth  = 51,
 	eModifierType_MeshSequenceCache = 52,
 	eModifierType_SurfaceDeform     = 53,
+	eModifierType_WeightedNormal	= 54,
 	NUM_MODIFIER_TYPES
 } ModifierType;
 
@@ -1619,6 +1620,32 @@ enum {
 	MOD_SDEF_MODE_CENTROID = 2,
 };
 
+typedef struct WeightedNormalModifierData {
+	ModifierData modifier;
+
+	char defgrp_name[64];  /* MAX_VGROUP_NAME */
+	char mode, flag;
+	short weight;
+	float thresh;
+} WeightedNormalModifierData;
+
+/* Name/id of the generic PROP_INT cdlayer storing face weights. */
+#define MOD_WEIGHTEDNORMALS_FACEWEIGHT_CDLAYER_ID "__mod_weightednormals_faceweight"
+
+/* WeightedNormalModifierData.mode */
+enum {
+	MOD_WEIGHTEDNORMAL_MODE_FACE = 0,
+	MOD_WEIGHTEDNORMAL_MODE_ANGLE = 1,
+	MOD_WEIGHTEDNORMAL_MODE_FACE_ANGLE = 2,
+};
+
+/* WeightedNormalModifierData.flag */
+enum {
+	MOD_WEIGHTEDNORMAL_KEEP_SHARP = (1 << 0),
+	MOD_WEIGHTEDNORMAL_INVERT_VGROUP = (1 << 1),
+	MOD_WEIGHTEDNORMAL_FACE_INFLUENCE = (1 << 2),
+};
+
 #define MOD_MESHSEQ_READ_ALL \
 	(MOD_MESHSEQ_READ_VERT | MOD_MESHSEQ_READ_POLY | MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)
 

source/blender/makesdna/DNA_scene_types.h

@@ -1579,6 +1579,10 @@ typedef struct ToolSettings {
 	struct CurvePaintSettings curve_paint_settings;
 
 	struct MeshStatVis statvis;
+
+	/* Normal Editing */
+	float normal_vector[3];
+	int face_strength;
 } ToolSettings;
 
 /* *************************************************************** */
@@ -2042,6 +2046,13 @@ enum {
 	OB_DRAW_GROUPUSER_ALL       = 2
 };
 
+/* toolsettings->face_strength */
+enum {
+	FACE_STRENGTH_WEAK = -16384,
+	FACE_STRENGTH_MEDIUM = 0,
+	FACE_STRENGTH_STRONG = 16384,
+};
+
 /* object_vgroup.c */
 /* ToolSettings.vgroupsubset */
 typedef enum eVGroupSelect {

source/blender/makesrna/RNA_access.h

@@ -697,6 +697,7 @@ extern StructRNA RNA_WaveModifier;
 extern StructRNA RNA_VertexWeightEditModifier;
 extern StructRNA RNA_VertexWeightMixModifier;
 extern StructRNA RNA_VertexWeightProximityModifier;
+extern StructRNA RNA_WeightedNormalModifier;
 extern StructRNA RNA_Window;
 extern StructRNA RNA_WindowManager;
 extern StructRNA RNA_WipeSequence;

source/blender/makesrna/intern/rna_modifier.c

@@ -68,6 +68,7 @@ const EnumPropertyItem rna_enum_object_modifier_type_items[] = {
 	{eModifierType_MeshCache, "MESH_CACHE", ICON_MOD_MESHDEFORM, "Mesh Cache", ""},
 	{eModifierType_MeshSequenceCache, "MESH_SEQUENCE_CACHE", ICON_MOD_MESHDEFORM, "Mesh Sequence Cache", ""},
 	{eModifierType_NormalEdit, "NORMAL_EDIT", ICON_MOD_NORMALEDIT, "Normal Edit", ""},
+	{eModifierType_WeightedNormal, "WEIGHTED_NORMAL", ICON_MOD_NORMALEDIT, "Weighted Normal", ""},
 	{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", ""},
@@ -411,6 +412,8 @@ static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr)
 			return &RNA_MeshSequenceCacheModifier;
 		case eModifierType_SurfaceDeform:
 			return &RNA_SurfaceDeformModifier;
+		case eModifierType_WeightedNormal:
+			return &RNA_WeightedNormalModifier;
 		/* Default */
 		case eModifierType_None:
 		case eModifierType_ShapeKey:
@@ -501,6 +504,7 @@ RNA_MOD_VGROUP_NAME_SET(WeightVGMix, defgrp_name_b);
 RNA_MOD_VGROUP_NAME_SET(WeightVGMix, mask_defgrp_name);
 RNA_MOD_VGROUP_NAME_SET(WeightVGProximity, defgrp_name);
 RNA_MOD_VGROUP_NAME_SET(WeightVGProximity, mask_defgrp_name);
+RNA_MOD_VGROUP_NAME_SET(WeightedNormal, defgrp_name);
 RNA_MOD_VGROUP_NAME_SET(Wireframe, defgrp_name);
 
 static void rna_ExplodeModifier_vgroup_get(PointerRNA *ptr, char *value)
@@ -4809,6 +4813,68 @@ static void rna_def_modifier_surfacedeform(BlenderRNA *brna)
 	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 }
 
+static void rna_def_modifier_weightednormal(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	static EnumPropertyItem prop_weighting_mode_items[] = {
+		{MOD_WEIGHTEDNORMAL_MODE_FACE, "FACE_AREA", 0, "Face Area", "Generate face area weighted normals"},
+		{MOD_WEIGHTEDNORMAL_MODE_ANGLE, "CORNER_ANGLE", 0, "Corner Angle", "Generate corner angle weighted normals"},
+		{MOD_WEIGHTEDNORMAL_MODE_FACE_ANGLE, "FACE_AREA_WITH_ANGLE", 0, "Face Area And Angle",
+		                                     "Generated normals weighted by both face area and angle"},
+		{0, NULL, 0, NULL, NULL}
+	};
+
+	srna = RNA_def_struct(brna, "WeightedNormalModifier", "Modifier");
+	RNA_def_struct_ui_text(srna, "WeightedNormal Modifier", "");
+	RNA_def_struct_sdna(srna, "WeightedNormalModifierData");
+	RNA_def_struct_ui_icon(srna, ICON_MOD_NORMALEDIT);
+
+	prop = RNA_def_property(srna, "weight", PROP_INT, PROP_NONE);
+	RNA_def_property_range(prop, 1, 100);
+	RNA_def_property_ui_range(prop, 1, 100, 1, -1);
+	RNA_def_property_ui_text(prop, "Weight",
+	                         "Corrective factor applied to faces' weights, 50 is neutral, "
+	                         "lower values increase weight of weak faces, "
+	                         "higher values increase weight of strong faces");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_items(prop, prop_weighting_mode_items);
+	RNA_def_property_ui_text(prop, "Weighting Mode", "Weighted vertex normal mode to use");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "thresh", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_range(prop, 0, 10);
+	RNA_def_property_ui_range(prop, 0, 10, 1, 2);
+	RNA_def_property_ui_text(prop, "Threshold", "Threshold value for different weights to be considered equal");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "keep_sharp", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WEIGHTEDNORMAL_KEEP_SHARP);
+	RNA_def_property_ui_text(prop, "Keep Sharp",
+	                         "Keep sharp edges as computed for default split normals, "
+	                         "instead of setting a single weighted normal for each vertex.");
+	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 modifying the selected areas");
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_WeightedNormalModifier_defgrp_name_set");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WEIGHTEDNORMAL_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, "face_influence", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WEIGHTEDNORMAL_FACE_INFLUENCE);
+	RNA_def_property_ui_text(prop, "Face Influence", "Use influence of face for weighting");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+}
+
 void RNA_def_modifier(BlenderRNA *brna)
 {
 	StructRNA *srna;
@@ -4927,6 +4993,7 @@ void RNA_def_modifier(BlenderRNA *brna)
 	rna_def_modifier_normaledit(brna);
 	rna_def_modifier_meshseqcache(brna);
 	rna_def_modifier_surfacedeform(brna);
+	rna_def_modifier_weightednormal(brna);
 }
 
 #endif

source/blender/makesrna/intern/rna_scene.c

@@ -2502,6 +2502,13 @@ static void rna_def_tool_settings(BlenderRNA  *brna)
 		{0, NULL, 0, NULL, NULL}
 	};
 
+	static EnumPropertyItem mod_weighted_strength[] = {
+		{FACE_STRENGTH_WEAK, "Weak", 0, "Weak", ""},
+		{FACE_STRENGTH_MEDIUM, "Medium", 0, "Medium", ""},
+		{FACE_STRENGTH_STRONG, "Strong", 0, "Strong", ""},
+		{0, NULL, 0, NULL, NULL},
+	};
+
 	static const EnumPropertyItem draw_groupuser_items[] = {
 		{OB_DRAW_GROUPUSER_NONE, "NONE", 0, "None", ""},
 		{OB_DRAW_GROUPUSER_ACTIVE, "ACTIVE", 0, "Active", "Show vertices with no weights in the active group"},
@@ -2890,6 +2897,14 @@ static void rna_def_tool_settings(BlenderRNA  *brna)
 	RNA_def_property_boolean_sdna(prop, NULL, "edge_mode_live_unwrap", 1);
 	RNA_def_property_ui_text(prop, "Live Unwrap", "Changing edges seam re-calculates UV unwrap");
 
+	prop = RNA_def_property(srna, "normal_vector", PROP_FLOAT, PROP_XYZ);
+	RNA_def_property_ui_text(prop, "Normal Vector", "Normal Vector used to copy, add or multiply");
+	RNA_def_property_ui_range(prop, -10000.0, 10000.0, 1, 3);
+
+	prop = RNA_def_property(srna, "face_strength", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_items(prop, mod_weighted_strength);
+	RNA_def_property_ui_text(prop, "Face Strength", "Set strength of face to specified value");
+
 	/* etch-a-ton */
 	prop = RNA_def_property(srna, "use_bone_sketching", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "bone_sketching", BONE_SKETCHING);

source/blender/modifiers/CMakeLists.txt

@@ -100,6 +100,7 @@ set(SRC
 	intern/MOD_uvproject.c
 	intern/MOD_warp.c
 	intern/MOD_wave.c
+	intern/MOD_weighted_normal.c
 	intern/MOD_weightvg_util.c
 	intern/MOD_weightvgedit.c
 	intern/MOD_weightvgmix.c

source/blender/modifiers/MOD_modifiertypes.h

@@ -86,6 +86,7 @@ extern ModifierTypeInfo modifierType_NormalEdit;
 extern ModifierTypeInfo modifierType_CorrectiveSmooth;
 extern ModifierTypeInfo modifierType_MeshSequenceCache;
 extern ModifierTypeInfo modifierType_SurfaceDeform;
+extern ModifierTypeInfo modifierType_WeightedNormal;
 
 /* MOD_util.c */
 void modifier_type_init(ModifierTypeInfo *types[]);

source/blender/modifiers/intern/MOD_util.c

@@ -288,5 +288,6 @@ void modifier_type_init(ModifierTypeInfo *types[])
 	INIT_TYPE(CorrectiveSmooth);
 	INIT_TYPE(MeshSequenceCache);
 	INIT_TYPE(SurfaceDeform);
+	INIT_TYPE(WeightedNormal);
 #undef INIT_TYPE
 }

source/blender/modifiers/intern/MOD_weighted_normal.c

@@ -0,0 +1,657 @@
+/*
+ * ***** 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.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ */
+
+/** \file blender/modifiers/intern/MOD_weighted_normal.c
+ *  \ingroup modifiers
+ */
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_mesh_types.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+
+#include "BKE_cdderivedmesh.h"
+#include "BKE_deform.h"
+#include "BKE_mesh.h"
+
+#include "BLI_math.h"
+#include "BLI_linklist.h"
+
+#include "MOD_modifiertypes.h"
+#include "MOD_util.h"
+
+#define CLNORS_VALID_VEC_LEN (1e-6f)
+
+typedef struct ModePair {
+	float val;  /* Contains mode based value (face area / corner angle). */
+	int index;  /* Index value per poly or per loop. */
+} ModePair;
+
+/* Sorting function used in modifier, sorts in decreasing order. */
+static int modepair_cmp_by_val_inverse(const void *p1, const void *p2)
+{
+	ModePair *r1 = (ModePair *)p1;
+	ModePair *r2 = (ModePair *)p2;
+
+	return (r1->val < r2->val) ? 1 : ((r1->val > r2->val) ? -1 : 0);
+}
+
+/* There will be one of those per vertex (simple case, computing one normal per vertex), or per smooth fan. */
+typedef struct WeightedNormalDataAggregateItem {
+	float normal[3];
+
+	int num_loops;  /* Count number of loops using this item so far. */
+	float curr_val;  /* Current max val for this item. */
+	int curr_strength;  /* Current max strength encountered for this item. */
+} WeightedNormalDataAggregateItem;
+
+#define NUM_CACHED_INVERSE_POWERS_OF_WEIGHT 128
+
+typedef struct WeightedNormalData {
+	const int numVerts;
+	const int numEdges;
+	const int numLoops;
+	const int numPolys;
+
+	MVert *mvert;
+	MEdge *medge;
+
+	MLoop *mloop;
+	short (*clnors)[2];
+	const bool has_clnors;  /* True if clnors already existed, false if we had to create them. */
+	const float split_angle;
+
+	MPoly *mpoly;
+	float (*polynors)[3];
+	int *poly_strength;
+
+	MDeformVert *dvert;
+	const int defgrp_index;
+	const bool use_invert_vgroup;
+
+	const float weight;
+	const short mode;
+
+	/* Lower-level, internal processing data. */
+	float cached_inverse_powers_of_weight[NUM_CACHED_INVERSE_POWERS_OF_WEIGHT];
+
+	WeightedNormalDataAggregateItem *items_data;
+
+	ModePair *mode_pair;
+
+	int *loop_to_poly;
+} WeightedNormalData;
+
+/* Check strength of given poly compared to those found so far for that given item (vertex or smooth fan),
+ * and reset matching item_data in case we get a stronger new strength. */
+static bool check_item_poly_strength(
+        WeightedNormalData *wn_data, WeightedNormalDataAggregateItem *item_data, const int mp_index)
+{
+	BLI_assert (wn_data->poly_strength != NULL);
+
+	const int mp_strength = wn_data->poly_strength[mp_index];
+
+	if (mp_strength > item_data->curr_strength) {
+		item_data->curr_strength = mp_strength;
+		item_data->curr_val = 0.0f;
+		item_data->num_loops = 0;
+		zero_v3(item_data->normal);
+	}
+
+	return mp_strength == item_data->curr_strength;
+}
+
+static void aggregate_item_normal(
+        WeightedNormalModifierData *wnmd, WeightedNormalData *wn_data,
+        WeightedNormalDataAggregateItem *item_data,
+        const int mv_index, const int mp_index,
+        const float curr_val, const bool use_face_influence)
+{
+	float (*polynors)[3] = wn_data->polynors;
+
+	MDeformVert *dvert = wn_data->dvert;
+	const int defgrp_index = wn_data->defgrp_index;
+	const bool use_invert_vgroup = wn_data->use_invert_vgroup;
+
+	const float weight = wn_data->weight;
+
+	float *cached_inverse_powers_of_weight = wn_data->cached_inverse_powers_of_weight;
+
+	const bool has_vgroup = dvert != NULL;
+	const bool vert_of_group = has_vgroup && defvert_find_index(&dvert[mv_index], defgrp_index) != NULL;
+
+	if (has_vgroup && ((vert_of_group && use_invert_vgroup) || (!vert_of_group && !use_invert_vgroup))) {
+		return;
+	}
+
+	if (use_face_influence && !check_item_poly_strength(wn_data, item_data, mp_index)) {
+		return;
+	}
+
+	/* If item's curr_val is 0 init it to present value. */
+	if (item_data->curr_val == 0.0f) {
+		item_data->curr_val = curr_val;
+	}
+	if (!compare_ff(item_data->curr_val, curr_val, wnmd->thresh)) {
+		/* item's curr_val and present value differ more than threshold, update. */
+		item_data->num_loops++;
+		item_data->curr_val = curr_val;
+	}
+
+	/* Exponentially divided weight for each normal (since a few values will be used by most cases, we cache those). */
+	const int num_loops = item_data->num_loops;
+	if (num_loops < NUM_CACHED_INVERSE_POWERS_OF_WEIGHT && cached_inverse_powers_of_weight[num_loops] == 0.0f) {
+		cached_inverse_powers_of_weight[num_loops] = 1.0f / powf(weight, num_loops);
+	}
+	const float inverted_n_weight = num_loops < NUM_CACHED_INVERSE_POWERS_OF_WEIGHT ?
+	                                    cached_inverse_powers_of_weight[num_loops] : 1.0f / powf(weight, num_loops);
+
+	madd_v3_v3fl(item_data->normal, polynors[mp_index], curr_val * inverted_n_weight);
+}
+
+static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd, WeightedNormalData *wn_data)
+{
+	const int numVerts = wn_data->numVerts;
+	const int numEdges = wn_data->numEdges;
+	const int numLoops = wn_data->numLoops;
+	const int numPolys = wn_data->numPolys;
+
+	MVert *mvert = wn_data->mvert;
+	MEdge *medge = wn_data->medge;
+
+	MLoop *mloop = wn_data->mloop;
+	short (*clnors)[2] = wn_data->clnors;
+	int *loop_to_poly = wn_data->loop_to_poly;
+
+	MPoly *mpoly = wn_data->mpoly;
+	float (*polynors)[3] = wn_data->polynors;
+	int *poly_strength = wn_data->poly_strength;
+
+	MDeformVert *dvert = wn_data->dvert;
+
+	const short mode = wn_data->mode;
+	ModePair *mode_pair = wn_data->mode_pair;
+
+	const bool has_clnors = wn_data->has_clnors;
+	const float split_angle = wn_data->split_angle;
+	MLoopNorSpaceArray lnors_spacearr = {NULL};
+
+	const bool keep_sharp = (wnmd->flag & MOD_WEIGHTEDNORMAL_KEEP_SHARP) != 0;
+	const bool use_face_influence = (wnmd->flag & MOD_WEIGHTEDNORMAL_FACE_INFLUENCE) != 0 && poly_strength != NULL;
+	const bool has_vgroup = dvert != NULL;
+
+	float (*loop_normals)[3] = NULL;
+
+	WeightedNormalDataAggregateItem *items_data = NULL;
+	int num_items = 0;
+	if (keep_sharp) {
+		BLI_bitmap *done_loops = BLI_BITMAP_NEW(numLoops, __func__);
+
+		/* This will give us loop normal spaces, we do not actually care about computed loop_normals for now... */
+		loop_normals = MEM_calloc_arrayN((size_t)numLoops, sizeof(*loop_normals), __func__);
+		BKE_mesh_normals_loop_split(mvert, numVerts, medge, numEdges,
+		                            mloop, loop_normals, numLoops, mpoly, polynors, numPolys,
+		                            true, split_angle, &lnors_spacearr, has_clnors ? clnors : NULL, loop_to_poly);
+
+		num_items = lnors_spacearr.num_spaces;
+		items_data = MEM_calloc_arrayN((size_t)num_items, sizeof(*items_data), __func__);
+
+		/* In this first loop, we assign each WeightedNormalDataAggregateItem to its smooth fan of loops (aka lnor space). */
+		MPoly *mp;
+		int mp_index;
+		int item_index;
+		for (mp = mpoly, mp_index = 0, item_index = 0; mp_index < numPolys; mp++, mp_index++) {
+			int ml_index = mp->loopstart;
+			const int ml_end_index = ml_index + mp->totloop;
+
+			for (; ml_index < ml_end_index; ml_index++) {
+				if (BLI_BITMAP_TEST(done_loops, ml_index)) {
+					/* Smooth fan of this loop has already been processed, skip it. */
+					continue;
+				}
+				BLI_assert(item_index < num_items);
+
+				WeightedNormalDataAggregateItem *itdt = &items_data[item_index];
+				itdt->curr_strength = FACE_STRENGTH_WEAK;
+
+				MLoopNorSpace *lnor_space = lnors_spacearr.lspacearr[ml_index];
+				lnor_space->user_data = itdt;
+
+				if (!(lnor_space->flags & MLNOR_SPACE_IS_SINGLE)) {
+					for (LinkNode *lnode = lnor_space->loops; lnode; lnode = lnode->next) {
+						const int ml_fan_index = GET_INT_FROM_POINTER(lnode->link);
+						BLI_BITMAP_ENABLE(done_loops, ml_fan_index);
+					}
+				}
+				else {
+					BLI_BITMAP_ENABLE(done_loops, ml_index);
+				}
+
+				item_index++;
+			}
+		}
+
+		MEM_freeN(done_loops);
+	}
+	else {
+		num_items = numVerts;
+		items_data = MEM_calloc_arrayN((size_t)num_items, sizeof(*items_data), __func__);
+		if (use_face_influence) {
+			for (int item_index = 0; item_index < num_items; item_index++) {
+				items_data[item_index].curr_strength = FACE_STRENGTH_WEAK;
+			}
+		}
+	}
+	wn_data->items_data = items_data;
+
+	switch (mode) {
+		case MOD_WEIGHTEDNORMAL_MODE_FACE:
+			for (int i = 0; i < numPolys; i++) {
+				const int mp_index = mode_pair[i].index;
+				const float mp_val = mode_pair[i].val;
+
+				int ml_index = mpoly[mp_index].loopstart;
+				const int ml_index_end = ml_index + mpoly[mp_index].totloop;
+				for (; ml_index < ml_index_end; ml_index++) {
+					const int mv_index = mloop[ml_index].v;
+					WeightedNormalDataAggregateItem *item_data = keep_sharp ?
+					                                                 lnors_spacearr.lspacearr[ml_index]->user_data:
+					                                                 &items_data[mv_index];
+
+					aggregate_item_normal(wnmd, wn_data, item_data, mv_index, mp_index, mp_val, use_face_influence);
+				}
+			}
+			break;
+		case MOD_WEIGHTEDNORMAL_MODE_ANGLE:
+		case MOD_WEIGHTEDNORMAL_MODE_FACE_ANGLE:
+			BLI_assert(loop_to_poly != NULL);
+
+			for (int i = 0; i < numLoops; i++) {
+				const int ml_index = mode_pair[i].index;
+				const float ml_val = mode_pair[i].val;
+
+				const int mp_index = loop_to_poly[ml_index];
+				const int mv_index = mloop[ml_index].v;
+				WeightedNormalDataAggregateItem *item_data = keep_sharp ?
+				                                                 lnors_spacearr.lspacearr[ml_index]->user_data:
+				                                                 &items_data[mv_index];
+
+				aggregate_item_normal(wnmd, wn_data, item_data, mv_index, mp_index, ml_val, use_face_influence);
+			}
+			break;
+		default:
+			BLI_assert(0);
+	}
+
+	/* Validate computed weighted normals. */
+	for (int item_index = 0; item_index < num_items; item_index++) {
+		if (normalize_v3(items_data[item_index].normal) < CLNORS_VALID_VEC_LEN) {
+			zero_v3(items_data[item_index].normal);
+		}
+	}
+
+	if (keep_sharp) {
+		/* Set loop normals for normal computed for each lnor space (smooth fan).
+		 * Note that loop_normals is already populated with clnors (before this modifier is applied, at start of
+		 * this function), so no need to recompute them here. */
+		for (int ml_index = 0; ml_index < numLoops; ml_index++) {
+			WeightedNormalDataAggregateItem *item_data = lnors_spacearr.lspacearr[ml_index]->user_data;
+			if (!is_zero_v3(item_data->normal)) {
+				copy_v3_v3(loop_normals[ml_index], item_data->normal);
+			}
+		}
+
+		BKE_mesh_normals_loop_custom_set(mvert, numVerts, medge, numEdges,
+		                                 mloop, loop_normals, numLoops, mpoly, polynors, numPolys, clnors);
+	}
+	else {
+		/* TODO: Ideally, we could add an option to BKE_mesh_normals_loop_custom_[from_vertices_]set() to keep current
+		 * clnors instead of resetting them to default autocomputed ones, when given new custom normal is zero-vec.
+		 * But this is not exactly trivial change, better to keep this optimization for later...
+		 */
+		if (!has_vgroup) {
+			/* Note: in theory, we could avoid this extra allocation & copying... But think we can live with it for now,
+			 * and it makes code simpler & cleaner. */
+			float (*vert_normals)[3] = MEM_calloc_arrayN((size_t)numVerts, sizeof(*loop_normals), __func__);
+
+			for (int ml_index = 0; ml_index < numLoops; ml_index++) {
+				const int mv_index = mloop[ml_index].v;
+				copy_v3_v3(vert_normals[mv_index], items_data[mv_index].normal);
+			}
+
+			BKE_mesh_normals_loop_custom_from_vertices_set(mvert, vert_normals, numVerts, medge, numEdges,
+			                                               mloop, numLoops, mpoly, polynors, numPolys, clnors);
+
+			MEM_freeN(vert_normals);
+		}
+		else {
+			loop_normals = MEM_calloc_arrayN((size_t)numLoops, sizeof(*loop_normals), __func__);
+
+			BKE_mesh_normals_loop_split(mvert, numVerts, medge, numEdges,
+			                            mloop, loop_normals, numLoops, mpoly, polynors, numPolys,
+			                            true, split_angle, NULL, has_clnors ? clnors : NULL, loop_to_poly);
+
+			for (int ml_index = 0; ml_index < numLoops; ml_index++) {
+				const int item_index = mloop[ml_index].v;
+				if (!is_zero_v3(items_data[item_index].normal)) {
+					copy_v3_v3(loop_normals[ml_index], items_data[item_index].normal);
+				}
+			}
+
+			BKE_mesh_normals_loop_custom_set(mvert, numVerts, medge, numEdges,
+			                                 mloop, loop_normals, numLoops, mpoly, polynors, numPolys, clnors);
+		}
+	}
+
+	if (keep_sharp) {
+		BKE_lnor_spacearr_free(&lnors_spacearr);
+	}
+	MEM_SAFE_FREE(loop_normals);
+}
+
+static void wn_face_area(WeightedNormalModifierData *wnmd, WeightedNormalData *wn_data)
+{
+	const int numPolys = wn_data->numPolys;
+
+	MVert *mvert = wn_data->mvert;
+	MLoop *mloop = wn_data->mloop;
+	MPoly *mpoly = wn_data->mpoly;
+
+	MPoly *mp;
+	int mp_index;
+
+	ModePair *face_area = MEM_malloc_arrayN((size_t)numPolys, sizeof(*face_area), __func__);
+
+	ModePair *f_area = face_area;
+	for (mp_index = 0, mp = mpoly; mp_index < numPolys; mp_index++, mp++, f_area++) {
+		f_area->val = BKE_mesh_calc_poly_area(mp, &mloop[mp->loopstart], mvert);
+		f_area->index = mp_index;
+	}
+
+	qsort(face_area, numPolys, sizeof(*face_area), modepair_cmp_by_val_inverse);
+
+	wn_data->mode_pair = face_area;
+	apply_weights_vertex_normal(wnmd, wn_data);
+}
+
+static void wn_corner_angle(WeightedNormalModifierData *wnmd, WeightedNormalData *wn_data)
+{
+	const int numLoops = wn_data->numLoops;
+	const int numPolys = wn_data->numPolys;
+
+	MVert *mvert = wn_data->mvert;
+	MLoop *mloop = wn_data->mloop;
+	MPoly *mpoly = wn_data->mpoly;
+
+	MPoly *mp;
+	int mp_index;
+
+	int *loop_to_poly = MEM_malloc_arrayN((size_t)numLoops, sizeof(*loop_to_poly), __func__);
+
+	ModePair *corner_angle = MEM_malloc_arrayN((size_t)numLoops, sizeof(*corner_angle), __func__);
+
+	for (mp_index = 0, mp = mpoly; mp_index < numPolys; mp_index++, mp++) {
+		MLoop *ml_start = &mloop[mp->loopstart];
+
+		float *index_angle = MEM_malloc_arrayN((size_t)mp->totloop, sizeof(*index_angle), __func__);
+		BKE_mesh_calc_poly_angles(mp, ml_start, mvert, index_angle);
+
+		ModePair *c_angl = &corner_angle[mp->loopstart];
+		float *angl = index_angle;
+		for (int ml_index = mp->loopstart; ml_index < mp->loopstart + mp->totloop; ml_index++, c_angl++, angl++) {
+			c_angl->val = (float)M_PI - *angl;
+			c_angl->index = ml_index;
+
+			loop_to_poly[ml_index] = mp_index;
+		}
+		MEM_freeN(index_angle);
+	}
+
+	qsort(corner_angle, numLoops, sizeof(*corner_angle), modepair_cmp_by_val_inverse);
+
+	wn_data->loop_to_poly = loop_to_poly;
+	wn_data->mode_pair = corner_angle;
+	apply_weights_vertex_normal(wnmd, wn_data);
+}
+
+static void wn_face_with_angle(WeightedNormalModifierData *wnmd, WeightedNormalData *wn_data)
+{
+	const int numLoops = wn_data->numLoops;
+	const int numPolys = wn_data->numPolys;
+
+	MVert *mvert = wn_data->mvert;
+	MLoop *mloop = wn_data->mloop;
+	MPoly *mpoly = wn_data->mpoly;
+
+	MPoly *mp;
+	int mp_index;
+
+	int *loop_to_poly = MEM_malloc_arrayN((size_t)numLoops, sizeof(*loop_to_poly), __func__);
+
+	ModePair *combined = MEM_malloc_arrayN((size_t)numLoops, sizeof(*combined), __func__);
+
+	for (mp_index = 0, mp = mpoly; mp_index < numPolys; mp_index++, mp++) {
+		MLoop *ml_start = &mloop[mp->loopstart];
+
+		float face_area = BKE_mesh_calc_poly_area(mp, ml_start, mvert);
+		float *index_angle = MEM_malloc_arrayN((size_t)mp->totloop, sizeof(*index_angle), __func__);
+		BKE_mesh_calc_poly_angles(mp, ml_start, mvert, index_angle);
+
+		ModePair *cmbnd = &combined[mp->loopstart];
+		float *angl = index_angle;
+		for (int ml_index = mp->loopstart; ml_index < mp->loopstart + mp->totloop; ml_index++, cmbnd++, angl++) {
+			/* In this case val is product of corner angle and face area. */
+			cmbnd->val = ((float)M_PI - *angl) * face_area;
+			cmbnd->index = ml_index;
+
+			loop_to_poly[ml_index] = mp_index;
+		}
+		MEM_freeN(index_angle);
+	}
+
+	qsort(combined, numLoops, sizeof(*combined), modepair_cmp_by_val_inverse);
+
+	wn_data->loop_to_poly = loop_to_poly;
+	wn_data->mode_pair = combined;
+	apply_weights_vertex_normal(wnmd, wn_data);
+}
+
+static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *dm, ModifierApplyFlag UNUSED(flag))
+{
+	WeightedNormalModifierData *wnmd = (WeightedNormalModifierData *)md;
+
+	Mesh *me = ob->data;
+
+	if (!(me->flag & ME_AUTOSMOOTH)) {
+		modifier_setError((ModifierData *)wnmd, "Enable 'Auto Smooth' option in mesh settings");
+		return dm;
+	}
+
+	const int numVerts = dm->getNumVerts(dm);
+	const int numEdges = dm->getNumEdges(dm);
+	const int numLoops = dm->getNumLoops(dm);
+	const int numPolys = dm->getNumPolys(dm);
+
+	MEdge *medge = dm->getEdgeArray(dm);
+	if (me->medge == medge) {
+		/* We need to duplicate data here, otherwise setting custom normals (which may also affect sharp edges) could
+		 * modify org mesh. */
+		dm = CDDM_copy(dm);
+		medge = dm->getEdgeArray(dm);
+	}
+	MPoly *mpoly = dm->getPolyArray(dm);
+	MVert *mvert = dm->getVertArray(dm);
+	MLoop *mloop = dm->getLoopArray(dm);
+
+	bool free_polynors = false;
+
+	/* Right now:
+	 * If weight = 50 then all faces are given equal weight.
+	 * If weight > 50 then more weight given to faces with larger vals (face area / corner angle).
+	 * If weight < 50 then more weight given to faces with lesser vals. However current calculation
+	 * does not converge to min/max.
+	 */
+	float weight = ((float)wnmd->weight) / 50.0f;
+	if (wnmd->weight == 100) {
+		weight = (float)SHRT_MAX;
+	}
+	else if (wnmd->weight == 1) {
+		weight = 1 / (float)SHRT_MAX;
+	}
+	else if ((weight - 1) * 25 > 1) {
+		weight = (weight - 1) * 25;
+	}
+
+	float (*polynors)[3] = dm->getPolyDataArray(dm, CD_NORMAL);
+	if (!polynors) {
+		polynors = MEM_malloc_arrayN((size_t)numPolys, sizeof(*polynors), __func__);
+		BKE_mesh_calc_normals_poly(mvert, NULL, numVerts, mloop, mpoly, numLoops, numPolys, polynors, false);
+		free_polynors = true;
+	}
+
+	const float split_angle = me->smoothresh;
+	short (*clnors)[2];
+	clnors = CustomData_duplicate_referenced_layer(&dm->loopData, CD_CUSTOMLOOPNORMAL, numLoops);
+	/* Keep info  whether we had clnors, it helps when generating clnor spaces and default normals. */
+	const bool has_clnors = clnors != NULL;
+	if (!clnors) {
+		DM_add_loop_layer(dm, CD_CUSTOMLOOPNORMAL, CD_CALLOC, NULL);
+		clnors = dm->getLoopDataArray(dm, CD_CUSTOMLOOPNORMAL);
+	}
+
+	MDeformVert *dvert;
+	int defgrp_index;
+	modifier_get_vgroup(ob, dm, wnmd->defgrp_name, &dvert, &defgrp_index);
+
+	WeightedNormalData wn_data = {
+	    .numVerts = numVerts,
+	    .numEdges = numEdges,
+	    .numLoops = numLoops,
+	    .numPolys = numPolys,
+
+	    .mvert = mvert,
+	    .medge = medge,
+
+	    .mloop = mloop,
+	    .clnors = clnors,
+	    .has_clnors = has_clnors,
+	    .split_angle = split_angle,
+
+	    .mpoly = mpoly,
+	    .polynors = polynors,
+	    .poly_strength = CustomData_get_layer_named(&dm->polyData, CD_PROP_INT, MOD_WEIGHTEDNORMALS_FACEWEIGHT_CDLAYER_ID),
+
+	    .dvert = dvert,
+	    .defgrp_index = defgrp_index,
+	    .use_invert_vgroup = (wnmd->flag & MOD_WEIGHTEDNORMAL_INVERT_VGROUP) != 0,
+
+	    .weight = weight,
+	    .mode = wnmd->mode,
+	};
+
+	switch (wnmd->mode) {
+		case MOD_WEIGHTEDNORMAL_MODE_FACE:
+			wn_face_area(wnmd, &wn_data);
+			break;
+		case MOD_WEIGHTEDNORMAL_MODE_ANGLE:
+			wn_corner_angle(wnmd, &wn_data);
+			break;
+		case MOD_WEIGHTEDNORMAL_MODE_FACE_ANGLE:
+			wn_face_with_angle(wnmd, &wn_data);
+			break;
+	}
+
+	if (free_polynors) {
+		MEM_freeN(polynors);
+	}
+
+	MEM_SAFE_FREE(wn_data.loop_to_poly);
+	MEM_SAFE_FREE(wn_data.mode_pair);
+	MEM_SAFE_FREE(wn_data.items_data);
+
+	return dm;
+}
+
+static void copyData(ModifierData *md, ModifierData *target)
+{
+	modifier_copyData_generic(md, target);
+}
+
+static void initData(ModifierData *md)
+{
+	WeightedNormalModifierData *wnmd = (WeightedNormalModifierData *)md;
+	wnmd->mode = MOD_WEIGHTEDNORMAL_MODE_FACE;
+	wnmd->weight = 50;
+	wnmd->thresh = 1e-2f;
+	wnmd->flag = 0;
+}
+
+static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
+{
+	WeightedNormalModifierData *wnmd = (WeightedNormalModifierData *)md;
+	CustomDataMask dataMask = CD_CUSTOMLOOPNORMAL;
+
+	if (wnmd->defgrp_name[0]) {
+		dataMask |= CD_MASK_MDEFORMVERT;
+	}
+
+	if (wnmd->flag & MOD_WEIGHTEDNORMAL_FACE_INFLUENCE) {
+		dataMask |= CD_MASK_PROP_INT;
+	}
+
+	return dataMask;
+}
+
+static bool dependsOnNormals(ModifierData *UNUSED(md))
+{
+	return true;
+}
+
+ModifierTypeInfo modifierType_WeightedNormal = {
+	/* name */              "Weighted Normal",
+	/* structName */        "WeightedNormalModifierData",
+	/* structSize */        sizeof(WeightedNormalModifierData),
+	/* type */              eModifierTypeType_Constructive,
+	/* flags */             eModifierTypeFlag_AcceptsMesh |
+	                        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 */        NULL,
+	/* updateDepgraph */    NULL,
+	/* updateDepsgraph */   NULL,
+	/* dependsOnTime */     NULL,
+	/* dependsOnNormals */  dependsOnNormals,
+	/* foreachObjectLink */ NULL,
+	/* foreachIDLink */     NULL,
+	/* foreachTexLink */    NULL,
+};