Cleanup: comments (long lines) in blenkernel
[blender.git] / source / blender / blenkernel / intern / mesh_mapping.c
index 811b78411a3a5800927619039aeb35497146514d..40e300e6e2d73822cfd27ba12ab15341dd68666b 100644 (file)
@@ -42,8 +42,8 @@
  * \{ */
 
 /* ngon version wip, based on BM_uv_vert_map_create */
-/* this replaces the non bmesh function (in trunk) which takes MTFace's, if we ever need it back we could
- * but for now this replaces it because its unused. */
+/* this replaces the non bmesh function (in trunk) which takes MTFace's,
+ * if we ever need it back we could but for now this replaces it because its unused. */
 
 UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *mpoly,
                                        const MLoop *mloop,
@@ -67,12 +67,15 @@ UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *mpoly,
 
   /* generate UvMapVert array */
   mp = mpoly;
-  for (a = 0; a < totpoly; a++, mp++)
-    if (!selected || (!(mp->flag & ME_HIDE) && (mp->flag & ME_FACE_SEL)))
+  for (a = 0; a < totpoly; a++, mp++) {
+    if (!selected || (!(mp->flag & ME_HIDE) && (mp->flag & ME_FACE_SEL))) {
       totuv += mp->totloop;
+    }
+  }
 
-  if (totuv == 0)
+  if (totuv == 0) {
     return NULL;
+  }
 
   vmap = (UvVertMap *)MEM_callocN(sizeof(*vmap), "UvVertMap");
   buf = vmap->buf = (UvMapVert *)MEM_callocN(sizeof(*vmap->buf) * (size_t)totuv, "UvMapVert");
@@ -142,15 +145,18 @@ UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *mpoly,
 
         if (fabsf(uv[0] - uv2[0]) < limit[0] && fabsf(uv[1] - uv2[1]) < limit[1] &&
             (!use_winding || winding[iterv->poly_index] == winding[v->poly_index])) {
-          if (lastv)
+          if (lastv) {
             lastv->next = next;
-          else
+          }
+          else {
             vlist = next;
+          }
           iterv->next = newvlist;
           newvlist = iterv;
         }
-        else
+        else {
           lastv = iterv;
+        }
 
         iterv = next;
       }
@@ -178,10 +184,12 @@ UvMapVert *BKE_mesh_uv_vert_map_get_vert(UvVertMap *vmap, unsigned int v)
 void BKE_mesh_uv_vert_map_free(UvVertMap *vmap)
 {
   if (vmap) {
-    if (vmap->vert)
+    if (vmap->vert) {
       MEM_freeN(vmap->vert);
-    if (vmap->buf)
+    }
+    if (vmap->buf) {
       MEM_freeN(vmap->buf);
+    }
     MEM_freeN(vmap);
   }
 }
