ClangFormat: apply to source, most of intern
[blender.git] / source / blender / blenkernel / BKE_mesh.h
index a2613c2..e89e1b0 100644 (file)
@@ -75,46 +75,53 @@ extern "C" {
 
 /* *** mesh.c *** */
 
-struct BMesh *BKE_mesh_to_bmesh_ex(
-        const struct Mesh *me,
-        const struct BMeshCreateParams *create_params,
-        const struct BMeshFromMeshParams *convert_params);
-struct BMesh *BKE_mesh_to_bmesh(
-        struct Mesh *me, struct Object *ob,
-        const bool add_key_index, const struct BMeshCreateParams *params);
+struct BMesh *BKE_mesh_to_bmesh_ex(const struct Mesh *me,
+                                   const struct BMeshCreateParams *create_params,
+                                   const struct BMeshFromMeshParams *convert_params);
+struct BMesh *BKE_mesh_to_bmesh(struct Mesh *me,
+                                struct Object *ob,
+                                const bool add_key_index,
+                                const struct BMeshCreateParams *params);
 
 struct Mesh *BKE_mesh_from_bmesh_nomain(struct BMesh *bm, const struct BMeshToMeshParams *params);
-struct Mesh *BKE_mesh_from_bmesh_for_eval_nomain(struct BMesh *bm, const struct CustomData_MeshMasks *cd_mask_extra);
+struct Mesh *BKE_mesh_from_bmesh_for_eval_nomain(struct BMesh *bm,
+                                                 const struct CustomData_MeshMasks *cd_mask_extra);
 
 struct Mesh *BKE_mesh_from_editmesh_with_coords_thin_wrap(
-        struct BMEditMesh *em, const struct CustomData_MeshMasks *data_mask, float (*vertexCos)[3]);
+    struct BMEditMesh *em, const struct CustomData_MeshMasks *data_mask, float (*vertexCos)[3]);
 
-int poly_find_loop_from_vert(
-        const struct MPoly *poly,
-        const struct MLoop *loopstart, unsigned vert);
-int poly_get_adj_loops_from_vert(
-        const struct MPoly *poly,
-        const struct MLoop *mloop, unsigned int vert,
-        unsigned int r_adj[2]);
+int poly_find_loop_from_vert(const struct MPoly *poly,
+                             const struct MLoop *loopstart,
+                             unsigned vert);
+int poly_get_adj_loops_from_vert(const struct MPoly *poly,
+                                 const struct MLoop *mloop,
+                                 unsigned int vert,
+                                 unsigned int r_adj[2]);
 
 int BKE_mesh_edge_other_vert(const struct MEdge *e, int v);
-void BKE_mesh_looptri_get_real_edges(const struct Mesh *mesh, const struct MLoopTri *looptri, int r_edges[3]);
+void BKE_mesh_looptri_get_real_edges(const struct Mesh *mesh,
+                                     const struct MLoopTri *looptri,
+                                     int r_edges[3]);
 
 void BKE_mesh_free(struct Mesh *me);
 void BKE_mesh_init(struct Mesh *me);
 struct Mesh *BKE_mesh_add(struct Main *bmain, const char *name);
-void BKE_mesh_copy_data(struct Main *bmain, struct Mesh *me_dst, const struct Mesh *me_src, const int flag);
+void BKE_mesh_copy_data(struct Main *bmain,
+                        struct Mesh *me_dst,
+                        const struct Mesh *me_src,
+                        const int flag);
 struct Mesh *BKE_mesh_copy(struct Main *bmain, const struct Mesh *me);
 void BKE_mesh_update_customdata_pointers(struct Mesh *me, const bool do_ensure_tess_cd);
 void BKE_mesh_ensure_skin_customdata(struct Mesh *me);
 
 struct Mesh *BKE_mesh_new_nomain(
-        int verts_len, int edges_len, int tessface_len,
-        int loops_len, int polys_len);
-struct Mesh *BKE_mesh_new_nomain_from_template(
-        const struct Mesh *me_src,
-        int verts_len, int edges_len, int tessface_len,
-        int loops_len, int polys_len);
+    int verts_len, int edges_len, int tessface_len, int loops_len, int polys_len);
+struct Mesh *BKE_mesh_new_nomain_from_template(const struct Mesh *me_src,
+                                               int verts_len,
+                                               int edges_len,
+                                               int tessface_len,
+                                               int loops_len,
+                                               int polys_len);
 
 /* Performs copy for use during evaluation, optional referencing original arrays to reduce memory. */
 struct Mesh *BKE_mesh_copy_for_eval(struct Mesh *source, bool reference);
