Fix indentation, spacing and added comments

7 files changed, 72 insertions, 40 deletions

diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c
index 4059cf27f23..292453fac4b 100644
--- a/source/blender/bmesh/intern/bmesh_mesh.c
+++ b/source/blender/bmesh/intern/bmesh_mesh.c
@@ -1114,9 +1114,10 @@ void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all)
 
 				/* 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) &&
+				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) {
@@ -1125,9 +1126,10 @@ void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all)
 					BLI_BITMAP_ENABLE(done_verts, BM_elem_index_get(l_prev->v));
 				}
 
-				if (!BM_elem_flag_test(l->next->v, BM_ELEM_SELECT) &&
+				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) {
@@ -1172,7 +1174,8 @@ void BM_lnorspace_rebuild(BMesh *bm, bool 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_data_to_normal(bm->lnor_spacearr->lspacearr[l_index], *clnor, oldnors[l_index]);
+					BKE_lnor_space_custom_data_to_normal(bm->lnor_spacearr->lspacearr[l_index], *clnor,
+														 oldnors[l_index]);
 				}
 			}
 		}
@@ -1191,7 +1194,8 @@ void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
 				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);
+					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);
 			}
@@ -1398,7 +1402,8 @@ BMLoopNorEditDataArray *BM_loop_normal_editdata_array_init(BMesh *bm)
 	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__);
+	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);
diff --git a/source/blender/bmesh/operators/bmo_bevel.c b/source/blender/bmesh/operators/bmo_bevel.c
index 9d956c26390..eb299dbba60 100644
--- a/source/blender/bmesh/operators/bmo_bevel.c
+++ b/source/blender/bmesh/operators/bmo_bevel.c
@@ -66,7 +66,8 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
 			}
 		}
 
-		BM_mesh_bevel(bm, offset, offset_type, seg, profile, vonly, false, clamp_overlap, NULL, -1, material, loop_slide, mark_seam, mark_sharp, hnmode, op);
+		BM_mesh_bevel(bm, offset, offset_type, seg, profile, vonly, false, clamp_overlap, NULL, -1, material,
+					  loop_slide, mark_seam, mark_sharp, hnmode, op);
 
 		BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faces.out", BM_FACE, BM_ELEM_TAG);
 		BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "edges.out", BM_EDGE, BM_ELEM_TAG);
diff --git a/source/blender/bmesh/tools/bmesh_bevel.c b/source/blender/bmesh/tools/bmesh_bevel.c
index 79310deef2a..b45c9e295ab 100644
--- a/source/blender/bmesh/tools/bmesh_bevel.c
+++ b/source/blender/bmesh/tools/bmesh_bevel.c
@@ -1554,16 +1554,19 @@ static void check_edge_data_seam_sharp_edges(BevVert *bv, int flag, bool neg)
 		int flag_count = 0;
 		EdgeHalf *ne = e->next;
 		
-		while ((!neg && !BEV_EXTEND_EDGE_DATA_CHECK(ne, flag) || (neg && BEV_EXTEND_EDGE_DATA_CHECK(ne, flag))) && ne != efirst) {
+		while ((!neg && !BEV_EXTEND_EDGE_DATA_CHECK(ne, flag) || (neg && BEV_EXTEND_EDGE_DATA_CHECK(ne, flag))) &&
+				ne != efirst)
+		{
 			if (ne->is_bev)
 				flag_count++;
 			ne = ne->next;
 		}
 		if (ne == e || (ne == efirst && (!neg && !BEV_EXTEND_EDGE_DATA_CHECK(efirst, flag) ||
-										(neg && BEV_EXTEND_EDGE_DATA_CHECK(efirst, flag))))) {
+										(neg && BEV_EXTEND_EDGE_DATA_CHECK(efirst, flag)))))
+		{
 			break;
 		}
- 		if (flag == BM_ELEM_SEAM)				/* Set seam_len / sharp_len of starting edge */
+		if (flag == BM_ELEM_SEAM)				/* Set seam_len / sharp_len of starting edge */
 			e->rightv->seam_len = flag_count;
 		else if (flag == BM_ELEM_SMOOTH)
 			e->rightv->sharp_len = flag_count;