@@ -212,8 +220,9 @@ static void mesh_vert_poly_or_loop_map_create(MeshElemMap **r_map,
   for (i = 0; i < totpoly; i++) {
     const MPoly *p = &mpoly[i];
 
-    for (j = 0; j < p->totloop; j++)
+    for (j = 0; j < p->totloop; j++) {
       map[mloop[p->loopstart + j].v].count++;
+    }
   }
 
   /* Assign indices mem */
@@ -242,7 +251,8 @@ static void mesh_vert_poly_or_loop_map_create(MeshElemMap **r_map,
 }
 
 /**
- * Generates a map where the key is the vertex and the value is a list of polys that use that vertex as a corner.
+ * Generates a map where the key is the vertex and the value
+ * is a list of polys that use that vertex as a corner.
  * The lists are allocated from one memory pool.
  */
 void BKE_mesh_vert_poly_map_create(MeshElemMap **r_map,
@@ -257,7 +267,8 @@ void BKE_mesh_vert_poly_map_create(MeshElemMap **r_map,
 }
 
 /**
- * Generates a map where the key is the vertex and the value is a list of loops that use that vertex as a corner.
+ * Generates a map where the key is the vertex and the value
+ * is a list of loops that use that vertex as a corner.
  * The lists are allocated from one memory pool.
  */
 void BKE_mesh_vert_loop_map_create(MeshElemMap **r_map,
@@ -272,7 +283,8 @@ void BKE_mesh_vert_loop_map_create(MeshElemMap **r_map,
 }
 
 /**
- * Generates a map where the key is the edge and the value is a list of looptris that use that edge.
+ * Generates a map where the key is the edge and the value
+ * is a list of looptris that use that edge.
  * The lists are allocated from one memory pool.
  */
 void BKE_mesh_vert_looptri_map_create(MeshElemMap **r_map,
@@ -320,7 +332,8 @@ void BKE_mesh_vert_looptri_map_create(MeshElemMap **r_map,
 }
 
 /**
- * Generates a map where the key is the vertex and the value is a list of edges that use that vertex as an endpoint.
+ * Generates a map where the key is the vertex and the value
+ * is a list of edges that use that vertex as an endpoint.
  * The lists are allocated from one memory pool.
  */
 void BKE_mesh_vert_edge_map_create(
@@ -363,7 +376,8 @@ void BKE_mesh_vert_edge_map_create(
 }
 
 /**
- * A version of #BKE_mesh_vert_edge_map_create that references connected vertices directly (not their edges).
+ * A version of #BKE_mesh_vert_edge_map_create that references connected vertices directly
+ * (not their edges).
  */
 void BKE_mesh_vert_edge_vert_map_create(
     MeshElemMap **r_map, int **r_mem, const MEdge *medge, int totvert, int totedge)
@@ -463,7 +477,8 @@ void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
 }
 
 /**
- * Generates a map where the key is the edge and the value is a list of polygons that use that edge.
+ * Generates a map where the key is the edge and the value
+ * is a list of polygons that use that edge.
  * The lists are allocated from one memory pool.
  */
 void BKE_mesh_edge_poly_map_create(MeshElemMap **r_map,
@@ -730,7 +745,8 @@ static void poly_edge_loop_islands_calc(const MEdge *medge,
             num_edgeborders++;
           }
           if (use_bitflags) {
-            /* Find contiguous smooth groups already assigned, these are the values we can't reuse! */
+            /* Find contiguous smooth groups already assigned,
+             * these are the values we can't reuse! */
             for (; i--; p++) {
               int bit = poly_groups[*p];
               if (!ELEM(bit, 0, poly_group_id, poly_group_id_overflowed) &&
@@ -742,8 +758,9 @@ static void poly_edge_loop_islands_calc(const MEdge *medge,
         }
       }
     }
-    /* And now, we have all our poly from current group in poly_stack (from 0 to (ps_end_idx - 1)), as well as
-     * all smoothgroups bits we can't use in bit_poly_group_mask.
+    /* And now, we have all our poly from current group in poly_stack
+     * (from 0 to (ps_end_idx - 1)),
+     * as well as all smoothgroups bits we can't use in bit_poly_group_mask.
      */
     if (use_bitflags) {
       int i, *p, gid_bit = 0;
@@ -755,8 +772,9 @@ static void poly_edge_loop_islands_calc(const MEdge *medge,
       }
       if (UNLIKELY(gid_bit > 31)) {
         /* All bits used in contiguous smooth groups, we can't do much!
-         * Note: this is *very* unlikely - theoretically, four groups are enough, I don't think we can reach
-         *       this goal with such a simple algo, but I don't think either we'll never need all 32 groups!
+         * Note: this is *very* unlikely - theoretically, four groups are enough,
+         *       I don't think we can reach this goal with such a simple algo,
+         *       but I don't think either we'll never need all 32 groups!
          */
         printf(
             "Warning, could not find an available id for current smooth group, faces will me "
@@ -812,7 +830,8 @@ static bool poly_is_island_boundary_smooth_cb(const MPoly *mp,
                                               const int nbr_egde_users,
                                               void *UNUSED(user_data))
 {
-  /* Edge is sharp if its poly is sharp, or edge itself is sharp, or edge is not used by exactly two polygons. */
+  /* Edge is sharp if its poly is sharp, or edge itself is sharp,
+   * or edge is not used by exactly two polygons. */
   return (!(mp->flag & ME_SMOOTH) || (me->flag & ME_SHARP) || (nbr_egde_users != 2));
 }
 
@@ -820,9 +839,9 @@ static bool poly_is_island_boundary_smooth_cb(const MPoly *mp,
  * Calculate smooth groups from sharp edges.
  *
  * \param r_totgroup: The total number of groups, 1 or more.
- * \return Polygon aligned array of group index values (bitflags if use_bitflags is true), starting at 1
- *         (0 being used as 'invalid' flag).
- *         Note it's callers's responsibility to MEM_freeN returned array.
+ * \return Polygon aligned array of group index values (bitflags if use_bitflags is true),
+ * starting at 1 (0 being used as 'invalid' flag).
+ * Note it's callers's responsibility to MEM_freeN returned array.
  */
 int *BKE_mesh_calc_smoothgroups(const MEdge *medge,
                                 const int totedge,
@@ -963,10 +982,11 @@ void BKE_mesh_loop_islands_add(MeshIslandStore *island_store,
          sizeof(*innrcut->indices) * (size_t)num_innercut_items);
 }
 
-/* TODO: I'm not sure edge seam flag is enough to define UV islands? Maybe we should also consider UVmaps values
+/* TODO: I'm not sure edge seam flag is enough to define UV islands?
+ *       Maybe we should also consider UVmaps values
  *       themselves (i.e. different UV-edges for a same mesh-edge => boundary edge too?).
- *       Would make things much more complex though, and each UVMap would then need its own mesh mapping,
- *       not sure we want that at all!
+ *       Would make things much more complex though,
+ *       and each UVMap would then need its own mesh mapping, not sure we want that at all!
  */
 typedef struct MeshCheckIslandBoundaryUv {
   const MLoop *loops;
@@ -1043,8 +1063,9 @@ static bool mesh_calc_islands_loop_poly_uv(MVert *UNUSED(verts),
   int *loop_indices;
   int num_pidx, num_lidx;
 
-  /* Those are used to detect 'inner cuts', i.e. edges that are borders, and yet have two or more polys of
-   * a same group using them (typical case: seam used to unwrap properly a cylinder). */
+  /* Those are used to detect 'inner cuts', i.e. edges that are borders,
+   * and yet have two or more polys of a same group using them
+   * (typical case: seam used to unwrap properly a cylinder). */
   BLI_bitmap *edge_borders = NULL;
   int num_edge_borders = 0;
   char *edge_border_count = NULL;
@@ -1166,7 +1187,8 @@ static bool mesh_calc_islands_loop_poly_uv(MVert *UNUSED(verts),
 }
 
 /**
- * Calculate 'generic' UV islands, i.e. based only on actual geometry data (edge seams), not some UV layers coordinates.
+ * Calculate 'generic' UV islands, i.e. based only on actual geometry data (edge seams),
+ * not some UV layers coordinates.
  */
 bool BKE_mesh_calc_islands_loop_poly_edgeseam(MVert *verts,
                                               const int totvert,
@@ -1186,12 +1208,14 @@ bool BKE_mesh_calc_islands_loop_poly_edgeseam(MVert *verts,
  * Calculate UV islands.
  *
  * \note If no MLoopUV layer is passed, we only consider edges tagged as seams as UV boundaries.
- *     This has the advantages of simplicity, and being valid/common to all UV maps.
- *     However, it means actual UV islands without matching UV seams will not be handled correctly...
- *     If a valid UV layer is passed as \a luvs parameter, UV coordinates are also used to detect islands boundaries.
+ * This has the advantages of simplicity, and being valid/common to all UV maps.
+ * However, it means actual UV islands without matching UV seams will not be handled correctly...
+ * If a valid UV layer is passed as \a luvs parameter,
+ * UV coordinates are also used to detect islands boundaries.
  *
  * \note All this could be optimized...
- *     Not sure it would be worth the more complex code, though, those loops are supposed to be really quick to do...
+ * Not sure it would be worth the more complex code, though,
+ * those loops are supposed to be really quick to do...
  */
 bool BKE_mesh_calc_islands_loop_poly_uvmap(MVert *verts,
                                            const int totvert,