@@ -130,26 +137,45 @@ void BKE_mesh_make_local(struct Main *bmain, struct Mesh *me, const bool lib_loc
 void BKE_mesh_boundbox_calc(struct Mesh *me, float r_loc[3], float r_size[3]);
 void BKE_mesh_texspace_calc(struct Mesh *me);
 float (*BKE_mesh_orco_verts_get(struct Object *ob))[3];
-void   BKE_mesh_orco_verts_transform(struct Mesh *me, float (*orco)[3], int totvert, int invert);
+void BKE_mesh_orco_verts_transform(struct Mesh *me, float (*orco)[3], int totvert, int invert);
 int test_index_face(struct MFace *mface, struct CustomData *mfdata, int mfindex, int nr);
 struct Mesh *BKE_mesh_from_object(struct Object *ob);
 void BKE_mesh_assign_object(struct Main *bmain, struct Object *ob, struct Mesh *me);
 void BKE_mesh_from_metaball(struct ListBase *lb, struct Mesh *me);
-int  BKE_mesh_nurbs_to_mdata(
-        struct Object *ob, struct MVert **r_allvert, int *r_totvert,
-        struct MEdge **r_alledge, int *r_totedge, struct MLoop **r_allloop, struct MPoly **r_allpoly,
-        int *r_totloop, int *r_totpoly);
-int BKE_mesh_nurbs_displist_to_mdata(
-        struct Object *ob, const struct ListBase *dispbase,
-        struct MVert **r_allvert, int *r_totvert,
-        struct MEdge **r_alledge, int *r_totedge,
-        struct MLoop **r_allloop, struct MPoly **r_allpoly,
-        struct MLoopUV **r_alluv, int *r_totloop, int *r_totpoly);
-void BKE_mesh_from_nurbs_displist(
-        struct Main *bmain, struct Object *ob, struct ListBase *dispbase, const bool use_orco_uv, const char *obdata_name, bool temporary);
+int BKE_mesh_nurbs_to_mdata(struct Object *ob,
+                            struct MVert **r_allvert,
+                            int *r_totvert,
+                            struct MEdge **r_alledge,
+                            int *r_totedge,
+                            struct MLoop **r_allloop,
+                            struct MPoly **r_allpoly,
+                            int *r_totloop,
+                            int *r_totpoly);
+int BKE_mesh_nurbs_displist_to_mdata(struct Object *ob,
+                                     const struct ListBase *dispbase,
+                                     struct MVert **r_allvert,
+                                     int *r_totvert,
+                                     struct MEdge **r_alledge,
+                                     int *r_totedge,
+                                     struct MLoop **r_allloop,
+                                     struct MPoly **r_allpoly,
+                                     struct MLoopUV **r_alluv,
+                                     int *r_totloop,
+                                     int *r_totpoly);
+void BKE_mesh_from_nurbs_displist(struct Main *bmain,
+                                  struct Object *ob,
+                                  struct ListBase *dispbase,
+                                  const bool use_orco_uv,
+                                  const char *obdata_name,
+                                  bool temporary);
 void BKE_mesh_from_nurbs(struct Main *bmain, struct Object *ob);
-void BKE_mesh_to_curve_nurblist(const struct Mesh *me, struct ListBase *nurblist, const int edge_users_test);
-void BKE_mesh_to_curve(struct Main *bmain, struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob);
+void BKE_mesh_to_curve_nurblist(const struct Mesh *me,
+                                struct ListBase *nurblist,
+                                const int edge_users_test);
+void BKE_mesh_to_curve(struct Main *bmain,
+                       struct Depsgraph *depsgraph,
+                       struct Scene *scene,
+                       struct Object *ob);
 void BKE_mesh_material_index_remove(struct Mesh *me, short index);
 void BKE_mesh_material_index_clear(struct Mesh *me);
 void BKE_mesh_material_remap(struct Mesh *me, const unsigned int *remap, unsigned int remap_len);
@@ -158,32 +184,48 @@ void BKE_mesh_smooth_flag_set(struct Object *meshOb, int enableSmooth);
 const char *BKE_mesh_cmp(struct Mesh *me1, struct Mesh *me2, float thresh);
 
 struct BoundBox *BKE_mesh_boundbox_get(struct Object *ob);
-struct BoundBox *BKE_mesh_texspace_get(struct Mesh *me, float r_loc[3], float r_rot[3], float r_size[3]);
-void BKE_mesh_texspace_get_reference(struct Mesh *me, short **r_texflag,  float **r_loc, float **r_rot, float **r_size);
+struct BoundBox *BKE_mesh_texspace_get(struct Mesh *me,
+                                       float r_loc[3],
+                                       float r_rot[3],
+                                       float r_size[3]);
+void BKE_mesh_texspace_get_reference(
+    struct Mesh *me, short **r_texflag, float **r_loc, float **r_rot, float **r_size);
 void BKE_mesh_texspace_copy_from_object(struct Mesh *me, struct Object *ob);
 
-bool BKE_mesh_uv_cdlayer_rename_index(
-        struct Mesh *me, const int loop_index, const int face_index,
-        const char *new_name, const bool do_tessface);
-bool BKE_mesh_uv_cdlayer_rename(struct Mesh *me, const char *old_name, const char *new_name, bool do_tessface);
+bool BKE_mesh_uv_cdlayer_rename_index(struct Mesh *me,
+                                      const int loop_index,
+                                      const int face_index,
+                                      const char *new_name,
+                                      const bool do_tessface);
+bool BKE_mesh_uv_cdlayer_rename(struct Mesh *me,
+                                const char *old_name,
+                                const char *new_name,
+                                bool do_tessface);
 
 float (*BKE_mesh_vertexCos_get(const struct Mesh *me, int *r_numVerts))[3];
 
 void BKE_mesh_split_faces(struct Mesh *mesh, bool free_loop_normals);
 
-struct Mesh *BKE_mesh_new_from_object(
-        struct Depsgraph *depsgraph, struct Main *bmain, struct Scene *sce, struct Object *ob,
-        const bool apply_modifiers, const bool calc_undeformed);
-struct Mesh *BKE_mesh_create_derived_for_modifier(
-        struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob,
-        struct ModifierData *md, int build_shapekey_layers);
+struct Mesh *BKE_mesh_new_from_object(struct Depsgraph *depsgraph,
+                                      struct Main *bmain,
+                                      struct Scene *sce,
+                                      struct Object *ob,
+                                      const bool apply_modifiers,
+                                      const bool calc_undeformed);
+struct Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
+                                                  struct Scene *scene,
+                                                  struct Object *ob,
+                                                  struct ModifierData *md,
+                                                  int build_shapekey_layers);
 
 /* Copies a nomain-Mesh into an existing Mesh. */