@@ -1687,7 +1690,7 @@ static void bevel_harden_normals_mode(BMesh *bm, BevelParams *bp, BevVert *bv, B
 				BMFace *f_a, *f_b;
 				BM_edge_face_pair(e, &f_a, &f_b);
 
-				if(f_a && !BLI_ghash_haskey(tempfaceHash, SET_UINT_IN_POINTER(BM_elem_index_get(f_a)))) {
+				if (f_a && !BLI_ghash_haskey(tempfaceHash, SET_UINT_IN_POINTER(BM_elem_index_get(f_a)))) {
 					int f_area = BM_face_calc_area(f_a);
 					float f_no[3];
 					copy_v3_v3(f_no, f_a->no);
@@ -1695,7 +1698,7 @@ static void bevel_harden_normals_mode(BMesh *bm, BevelParams *bp, BevVert *bv, B
 					add_v3_v3(n_final, f_no);
 					BLI_ghash_insert(tempfaceHash, SET_UINT_IN_POINTER(BM_elem_index_get(f_a)), NULL);
 				}
-				if(f_b && !BLI_ghash_haskey(tempfaceHash, SET_UINT_IN_POINTER(BM_elem_index_get(f_b)))) {
+				if (f_b && !BLI_ghash_haskey(tempfaceHash, SET_UINT_IN_POINTER(BM_elem_index_get(f_b)))) {
 					int f_area = BM_face_calc_area(f_b);
 					float f_no[3];
 					copy_v3_v3(f_no, f_b->no);
@@ -3794,7 +3797,7 @@ static void bevel_build_rings(BevelParams *bp, BMesh *bm, BevVert *bv)
 						                   NULL, bme1, bme2, bme3, mat_nr);
 					}
 				}
-				if(do_fix_shading_bv)
+				if (do_fix_shading_bv)
 					BLI_ghash_insert(bp->faceHash, r_f, NULL);
 			}
 		}
diff --git a/source/blender/editors/mesh/editmesh_bevel.c b/source/blender/editors/mesh/editmesh_bevel.c
index 442eef927af..931e395736f 100644
--- a/source/blender/editors/mesh/editmesh_bevel.c
+++ b/source/blender/editors/mesh/editmesh_bevel.c
@@ -153,7 +153,8 @@ static void bevel_harden_normals(BMEditMesh *em, BMOperator *bmop, float face_st
 	BM_ITER_MESH(f, &fiter, bm, BM_FACES_OF_MESH) {
 		l_cur = l_first = BM_FACE_FIRST_LOOP(f);
 		do {
-			if (BM_elem_flag_test(l_cur->v, BM_ELEM_SELECT) && (!BM_elem_flag_test(l_cur->e, BM_ELEM_TAG) ||
+			if ((BM_elem_flag_test(l_cur->v, BM_ELEM_SELECT)) &&
+				((!BM_elem_flag_test(l_cur->e, BM_ELEM_TAG)) ||
 				(!BM_elem_flag_test(l_cur, BM_ELEM_TAG) && BM_loop_check_cyclic_smooth_fan(l_cur))))
 			{
 				/* Both adjacent loops are sharp, set clnor to face normal */
@@ -191,7 +192,7 @@ static void bevel_harden_normals(BMEditMesh *em, BMOperator *bmop, float face_st
 						mul_v3_v3fl(cur, lfan_pivot->f->no, BM_face_calc_area(lfan_pivot->f));
 						add_v3_v3(cn_wght, cur);
 
-						if(BM_elem_flag_test(lfan_pivot->f, BM_ELEM_SELECT))
+						if (BM_elem_flag_test(lfan_pivot->f, BM_ELEM_SELECT))
 							add_v3_v3(cn_unwght, cur);
 
 						if (!BM_elem_flag_test(e_next, BM_ELEM_TAG) || (e_next == e_org)) {
@@ -215,7 +216,8 @@ static void bevel_harden_normals(BMEditMesh *em, BMOperator *bmop, float face_st
 							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], calc_n, clnors);
 						}
 						else
-							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], cn_unwght, clnors);
+							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], cn_unwght,
+																 clnors);
 					}
 					BLI_ghash_remove(nslot->data.ghash, v_pivot, NULL, MEM_freeN);
 				}
@@ -347,7 +349,7 @@ static bool edbm_bevel_calc(wmOperator *op)
 			BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
 		}
 
-		if(hnmode != BEVEL_HN_NONE)
+		if (hnmode != BEVEL_HN_NONE)
 			bevel_harden_normals(em, &bmop, hn_strength, hnmode);
 
 		/* no need to de-select existing geometry */
@@ -794,6 +796,8 @@ void MESH_OT_bevel(wmOperatorType *ot)
 	RNA_def_boolean(ot->srna, "mark_sharp", false, "Mark Sharp", "Mark beveled edges as sharp");
 	RNA_def_int(ot->srna, "material", -1, -1, INT_MAX, "Material",
 		"Material for bevel faces (-1 means use adjacent faces)", -1, 100);
-	RNA_def_float(ot->srna, "strength", 0.5f, 0.0f, 1.0f, "Normal Strength", "Strength of calculated normal", 0.0f, 1.0f);
-	RNA_def_enum(ot->srna, "hnmode", harden_normals_items, BEVEL_HN_NONE, "Normal Mode", "Weighting mode for Harden Normals");
+	RNA_def_float(ot->srna, "strength", 0.5f, 0.0f, 1.0f, "Normal Strength",
+		"Strength of calculated normal", 0.0f, 1.0f);
+	RNA_def_enum(ot->srna, "hnmode", harden_normals_items, BEVEL_HN_NONE, "Normal Mode",
+		"Weighting mode for Harden Normals");
 }
diff --git a/source/blender/editors/mesh/editmesh_tools.c b/source/blender/editors/mesh/editmesh_tools.c
index d327e270a35..d94d3051b50 100644
--- a/source/blender/editors/mesh/editmesh_tools.c
+++ b/source/blender/editors/mesh/editmesh_tools.c
@@ -7063,7 +7063,8 @@ static void point_normals_update_header(bContext *C, wmOperator *op)
 	             WM_MODALKEY(EDBM_CLNOR_MODAL_POINTTO_RESET), WM_MODALKEY(EDBM_CLNOR_MODAL_POINTTO_SET_USE_3DCURSOR),
 	             WM_MODALKEY(EDBM_CLNOR_MODAL_POINTTO_SET_USE_SELECTED),
 	             WM_MODALKEY(EDBM_CLNOR_MODAL_POINTTO_INVERT), WM_bool_as_string(RNA_boolean_get(op->ptr, "invert")),
-	             WM_MODALKEY(EDBM_CLNOR_MODAL_POINTTO_SPHERIZE), WM_bool_as_string(RNA_boolean_get(op->ptr, "spherize")),
+	             WM_MODALKEY(EDBM_CLNOR_MODAL_POINTTO_SPHERIZE), 
+				 WM_bool_as_string(RNA_boolean_get(op->ptr, "spherize")),
 	             WM_MODALKEY(EDBM_CLNOR_MODAL_POINTTO_ALIGN), WM_bool_as_string(RNA_boolean_get(op->ptr, "align")));
 
 #undef WM_MODALKEY
@@ -8063,7 +8064,8 @@ static int edbm_set_normals_from_faces_exec(bContext *C, wmOperator *op)
 				if (BLI_BITMAP_TEST(loop_set, BM_elem_index_get(l))) {
 					const int loop_index = BM_elem_index_get(l);
 					short *clnors = BM_ELEM_CD_GET_VOID_P(l, cd_clnors_offset);
-					BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[loop_index], vnors[v_index], clnors);
+					BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[loop_index], vnors[v_index],
+														 clnors);
 				}
 			}
 		}
diff --git a/source/blender/modifiers/intern/MOD_bevel.c b/source/blender/modifiers/intern/MOD_bevel.c
index 152fee9eb77..f1dc73436ee 100644
--- a/source/blender/modifiers/intern/MOD_bevel.c
+++ b/source/blender/modifiers/intern/MOD_bevel.c
@@ -110,7 +110,9 @@ static void bevel_set_weighted_normal_face_strength(BMesh *bm, Scene *scene)
 	}
 }
 