-void BKE_mesh_nomain_to_mesh(struct Mesh *mesh_src, struct Mesh *mesh_dst, struct Object *ob,
-                             const struct CustomData_MeshMasks *mask, bool take_ownership);
+void BKE_mesh_nomain_to_mesh(struct Mesh *mesh_src,
+                             struct Mesh *mesh_dst,
+                             struct Object *ob,
+                             const struct CustomData_MeshMasks *mask,
+                             bool take_ownership);
 void BKE_mesh_nomain_to_meshkey(struct Mesh *mesh_src, struct Mesh *mesh_dst, struct KeyBlock *kb);
 
-
 /* vertex level transformations & checks (no derived mesh) */
 
 bool BKE_mesh_minmax(const struct Mesh *me, float r_min[3], float r_max[3]);
@@ -198,11 +240,10 @@ void BKE_mesh_tessface_clear(struct Mesh *mesh);
 
 void BKE_mesh_do_versions_cd_flag_init(struct Mesh *mesh);
 
-
 void BKE_mesh_mselect_clear(struct Mesh *me);
 void BKE_mesh_mselect_validate(struct Mesh *me);
-int  BKE_mesh_mselect_find(struct Mesh *me, int index, int type);
-int  BKE_mesh_mselect_active_get(struct Mesh *me, int type);
+int BKE_mesh_mselect_find(struct Mesh *me, int index, int type);
+int BKE_mesh_mselect_active_get(struct Mesh *me, int type);
 void BKE_mesh_mselect_active_set(struct Mesh *me, int index, int type);
 
 void BKE_mesh_count_selected_items(const struct Mesh *mesh, int r_count[3]);
@@ -210,266 +251,369 @@ void BKE_mesh_count_selected_items(const struct Mesh *mesh, int r_count[3]);
 void BKE_mesh_apply_vert_coords(struct Mesh *mesh, float (*vertCoords)[3]);
 void BKE_mesh_apply_vert_normals(struct Mesh *mesh, short (*vertNormals)[3]);
 
-
 /* *** mesh_evaluate.c *** */
 
 void BKE_mesh_calc_normals_mapping_simple(struct Mesh *me);
-void BKE_mesh_calc_normals_mapping(
-        struct MVert *mverts, int numVerts,
-        const struct MLoop *mloop, const struct MPoly *mpolys, int numLoops, int numPolys, float (*r_polyNors)[3],
-        const struct MFace *mfaces, int numFaces, const int *origIndexFace, float (*r_faceNors)[3]);
-void BKE_mesh_calc_normals_mapping_ex(
-        struct MVert *mverts, int numVerts,
-        const struct MLoop *mloop, const struct MPoly *mpolys,
-        int numLoops, int numPolys, float (*r_polyNors)[3],
-        const struct MFace *mfaces, int numFaces, const int *origIndexFace, float (*r_faceNors)[3],
-        const bool only_face_normals);
-void BKE_mesh_calc_normals_poly(
-        struct MVert *mverts, float (*r_vertnors)[3], int numVerts,
-        const struct MLoop *mloop, const struct MPoly *mpolys,
-        int numLoops, int numPolys, float (*r_polyNors)[3],
-        const bool only_face_normals);
+void BKE_mesh_calc_normals_mapping(struct MVert *mverts,
+                                   int numVerts,
+                                   const struct MLoop *mloop,
+                                   const struct MPoly *mpolys,
+                                   int numLoops,
+                                   int numPolys,
+                                   float (*r_polyNors)[3],
+                                   const struct MFace *mfaces,
+                                   int numFaces,
+                                   const int *origIndexFace,
+                                   float (*r_faceNors)[3]);
+void BKE_mesh_calc_normals_mapping_ex(struct MVert *mverts,
+                                      int numVerts,
+                                      const struct MLoop *mloop,
+                                      const struct MPoly *mpolys,
+                                      int numLoops,
+                                      int numPolys,
+                                      float (*r_polyNors)[3],
+                                      const struct MFace *mfaces,
+                                      int numFaces,
+                                      const int *origIndexFace,
+                                      float (*r_faceNors)[3],
+                                      const bool only_face_normals);
+void BKE_mesh_calc_normals_poly(struct MVert *mverts,
+                                float (*r_vertnors)[3],
+                                int numVerts,
+                                const struct MLoop *mloop,
+                                const struct MPoly *mpolys,
+                                int numLoops,
+                                int numPolys,
+                                float (*r_polyNors)[3],
+                                const bool only_face_normals);
 void BKE_mesh_calc_normals(struct Mesh *me);
 void BKE_mesh_ensure_normals(struct Mesh *me);
 void BKE_mesh_ensure_normals_for_display(struct Mesh *mesh);
-void BKE_mesh_calc_normals_tessface(
-        struct MVert *mverts, int numVerts,
-        const struct MFace *mfaces, int numFaces,
-        float (*r_faceNors)[3]);
-void BKE_mesh_calc_normals_looptri(
-        struct MVert *mverts, int numVerts,
-        const struct MLoop *mloop,
-        const struct MLoopTri *looptri, int looptri_num,
-        float (*r_tri_nors)[3]);
-void BKE_mesh_loop_manifold_fan_around_vert_next(
-        const struct MLoop *mloops, const struct MPoly *mpolys,
-        const int *loop_to_poly, const int *e2lfan_curr, const uint mv_pivot_index,
-        const struct MLoop **r_mlfan_curr, int *r_mlfan_curr_index, int *r_mlfan_vert_index, int *r_mpfan_curr_index);
-
-void BKE_edges_sharp_from_angle_set(
-        const struct MVert *mverts, const int numVerts,
-        struct MEdge *medges, const int numEdges,
-        struct MLoop *mloops, const int numLoops,
-        struct MPoly *mpolys, const float (*polynors)[3], const int numPolys,
-        const float split_angle);
+void BKE_mesh_calc_normals_tessface(struct MVert *mverts,
+                                    int numVerts,
+                                    const struct MFace *mfaces,
+                                    int numFaces,
+                                    float (*r_faceNors)[3]);
+void BKE_mesh_calc_normals_looptri(struct MVert *mverts,
+                                   int numVerts,
+                                   const struct MLoop *mloop,
+                                   const struct MLoopTri *looptri,
+                                   int looptri_num,
+                                   float (*r_tri_nors)[3]);
+void BKE_mesh_loop_manifold_fan_around_vert_next(const struct MLoop *mloops,
+                                                 const struct MPoly *mpolys,
+                                                 const int *loop_to_poly,
+                                                 const int *e2lfan_curr,
+                                                 const uint mv_pivot_index,
+                                                 const struct MLoop **r_mlfan_curr,
+                                                 int *r_mlfan_curr_index,
+                                                 int *r_mlfan_vert_index,
+                                                 int *r_mpfan_curr_index);
+
+void BKE_edges_sharp_from_angle_set(const struct MVert *mverts,
+                                    const int numVerts,
+                                    struct MEdge *medges,
+                                    const int numEdges,
+                                    struct MLoop *mloops,
+                                    const int numLoops,
+                                    struct MPoly *mpolys,
+                                    const float (*polynors)[3],
+                                    const int numPolys,
+                                    const float split_angle);
 
 /**
  * References a contiguous loop-fan with normal offset vars.
  */
 typedef struct MLoopNorSpace {
-       float vec_lnor[3];      /* Automatically computed loop normal. */
-       float vec_ref[3];       /* Reference vector, orthogonal to vec_lnor. */
-       float vec_ortho[3];     /* Third vector, orthogonal to vec_lnor and vec_ref. */
-       float ref_alpha;        /* Reference angle, around vec_ortho, in ]0, pi] range (0.0 marks that space as invalid). */
-       float ref_beta;         /* Reference angle, around vec_lnor, in ]0, 2pi] range (0.0 marks that space as invalid). */
-       /* All loops using this lnor space (i.e. smooth fan of loops),
-        * as (depending on owning MLoopNorSpaceArrary.data_type):
-        *     - Indices (uint_in_ptr), or
-        *     - BMLoop pointers. */
-       struct LinkNode *loops;
-       char flags;
-
-       void *user_data;  /* To be used for extended processing related to loop normal spaces (aka smooth fans). */
+  float vec_lnor[3];  /* Automatically computed loop normal. */
+  float vec_ref[3];   /* Reference vector, orthogonal to vec_lnor. */
+  float vec_ortho[3]; /* Third vector, orthogonal to vec_lnor and vec_ref. */
+  float
+      ref_alpha; /* Reference angle, around vec_ortho, in ]0, pi] range (0.0 marks that space as invalid). */
+  float
+      ref_beta; /* Reference angle, around vec_lnor, in ]0, 2pi] range (0.0 marks that space as invalid). */
+  /* All loops using this lnor space (i.e. smooth fan of loops),
+   * as (depending on owning MLoopNorSpaceArrary.data_type):
+   *     - Indices (uint_in_ptr), or
+   *     - 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
  */
 enum {
-       MLNOR_SPACE_IS_SINGLE = 1 << 0,
+  MLNOR_SPACE_IS_SINGLE = 1 << 0,
 };
 
 /**
  * Collection of #MLoopNorSpace basic storage & pre-allocation.
  */
 typedef struct MLoopNorSpaceArray {
-       MLoopNorSpace **lspacearr;    /* MLoop aligned array */
-       struct LinkNode *loops_pool;  /* Allocated once, avoids to call BLI_linklist_prepend_arena() for each loop! */
-       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;
+  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;
 /**
  * MLoopNorSpaceArray.data_type
  */
 enum {
-       MLNOR_SPACEARR_LOOP_INDEX = 0,
-       MLNOR_SPACEARR_BMLOOP_PTR = 1,
+  MLNOR_SPACEARR_LOOP_INDEX = 0,
+  MLNOR_SPACEARR_BMLOOP_PTR = 1,
 };
 
 /* Low-level custom normals functions. */
-void BKE_lnor_spacearr_init(MLoopNorSpaceArray *lnors_spacearr, const int numLoops, const char data_type);
+void BKE_lnor_spacearr_init(MLoopNorSpaceArray *lnors_spacearr,
+                            const int numLoops,
+                            const char data_type);
 void BKE_lnor_spacearr_clear(MLoopNorSpaceArray *lnors_spacearr);
 void BKE_lnor_spacearr_free(MLoopNorSpaceArray *lnors_spacearr);
 MLoopNorSpace *BKE_lnor_space_create(MLoopNorSpaceArray *lnors_spacearr);
-void BKE_lnor_space_define(
-        MLoopNorSpace *lnor_space, const float lnor[3], float vec_ref[3], float vec_other[3],
-        struct BLI_Stack *edge_vectors);
-void BKE_lnor_space_add_loop(
-        MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpace *lnor_space,
-        const int ml_index, void *bm_loop, const bool is_single);
-void BKE_lnor_space_custom_data_to_normal(MLoopNorSpace *lnor_space, const short clnor_data[2], float r_custom_lnor[3]);
-void BKE_lnor_space_custom_normal_to_data(MLoopNorSpace *lnor_space, const float custom_lnor[3], short r_clnor_data[2]);
+void BKE_lnor_space_define(MLoopNorSpace *lnor_space,
+                           const float lnor[3],
+                           float vec_ref[3],
+                           float vec_other[3],
+                           struct BLI_Stack *edge_vectors);
+void BKE_lnor_space_add_loop(MLoopNorSpaceArray *lnors_spacearr,
+                             MLoopNorSpace *lnor_space,
+                             const int ml_index,
+                             void *bm_loop,
+                             const bool is_single);
+void BKE_lnor_space_custom_data_to_normal(MLoopNorSpace *lnor_space,
+                                          const short clnor_data[2],
+                                          float r_custom_lnor[3]);
+void BKE_lnor_space_custom_normal_to_data(MLoopNorSpace *lnor_space,
+                                          const float custom_lnor[3],
+                                          short r_clnor_data[2]);
 
 /* Medium-level custom normals functions. */
-void BKE_mesh_normals_loop_split(
-        const struct MVert *mverts, const int numVerts, struct MEdge *medges, const int numEdges,
-        struct MLoop *mloops, float (*r_loopnors)[3], const int numLoops,
-        struct MPoly *mpolys, const float (*polynors)[3], const int numPolys,
-        const bool use_split_normals, const float split_angle,
-        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2], int *r_loop_to_poly);
-
-void BKE_mesh_normals_loop_custom_set(
-        const struct MVert *mverts, const int numVerts, struct MEdge *medges, const int numEdges,
-        struct MLoop *mloops, float (*r_custom_loopnors)[3], const int numLoops,
-        struct MPoly *mpolys, const float (*polynors)[3], const int numPolys,
-        short (*r_clnors_data)[2]);
-void BKE_mesh_normals_loop_custom_from_vertices_set(
-        const struct MVert *mverts, float (*r_custom_vertnors)[3], const int numVerts,
-        struct MEdge *medges, const int numEdges, struct MLoop *mloops, const int numLoops,
-        struct MPoly *mpolys, const float (*polynors)[3], const int numPolys,
-        short (*r_clnors_data)[2]);
-
-void BKE_mesh_normals_loop_to_vertex(
-        const int numVerts, const struct MLoop *mloops, const int numLoops,
-        const float (*clnors)[3], float (*r_vert_clnors)[3]);
+void BKE_mesh_normals_loop_split(const struct MVert *mverts,
+                                 const int numVerts,
+                                 struct MEdge *medges,
+                                 const int numEdges,
+                                 struct MLoop *mloops,
+                                 float (*r_loopnors)[3],
+                                 const int numLoops,
+                                 struct MPoly *mpolys,
+                                 const float (*polynors)[3],
+                                 const int numPolys,
+                                 const bool use_split_normals,
+                                 const float split_angle,
+                                 MLoopNorSpaceArray *r_lnors_spacearr,
+                                 short (*clnors_data)[2],
+                                 int *r_loop_to_poly);
+
+void BKE_mesh_normals_loop_custom_set(const struct MVert *mverts,
+                                      const int numVerts,
+                                      struct MEdge *medges,
+                                      const int numEdges,
+                                      struct MLoop *mloops,
+                                      float (*r_custom_loopnors)[3],
+                                      const int numLoops,
+                                      struct MPoly *mpolys,
+                                      const float (*polynors)[3],
+                                      const int numPolys,
+                                      short (*r_clnors_data)[2]);
+void BKE_mesh_normals_loop_custom_from_vertices_set(const struct MVert *mverts,
+                                                    float (*r_custom_vertnors)[3],
+                                                    const int numVerts,
+                                                    struct MEdge *medges,
+                                                    const int numEdges,
+                                                    struct MLoop *mloops,
+                                                    const int numLoops,
+                                                    struct MPoly *mpolys,
+                                                    const float (*polynors)[3],
+                                                    const int numPolys,
+                                                    short (*r_clnors_data)[2]);
+
+void BKE_mesh_normals_loop_to_vertex(const int numVerts,
+                                     const struct MLoop *mloops,
+                                     const int numLoops,
+                                     const float (*clnors)[3],
+                                     float (*r_vert_clnors)[3]);
 
 /* High-level custom normals functions. */
 bool BKE_mesh_has_custom_loop_normals(struct Mesh *me);
 
 void BKE_mesh_calc_normals_split(struct Mesh *mesh);
-void BKE_mesh_calc_normals_split_ex(struct Mesh *mesh, struct MLoopNorSpaceArray *r_lnors_spacearr);
+void BKE_mesh_calc_normals_split_ex(struct Mesh *mesh,
+                                    struct MLoopNorSpaceArray *r_lnors_spacearr);
 
 void BKE_mesh_set_custom_normals(struct Mesh *mesh, float (*r_custom_loopnors)[3]);
 void BKE_mesh_set_custom_normals_from_vertices(struct Mesh *mesh, float (*r_custom_vertnors)[3]);
 
-
-void BKE_mesh_calc_poly_normal(
-        const struct MPoly *mpoly, const struct MLoop *loopstart,
-        const struct MVert *mvarray, float r_no[3]);
-void BKE_mesh_calc_poly_normal_coords(
-        const struct MPoly *mpoly, const struct MLoop *loopstart,
-        const float (*vertex_coords)[3], float r_no[3]);
-void BKE_mesh_calc_poly_center(
-        const struct MPoly *mpoly, const struct MLoop *loopstart,
-        const struct MVert *mvarray, float r_cent[3]);
-float BKE_mesh_calc_poly_area(
-        const struct MPoly *mpoly, const struct MLoop *loopstart,
-        const struct MVert *mvarray);
-void BKE_mesh_calc_poly_angles(
-        const struct MPoly *mpoly, const struct MLoop *loopstart,
-        const struct MVert *mvarray, float angles[]);
-
-void BKE_mesh_poly_edgehash_insert(
-        struct EdgeHash *ehash,
-        const struct MPoly *mp, const struct MLoop *mloop);
-void BKE_mesh_poly_edgebitmap_insert(
-        unsigned int *edge_bitmap,
-        const struct MPoly *mp, const struct MLoop *mloop);
-
+void BKE_mesh_calc_poly_normal(const struct MPoly *mpoly,
+                               const struct MLoop *loopstart,
+                               const struct MVert *mvarray,
+                               float r_no[3]);
+void BKE_mesh_calc_poly_normal_coords(const struct MPoly *mpoly,
+                                      const struct MLoop *loopstart,
+                                      const float (*vertex_coords)[3],
+                                      float r_no[3]);
+void BKE_mesh_calc_poly_center(const struct MPoly *mpoly,
+                               const struct MLoop *loopstart,
+                               const struct MVert *mvarray,
+                               float r_cent[3]);
+float BKE_mesh_calc_poly_area(const struct MPoly *mpoly,
+                              const struct MLoop *loopstart,
+                              const struct MVert *mvarray);
+void BKE_mesh_calc_poly_angles(const struct MPoly *mpoly,
+                               const struct MLoop *loopstart,
+                               const struct MVert *mvarray,
+                               float angles[]);
+
+void BKE_mesh_poly_edgehash_insert(struct EdgeHash *ehash,
+                                   const struct MPoly *mp,
+                                   const struct MLoop *mloop);
+void BKE_mesh_poly_edgebitmap_insert(unsigned int *edge_bitmap,
+                                     const struct MPoly *mp,
+                                     const struct MLoop *mloop);
 
 bool BKE_mesh_center_median(const struct Mesh *me, float r_cent[3]);
 bool BKE_mesh_center_bounds(const struct Mesh *me, float r_cent[3]);
 bool BKE_mesh_center_of_surface(const struct Mesh *me, float r_cent[3]);
 bool BKE_mesh_center_of_volume(const struct Mesh *me, float r_cent[3]);
 
-void BKE_mesh_calc_volume(
-        const struct MVert *mverts, const int mverts_num,
-        const struct MLoopTri *mlooptri, const int looptri_num,
-        const struct MLoop *mloop,
-        float *r_volume, float r_center[3]);
+void BKE_mesh_calc_volume(const struct MVert *mverts,
+                          const int mverts_num,
+                          const struct MLoopTri *mlooptri,
+                          const int looptri_num,
+                          const struct MLoop *mloop,
+                          float *r_volume,
+                          float r_center[3]);
 
 /* tessface */
-void BKE_mesh_loops_to_mface_corners(
-        struct CustomData *fdata, struct CustomData *ldata,
-        struct CustomData *pdata, unsigned int lindex[4], int findex,
-        const int polyindex, const int mf_len,
-        const int numTex, const int numCol,
-        const bool hasPCol, const bool hasOrigSpace, const bool hasLNor);
-void BKE_mesh_loops_to_tessdata(
-        struct CustomData *fdata, struct CustomData *ldata, struct MFace *mface,
-        int *polyindices, unsigned int (*loopindices)[4], const int num_faces);
-void BKE_mesh_tangent_loops_to_tessdata(
-        struct CustomData *fdata, struct CustomData *ldata, struct MFace *mface,
-        int *polyindices, unsigned int (*loopindices)[4], const int num_faces, const char *layer_name);
-int BKE_mesh_recalc_tessellation(
-        struct CustomData *fdata, struct CustomData *ldata, struct CustomData *pdata,
-        struct MVert *mvert,
-        int totface, int totloop, int totpoly,
-        const bool do_face_nor_copy);
-void BKE_mesh_recalc_looptri(
-        const struct MLoop *mloop, const struct MPoly *mpoly,
-        const struct MVert *mvert,
-        int totloop, int totpoly,
-        struct MLoopTri *mlooptri);
+void BKE_mesh_loops_to_mface_corners(struct CustomData *fdata,
+                                     struct CustomData *ldata,
+                                     struct CustomData *pdata,
+                                     unsigned int lindex[4],
+                                     int findex,
+                                     const int polyindex,
+                                     const int mf_len,
+                                     const int numTex,
+                                     const int numCol,
+                                     const bool hasPCol,
+                                     const bool hasOrigSpace,
+                                     const bool hasLNor);
+void BKE_mesh_loops_to_tessdata(struct CustomData *fdata,
+                                struct CustomData *ldata,
+                                struct MFace *mface,
+                                int *polyindices,
+                                unsigned int (*loopindices)[4],
+                                const int num_faces);
+void BKE_mesh_tangent_loops_to_tessdata(struct CustomData *fdata,
+                                        struct CustomData *ldata,
+                                        struct MFace *mface,
+                                        int *polyindices,
+                                        unsigned int (*loopindices)[4],
+                                        const int num_faces,
+                                        const char *layer_name);
+int BKE_mesh_recalc_tessellation(struct CustomData *fdata,
+                                 struct CustomData *ldata,
+                                 struct CustomData *pdata,
+                                 struct MVert *mvert,
+                                 int totface,
+                                 int totloop,
+                                 int totpoly,
+                                 const bool do_face_nor_copy);
+void BKE_mesh_recalc_looptri(const struct MLoop *mloop,
+                             const struct MPoly *mpoly,
+                             const struct MVert *mvert,
+                             int totloop,
+                             int totpoly,
+                             struct MLoopTri *mlooptri);
 void BKE_mesh_convert_mfaces_to_mpolys(struct Mesh *mesh);
 void BKE_mesh_do_versions_convert_mfaces_to_mpolys(struct Mesh *mesh);
-void BKE_mesh_convert_mfaces_to_mpolys_ex(
-        struct ID *id,
-        struct CustomData *fdata, struct CustomData *ldata, struct CustomData *pdata,
-        int totedge_i, int totface_i, int totloop_i, int totpoly_i,
-        struct MEdge *medge, struct MFace *mface,
-        int *r_totloop, int *r_totpoly,
-        struct MLoop **r_mloop, struct MPoly **r_mpoly);
+void BKE_mesh_convert_mfaces_to_mpolys_ex(struct ID *id,
+                                          struct CustomData *fdata,
+                                          struct CustomData *ldata,
+                                          struct CustomData *pdata,
+                                          int totedge_i,
+                                          int totface_i,
+                                          int totloop_i,
+                                          int totpoly_i,
+                                          struct MEdge *medge,
+                                          struct MFace *mface,
+                                          int *r_totloop,
+                                          int *r_totpoly,
+                                          struct MLoop **r_mloop,
+                                          struct MPoly **r_mpoly);
 
 void BKE_mesh_mdisp_flip(struct MDisps *md, const bool use_loop_mdisp_flip);
 
-void BKE_mesh_polygon_flip_ex(
-        struct MPoly *mpoly, struct MLoop *mloop, struct CustomData *ldata,
-        float (*lnors)[3], struct MDisps *mdisp, const bool use_loop_mdisp_flip);
+void BKE_mesh_polygon_flip_ex(struct MPoly *mpoly,
+                              struct MLoop *mloop,
+                              struct CustomData *ldata,
+                              float (*lnors)[3],
+                              struct MDisps *mdisp,
+                              const bool use_loop_mdisp_flip);
 void BKE_mesh_polygon_flip(struct MPoly *mpoly, struct MLoop *mloop, struct CustomData *ldata);
-void BKE_mesh_polygons_flip(struct MPoly *mpoly, struct MLoop *mloop, struct CustomData *ldata, int totpoly);
+void BKE_mesh_polygons_flip(struct MPoly *mpoly,
+                            struct MLoop *mloop,
+                            struct CustomData *ldata,
+                            int totpoly);
 
 /* merge verts  */
 /* Enum for merge_mode of CDDM_merge_verts.
  * Refer to mesh.c for details. */
 enum {
-       MESH_MERGE_VERTS_DUMP_IF_MAPPED,
-       MESH_MERGE_VERTS_DUMP_IF_EQUAL,
+  MESH_MERGE_VERTS_DUMP_IF_MAPPED,
+  MESH_MERGE_VERTS_DUMP_IF_EQUAL,
 };
-struct Mesh *BKE_mesh_merge_verts(
-        struct Mesh *mesh,
-        const int *vtargetmap, const int tot_vtargetmap,
-        const int merge_mode);
-
+struct Mesh *BKE_mesh_merge_verts(struct Mesh *mesh,
+                                  const int *vtargetmap,
+                                  const int tot_vtargetmap,
+                                  const int merge_mode);
 
 /* flush flags */
-void BKE_mesh_flush_hidden_from_verts_ex(
-        const struct MVert *mvert,
-        const struct MLoop *mloop,
-        struct MEdge *medge, const int totedge,
-        struct MPoly *mpoly, const int totpoly);
+void BKE_mesh_flush_hidden_from_verts_ex(const struct MVert *mvert,
+                                         const struct MLoop *mloop,
+                                         struct MEdge *medge,
+                                         const int totedge,
+                                         struct MPoly *mpoly,
+                                         const int totpoly);
 void BKE_mesh_flush_hidden_from_verts(struct Mesh *me);
-void BKE_mesh_flush_hidden_from_polys_ex(
-        struct MVert *mvert,
-        const struct MLoop *mloop,
-        struct MEdge *medge, const int totedge,
-        const struct MPoly *mpoly, const int totpoly);
+void BKE_mesh_flush_hidden_from_polys_ex(struct MVert *mvert,
+                                         const struct MLoop *mloop,
+                                         struct MEdge *medge,
+                                         const int totedge,
+                                         const struct MPoly *mpoly,
+                                         const int totpoly);
 void BKE_mesh_flush_hidden_from_polys(struct Mesh *me);
-void BKE_mesh_flush_select_from_polys_ex(
-        struct MVert *mvert,       const int totvert,
-        const struct MLoop *mloop,
-        struct MEdge *medge,       const int totedge,
-        const struct MPoly *mpoly, const int totpoly);
+void BKE_mesh_flush_select_from_polys_ex(struct MVert *mvert,
+                                         const int totvert,
+                                         const struct MLoop *mloop,
+                                         struct MEdge *medge,
+                                         const int totedge,
+                                         const struct MPoly *mpoly,
+                                         const int totpoly);
 void BKE_mesh_flush_select_from_polys(struct Mesh *me);
-void BKE_mesh_flush_select_from_verts_ex(
-        const struct MVert *mvert, const int totvert,
-        const struct MLoop *mloop,
-        struct MEdge *medge,       const int totedge,
-        struct MPoly *mpoly,       const int totpoly);
+void BKE_mesh_flush_select_from_verts_ex(const struct MVert *mvert,
+                                         const int totvert,
+                                         const struct MLoop *mloop,
+                                         struct MEdge *medge,
+                                         const int totedge,
+                                         struct MPoly *mpoly,
+                                         const int totpoly);
 void BKE_mesh_flush_select_from_verts(struct Mesh *me);
 
 /* spatial evaluation */
-void BKE_mesh_calc_relative_deform(
-        const struct MPoly *mpoly, const int totpoly,
-        const struct MLoop *mloop, const int totvert,
-
-        const float (*vert_cos_src)[3],
-        const float (*vert_cos_dst)[3],
-
-        const float (*vert_cos_org)[3],
-              float (*vert_cos_new)[3]);
+void BKE_mesh_calc_relative_deform(const struct MPoly *mpoly,
+                                   const int totpoly,
+                                   const struct MLoop *mloop,
+                                   const int totvert,
 
+                                   const float (*vert_cos_src)[3],
+                                   const float (*vert_cos_dst)[3],
 
+                                   const float (*vert_cos_org)[3],
+                                   float (*vert_cos_new)[3]);
 
 /* *** mesh_validate.c *** */
 
@@ -477,25 +621,34 @@ bool BKE_mesh_validate(struct Mesh *me, const bool do_verbose, const bool cddata
 bool BKE_mesh_is_valid(struct Mesh *me);
 bool BKE_mesh_validate_material_indices(struct Mesh *me);
 
-bool BKE_mesh_validate_arrays(
-        struct Mesh *me,
-        struct MVert *mverts, unsigned int totvert,
-        struct MEdge *medges, unsigned int totedge,
-        struct MFace *mfaces, unsigned int totface,
-        struct MLoop *mloops, unsigned int totloop,
-        struct MPoly *mpolys, unsigned int totpoly,
-        struct MDeformVert *dverts, /* assume totvert length */
-        const bool do_verbose, const bool do_fixes,
-        bool *r_change);
-
-bool BKE_mesh_validate_all_customdata(
-        struct CustomData *vdata, const uint totvert,
-        struct CustomData *edata, const uint totedge,
-        struct CustomData *ldata, const uint totloop,
-        struct CustomData *pdata, const uint totpoly,
-        const bool check_meshmask,
-        const bool do_verbose, const bool do_fixes,
-        bool *r_change);
+bool BKE_mesh_validate_arrays(struct Mesh *me,
+                              struct MVert *mverts,
+                              unsigned int totvert,
+                              struct MEdge *medges,
+                              unsigned int totedge,
+                              struct MFace *mfaces,
+                              unsigned int totface,
+                              struct MLoop *mloops,
+                              unsigned int totloop,
+                              struct MPoly *mpolys,
+                              unsigned int totpoly,
+                              struct MDeformVert *dverts, /* assume totvert length */
+                              const bool do_verbose,
+                              const bool do_fixes,
+                              bool *r_change);
+
+bool BKE_mesh_validate_all_customdata(struct CustomData *vdata,
+                                      const uint totvert,
+                                      struct CustomData *edata,
+                                      const uint totedge,
+                                      struct CustomData *ldata,
+                                      const uint totloop,
+                                      struct CustomData *pdata,
+                                      const uint totpoly,
+                                      const bool check_meshmask,
+                                      const bool do_verbose,
+                                      const bool do_fixes,
+                                      bool *r_change);
 
 void BKE_mesh_strip_loose_faces(struct Mesh *me);
 void BKE_mesh_strip_loose_polysloops(struct Mesh *me);
@@ -508,18 +661,17 @@ void BKE_mesh_calc_edges_tessface(struct Mesh *mesh);
 
 /* **** Depsgraph evaluation **** */
 
-void BKE_mesh_eval_geometry(struct Depsgraph *depsgraph,
-                            struct Mesh *mesh);
+void BKE_mesh_eval_geometry(struct Depsgraph *depsgraph, struct Mesh *mesh);
 
 /* Draw Cache */
 enum {
-       BKE_MESH_BATCH_DIRTY_ALL = 0,
-       BKE_MESH_BATCH_DIRTY_MAYBE_ALL,
-       BKE_MESH_BATCH_DIRTY_SELECT,
-       BKE_MESH_BATCH_DIRTY_SHADING,
-       BKE_MESH_BATCH_DIRTY_SCULPT_COORDS,
-       BKE_MESH_BATCH_DIRTY_UVEDIT_ALL,
-       BKE_MESH_BATCH_DIRTY_UVEDIT_SELECT,
+  BKE_MESH_BATCH_DIRTY_ALL = 0,
+  BKE_MESH_BATCH_DIRTY_MAYBE_ALL,
+  BKE_MESH_BATCH_DIRTY_SELECT,
+  BKE_MESH_BATCH_DIRTY_SHADING,
+  BKE_MESH_BATCH_DIRTY_SCULPT_COORDS,
+  BKE_MESH_BATCH_DIRTY_UVEDIT_ALL,
+  BKE_MESH_BATCH_DIRTY_UVEDIT_SELECT,
 };
 void BKE_mesh_batch_cache_dirty_tag(struct Mesh *me, int mode);
 void BKE_mesh_batch_cache_free(struct Mesh *me);
@@ -527,17 +679,17 @@ void BKE_mesh_batch_cache_free(struct Mesh *me);
 extern void (*BKE_mesh_batch_cache_dirty_tag_cb)(struct Mesh *me, int mode);
 extern void (*BKE_mesh_batch_cache_free_cb)(struct Mesh *me);
 
-
 /* Inlines */
 
 /* Instead of -1 that function uses ORIGINDEX_NONE as defined in BKE_customdata.h,
  * but I don't want to force every user of BKE_mesh.h to also include that file.
  * ~~ Sybren */
-BLI_INLINE int BKE_mesh_origindex_mface_mpoly(
-        const int *index_mf_to_mpoly, const int *index_mp_to_orig, const int i)
+BLI_INLINE int BKE_mesh_origindex_mface_mpoly(const int *index_mf_to_mpoly,
+                                              const int *index_mp_to_orig,
+                                              const int i)
 {
-       const int j = index_mf_to_mpoly[i];
-       return (j != -1) ? (index_mp_to_orig ? index_mp_to_orig[j] : j) : -1;
+  const int j = index_mf_to_mpoly[i];
+  return (j != -1) ? (index_mp_to_orig ? index_mp_to_orig[j] : j) : -1;
 }
 
 #ifdef __cplusplus