-static void bevel_mod_harden_normals(BevelModifierData *bmd, BMesh *bm, const float hn_strength, const int hnmode, MDeformVert *dvert, int vgroup)
+static void bevel_mod_harden_normals(
+			BevelModifierData *bmd, BMesh *bm, const float hn_strength,
+			const int hnmode, MDeformVert *dvert, int vgroup)
 {
 	if (bmd->res > 20 || bmd->value == 0)
 		return;
@@ -128,13 +130,16 @@ static void bevel_mod_harden_normals(BevelModifierData *bmd, BMesh *bm, const fl
 	BMIter fiter;
 	GHash *faceHash = bmd->clnordata.faceHash;
 
+	/* Iterate throught all loops of a face */
 	BM_ITER_MESH(f, &fiter, bm, BM_FACES_OF_MESH) {
 
 		l_cur = l_first = BM_FACE_FIRST_LOOP(f);
 		do {
-			if ((!BM_elem_flag_test(l_cur->e, BM_ELEM_TAG) || (!BM_elem_flag_test(l_cur, BM_ELEM_TAG) &&
-				BM_loop_check_cyclic_smooth_fan(l_cur)))) {
+			if ((!BM_elem_flag_test(l_cur->e, BM_ELEM_TAG)) ||
+				(!BM_elem_flag_test(l_cur, BM_ELEM_TAG) && BM_loop_check_cyclic_smooth_fan(l_cur)))
+			{
 
+				/* previous and next edge is sharp, accumulate face normals into loop */
 				if (!BM_elem_flag_test(l_cur->e, BM_ELEM_TAG) && !BM_elem_flag_test(l_cur->prev->e, BM_ELEM_TAG)) {
 					const int loop_index = BM_elem_index_get(l_cur);
 					short *clnors = BM_ELEM_CD_GET_VOID_P(l_cur, cd_clnors_offset);
@@ -151,8 +156,8 @@ static void bevel_mod_harden_normals(BevelModifierData *bmd, BMesh *bm, const fl
 					e_next = lfan_pivot->e;
 					BLI_SMALLSTACK_DECLARE(loops, BMLoop *);
 					float cn_wght[3] = { 0.0f, 0.0f, 0.0f };
-					int recon_face_count = 0;					/* Reconstructed face */
-					BMFace *recon_face = NULL;
+					int recon_face_count = 0;		/* Counts number of reconstructed faces current vert is connected to */
+					BMFace *recon_face = NULL;		/* Reconstructed face */
 
 					while (true) {
 						lfan_pivot_next = BM_vert_step_fan_loop(lfan_pivot, &e_next);
@@ -169,12 +174,12 @@ static void bevel_mod_harden_normals(BevelModifierData *bmd, BMesh *bm, const fl
 							int weight = BM_elem_float_data_get(&bm->edata, lfan_pivot->f, CD_BWEIGHT);
 							if (weight) {
 								if (hnmode == MOD_BEVEL_HN_FACE) {
-									float cur[3];
+									float cur[3];					//Add area weighted face normals
 									mul_v3_v3fl(cur, lfan_pivot->f->no, BM_face_calc_area(lfan_pivot->f));
 									add_v3_v3(cn_wght, cur);
 								}
 								else
-									add_v3_v3(cn_wght, lfan_pivot->f->no);
+									add_v3_v3(cn_wght, lfan_pivot->f->no);		//Else simply add face normals
 							}
 							else
 								add_v3_v3(cn_wght, lfan_pivot->f->no);
@@ -182,7 +187,9 @@ static void bevel_mod_harden_normals(BevelModifierData *bmd, BMesh *bm, const fl
 						}
 						else if (bmd->lim_flags & MOD_BEVEL_VGROUP) {
 							const bool has_vgroup = dvert != NULL;
-							const bool vert_of_group = has_vgroup && defvert_find_index(&dvert[BM_elem_index_get(l->v)], vgroup) != NULL;
+							const bool vert_of_group = has_vgroup &&
+									   (defvert_find_index(&dvert[BM_elem_index_get(l->v)], vgroup) != NULL);
+
 							if (vert_of_group && hnmode == MOD_BEVEL_HN_FACE) {
 								float cur[3];
 								mul_v3_v3fl(cur, lfan_pivot->f->no, BM_face_calc_area(lfan_pivot->f));
@@ -214,18 +221,22 @@ static void bevel_mod_harden_normals(BevelModifierData *bmd, BMesh *bm, const fl
 						const int l_index = BM_elem_index_get(l);
 						short *clnors = BM_ELEM_CD_GET_VOID_P(l, cd_clnors_offset);
 
+						/* If vertex is edge vert with 1 reconnected face */
 						if (recon_face_count == 1 || do_normal_to_recon) {
-							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], recon_face->no, clnors);
+							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], recon_face->no,
+																 clnors);
 						}
 						else if (vertex_only == false || recon_face_count == 0) {
 							copy_v3_v3(n_final, l->f->no);
 							mul_v3_fl(n_final, 1.0f - hn_strength);
 							add_v3_v3(n_final, cn_wght);
 							normalize_v3(n_final);
-							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], n_final, clnors);
+							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], n_final,
+																 clnors);
 						}
-						else if(BLI_ghash_haskey(faceHash, l->f))
-							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], l->v->no, clnors);
+						else if (BLI_ghash_haskey(faceHash, l->f))
+							BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], l->v->no,
+																 clnors);
 					}
 				}
 			}
@@ -261,6 +272,8 @@ static void bevel_fix_normal_shading_continuity(BevelModifierData *bmd, BMesh *b
 		if (f_b)
 			has_f_b = BLI_ghash_haskey(faceHash, f_b);
 		if (has_f_a ^ has_f_b) {
+		/* If one of both faces is present in faceHash then we are at a border
+		*  between new vmesh created and reconstructed face */
 
 			for (int i = 0; i < 2; i++) {
 				BMVert *v = (i == 0) ? e->v1 : e->v2;
@@ -291,12 +304,14 @@ static void bevel_fix_normal_shading_continuity(BevelModifierData *bmd, BMesh *b
 				}
 			}
 		}
-		else if(has_f_a == true  && has_f_b == true) {
+		else if (has_f_a == true  && has_f_b == true) {
+		/* Else if both faces are present we assign clnor corresponding
+		*  to vert normal and face normal */
 			for (int i = 0; i < 2; i++) {
 				BMVert *v = (i == 0) ? e->v1 : e->v2;
 				BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
 
-					if(l->f == f_a || l->f == f_b) {
+					if (l->f == f_a || l->f == f_b) {
 						const int l_index = BM_elem_index_get(l);
 						short *clnors = BM_ELEM_CD_GET_VOID_P(l, cd_clnors_offset);
 						float n_final[3], cn_wght[3];
@@ -417,9 +432,9 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
 	if (bmd->hnmode != BEVEL_HN_FIX_SHA && bmd->hnmode != MOD_BEVEL_HN_NONE) {
 		bevel_mod_harden_normals(bmd, bm, bmd->hn_strength, bmd->hnmode, dvert, vgroup);
 	}
-	if(bmd->hnmode == BEVEL_HN_FIX_SHA)
+	if (bmd->hnmode == BEVEL_HN_FIX_SHA)
 		bevel_fix_normal_shading_continuity(bmd, bm);
-	if(set_wn_strength)
+	if (set_wn_strength)
 		bevel_set_weighted_normal_face_strength(bm, scene);
 
 	result = BKE_bmesh_to_mesh_nomain(bm, &(struct BMeshToMeshParams){0});
@@ -429,7 +444,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
 	           bm->ftoolflagpool == NULL);  /* make sure we never alloc'd these */
 	BM_mesh_free(bm);
 
-	if(bmd->clnordata.faceHash)
+	if (bmd->clnordata.faceHash)
 		BLI_ghash_free(bmd->clnordata.faceHash, NULL, NULL);
 
 	result->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
@@ -450,7 +465,7 @@ ModifierTypeInfo modifierType_Bevel = {
 	/* flags */             eModifierTypeFlag_AcceptsMesh |
 	                        eModifierTypeFlag_SupportsEditmode |
 	                        eModifierTypeFlag_EnableInEditmode |
-							eModifierTypeFlag_AcceptsCVs,
+	                        eModifierTypeFlag_AcceptsCVs,
 	
 	/* copyData */          modifier_copyData_generic,
 
diff --git a/source/blender/modifiers/intern/MOD_weighted_normal.c b/source/blender/modifiers/intern/MOD_weighted_normal.c
index a2ace1aadc4..3e788db9c00 100644
--- a/source/blender/modifiers/intern/MOD_weighted_normal.c
+++ b/source/blender/modifiers/intern/MOD_weighted_normal.c
@@ -217,7 +217,8 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd, Weight
 		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). */
+		/* 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;
@@ -572,7 +573,8 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
 
 	    .mpoly = mpoly,
 	    .polynors = polynors,
-	    .poly_strength = CustomData_get_layer_named(&result->pdata, CD_PROP_INT, MOD_WEIGHTEDNORMALS_FACEWEIGHT_CDLAYER_ID),
+	    .poly_strength = CustomData_get_layer_named(&result->pdata, CD_PROP_INT,
+													MOD_WEIGHTEDNORMALS_FACEWEIGHT_CDLAYER_ID),
 
 	    .dvert = dvert,
 	    .defgrp_index = defgrp_index,