Cleanup: comment line length (blenlib)
authorCampbell Barton <ideasman42@gmail.com>
Tue, 15 Jan 2019 12:15:58 +0000 (23:15 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 15 Jan 2019 12:30:31 +0000 (23:30 +1100)
Prevents clang-format wrapping text before comments.

33 files changed:
source/blender/blenlib/BLI_astar.h
source/blender/blenlib/BLI_ghash.h
source/blender/blenlib/BLI_kdopbvh.h
source/blender/blenlib/BLI_noise.h
source/blender/blenlib/BLI_scanfill.h
source/blender/blenlib/BLI_string_utf8.h
source/blender/blenlib/intern/BLI_dial_2d.c
source/blender/blenlib/intern/BLI_filelist.c
source/blender/blenlib/intern/BLI_ghash.c
source/blender/blenlib/intern/BLI_kdopbvh.c
source/blender/blenlib/intern/DLRB_tree.c
source/blender/blenlib/intern/array_store.c
source/blender/blenlib/intern/astar.c
source/blender/blenlib/intern/expr_pylike_eval.c
source/blender/blenlib/intern/freetypefont.c
source/blender/blenlib/intern/hash_md5.c
source/blender/blenlib/intern/math_color.c
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/math_interp.c
source/blender/blenlib/intern/math_matrix.c
source/blender/blenlib/intern/math_rotation.c
source/blender/blenlib/intern/noise.c
source/blender/blenlib/intern/path_util.c
source/blender/blenlib/intern/polyfill_2d.c
source/blender/blenlib/intern/polyfill_2d_beautify.c
source/blender/blenlib/intern/rct.c
source/blender/blenlib/intern/scanfill.c
source/blender/blenlib/intern/scanfill_utils.c
source/blender/blenlib/intern/string.c
source/blender/blenlib/intern/string_utf8.c
source/blender/blenlib/intern/task.c
source/blender/blenlib/intern/timecode.c
source/blender/blenlib/intern/voxel.c

index 99e0dcd..6edb97c 100644 (file)
@@ -54,9 +54,13 @@ typedef struct BLI_AStarGNode {
 
 typedef struct BLI_AStarSolution {
        /* Final 'most useful' data. */
-       int steps;  /* Number of steps (i.e. walked links) in path (nodes num, including start and end, is steps + 1). */
-       int *prev_nodes;  /* Store the path, in reversed order (from destination to source node), as indices. */
-       BLI_AStarGNLink **prev_links;  /* Indices are nodes' ones, as prev_nodes, but they map to relevant link. */
+       /** Number of steps (i.e. walked links) in path
+        * (nodes num, including start and end, is steps + 1). */
+       int steps;
+       /** Store the path, in reversed order (from destination to source node), as indices. */
+       int *prev_nodes;
+       /** Indices are nodes' ones, as prev_nodes, but they map to relevant link. */
+       BLI_AStarGNLink **prev_links;
 
        void *custom_data;
 
index 7003eb0..3554711 100644 (file)
@@ -77,7 +77,8 @@ enum {
 
 #ifdef GHASH_INTERNAL_API
        /* Internal usage only */
-       GHASH_FLAG_IS_GSET      = (1 << 16),  /* Whether the GHash is actually used as GSet (no value storage). */
+       /* Whether the GHash is actually used as GSet (no value storage). */
+       GHASH_FLAG_IS_GSET      = (1 << 16),
 #endif
 };
 
index d83de68..c43b76c 100644 (file)
@@ -151,7 +151,8 @@ void BLI_bvhtree_update_tree(BVHTree *tree);
 
 int BLI_bvhtree_overlap_thread_num(const BVHTree *tree);
 
-/* collision/overlap: check two trees if they overlap, alloc's *overlap with length of the int return value */
+/* collision/overlap: check two trees if they overlap,
+ * alloc's *overlap with length of the int return value */
 BVHTreeOverlap *BLI_bvhtree_overlap(
         const BVHTree *tree1, const BVHTree *tree2, unsigned int *r_overlap_tot,
         BVHTree_OverlapCallback callback, void *userdata);
@@ -161,7 +162,8 @@ int   BLI_bvhtree_get_tree_type(const BVHTree *tree);
 float BLI_bvhtree_get_epsilon(const BVHTree *tree);
 
 /* find nearest node to the given coordinates
- * (if nearest is given it will only search nodes where square distance is smaller than nearest->dist) */
+ * (if nearest is given it will only search nodes where
+ * square distance is smaller than nearest->dist) */
 int BLI_bvhtree_find_nearest_ex(
         BVHTree *tree, const float co[3], BVHTreeNearest *nearest,
         BVHTree_NearestPointCallback callback, void *userdata,
index 03f2c58..6749d74 100644 (file)
@@ -42,7 +42,8 @@ float BLI_hnoise(float noisesize, float x, float y, float z);
 float BLI_hnoisep(float noisesize, float x, float y, float z);
 float BLI_turbulence(float noisesize, float x, float y, float z, int nr);
 float BLI_turbulence1(float noisesize, float x, float y, float z, int nr);
-/* newnoise: generic noise & turbulence functions to replace the above BLI_hnoise/p & BLI_turbulence/1.
+/* newnoise: generic noise & turbulence functions
+ * to replace the above BLI_hnoise/p & BLI_turbulence/1.
  * This is done so different noise basis functions can be used */
 float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noisebasis);
 float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int hard, int noisebasis);
index f6b37fa..eaca798 100644 (file)
@@ -71,13 +71,19 @@ typedef struct ScanFillVert {
                int                  i;
                unsigned int         u;
        } tmp;
-       float co[3];  /* vertex location */
-       float xy[2];  /* 2D projection of vertex location */
-       unsigned int keyindex; /* index, caller can use how it likes to match the scanfill result with own data */
+       /** vertex location */
+       float co[3];
+       /** 2D projection of vertex location */
+       float xy[2];
+       /** index, caller can use how it likes to match the scanfill result with own data */
+       unsigned int keyindex;
        unsigned short poly_nr;
-       unsigned char edge_tot;  /* number of edges using this vertex */
-       unsigned int f : 4;  /* vert status */
-       unsigned int user_flag : 4;  /* flag callers can use as they like */
+       /** number of edges using this vertex */
+       unsigned char edge_tot;
+       /** vert status */
+       unsigned int f : 4;
+       /** flag callers can use as they like */
+       unsigned int user_flag : 4;
 } ScanFillVert;
 
 typedef struct ScanFillEdge {
index 21542d0..4617a3a 100644 (file)
@@ -39,7 +39,8 @@ char        *BLI_strncat_utf8(char *__restrict dst, const char *__restrict src,
 ptrdiff_t    BLI_utf8_invalid_byte(const char *str, size_t length) ATTR_NONNULL();
 int          BLI_utf8_invalid_strip(char *str, size_t length) ATTR_NONNULL();
 
-int          BLI_str_utf8_size(const char *p) ATTR_NONNULL(); /* warning, can return -1 on bad chars */
+/* warning, can return -1 on bad chars */
+int          BLI_str_utf8_size(const char *p) ATTR_NONNULL();
 int          BLI_str_utf8_size_safe(const char *p) ATTR_NONNULL();
 /* copied from glib */
 unsigned int BLI_str_utf8_as_unicode(const char *p) ATTR_NONNULL();
@@ -64,7 +65,8 @@ size_t       BLI_strncpy_wchar_from_utf8(wchar_t *__restrict dst, const char *__
 /* count columns that character/string occupies, based on wcwidth.c */
 int          BLI_wcwidth(wchar_t ucs);
 int          BLI_wcswidth(const wchar_t *pwcs, size_t n) ATTR_NONNULL();
-int          BLI_str_utf8_char_width(const char *p) ATTR_NONNULL(); /* warning, can return -1 on bad chars */
+/* warning, can return -1 on bad chars */
+int          BLI_str_utf8_char_width(const char *p) ATTR_NONNULL();
 int          BLI_str_utf8_char_width_safe(const char *p) ATTR_NONNULL();
 
 size_t       BLI_str_partition_utf8(const char *str, const unsigned int delim[], const char **sep, const char **suf) ATTR_NONNULL();
index 1f4c59a..eb18b30 100644 (file)
@@ -66,7 +66,8 @@ float BLI_dial_angle(Dial *dial, const float current_position[2])
 
        sub_v2_v2v2(current_direction, current_position, dial->center);
 
-       /* only update when we have enough precision, by having the mouse adequately away from center */
+       /* only update when we have enough precision,
+        * by having the mouse adequately away from center */
        if (len_squared_v2(current_direction) > dial->threshold_squared) {
                float angle;
                float cosval, sinval;
@@ -86,7 +87,8 @@ float BLI_dial_angle(Dial *dial, const float current_position[2])
                angle = atan2f(sinval, cosval);
 
                /* change of sign, we passed the 180 degree threshold. This means we need to add a turn.
-                * to distinguish between transition from 0 to -1 and -PI to +PI, use comparison with PI/2 */
+                * to distinguish between transition from 0 to -1 and -PI to +PI,
+                * use comparison with PI/2 */
                if ((angle * dial->last_angle < 0.0f) &&
                    (fabsf(dial->last_angle) > (float)M_PI_2))
                {
index 76de52b..976a496 100644 (file)
@@ -179,7 +179,8 @@ static void bli_builddir(struct BuildDirCtx *dir_ctx, const char *dirname)
                                                file->type = file->s.st_mode;
                                        }
                                        else if (FILENAME_IS_CURRPAR(file->relname)) {
-                                               /* Hack around for UNC paths on windows - does not support stat on '\\SERVER\foo\..', sigh... */
+                                               /* Hack around for UNC paths on windows:
+                                                * does not support stat on '\\SERVER\foo\..', sigh... */
                                                file->type |= S_IFDIR;
                                        }
                                        dir_ctx->nrfiles++;
index 3c5fbf5..7dac54d 100644 (file)
@@ -242,8 +242,8 @@ static void ghash_buckets_resize(GHash *gh, const uint nbuckets)
                                        buckets_new[bucket_index] = e;
                                }
 #else
-                               /* No need to recompute hashes in this case, since our mask is just smaller, all items in old bucket i
-                                * will go in same new bucket (i & new_mask)! */
+                               /* No need to recompute hashes in this case, since our mask is just smaller,
+                                * all items in old bucket 'i' will go in same new bucket (i & new_mask)! */
                                const unsigned bucket_index = ghash_bucket_index(gh, i);
                                BLI_assert(!buckets_old[i] || (bucket_index == ghash_bucket_index(gh, ghash_entryhash(gh, buckets_old[i]))));
                                Entry *e;
@@ -614,8 +614,9 @@ static Entry *ghash_pop(GHash *gh, GHashIterState *state)
                return NULL;
        }
 
-       /* Note: using first_bucket_index here allows us to avoid potential huge number of loops over buckets,
-        *       in case we are popping from a large ghash with few items in it... */
+       /* Note: using first_bucket_index here allows us to avoid potential
+        * huge number of loops over buckets,
+        * in case we are popping from a large ghash with few items in it... */
        curr_bucket = ghash_find_next_bucket_index(gh, curr_bucket);
 
        Entry *e = gh->buckets[curr_bucket];
@@ -681,7 +682,8 @@ static GHash *ghash_copy(GHash *gh, GHashKeyCopyFP keycopyfp, GHashValCopyFP val
                         * This means entries in buckets in new copy will be in reversed order!
                         * This shall not be an issue though, since order should never be assumed in ghash. */
 
-                       /* Note: We can use 'i' here, since we are sure that 'gh' and 'gh_new' have the same number of buckets! */
+                       /* Note: We can use 'i' here, since we are sure that
+                        * 'gh' and 'gh_new' have the same number of buckets! */
                        e_new->next = gh_new->buckets[i];
                        gh_new->buckets[i] = e_new;
                }
index 7959ca4..d497c7a 100644 (file)
@@ -279,7 +279,8 @@ static int bvh_partition(BVHNode **a, int lo, int hi, BVHNode *x, int axis)
        }
 }
 
-static BVHNode *bvh_medianof3(BVHNode **a, int lo, int mid, int hi, int axis)  /* returns Sortable */
+/* returns Sortable */
+static BVHNode *bvh_medianof3(BVHNode **a, int lo, int mid, int hi, int axis)
 {
        if ((a[mid])->bv[axis] < (a[lo])->bv[axis]) {
                if ((a[hi])->bv[axis] < (a[mid])->bv[axis])
@@ -544,13 +545,16 @@ static void bvhtree_verify(BVHTree *tree)
  * This code can be easily reduced
  * (basicly this is only method to calculate pow(k, n) in O(1).. and stuff like that) */
 typedef struct BVHBuildHelper {
-       int tree_type;              /* */
-       int totleafs;               /* */
+       int tree_type;
+       int totleafs;
 
-       int leafs_per_child[32];    /* Min number of leafs that are archievable from a node at depth N */
-       int branches_on_level[32];  /* Number of nodes at depth N (tree_type^N) */
+       /** Min number of leafs that are archievable from a node at depth N */
+       int leafs_per_child[32];
+       /** Number of nodes at depth N (tree_type^N) */
+       int branches_on_level[32];
 
-       int remain_leafs;           /* Number of leafs that are placed on the level that is not 100% filled */
+       /** Number of leafs that are placed on the level that is not 100% filled */
+       int remain_leafs;
 
 } BVHBuildHelper;
 
@@ -699,17 +703,20 @@ static void non_recursive_bvh_div_nodes_task_cb(
        nth_positions[data->tree_type] = parent_leafs_end;
        for (k = 1; k < data->tree_type; k++) {
                const int child_index = j * data->tree_type + data->tree_offset + k;
-               const int child_level_index = child_index - data->first_of_next_level; /* child level index */
+               /* child level index */
+               const int child_level_index = child_index - data->first_of_next_level;
                nth_positions[k] = implicit_leafs_index(data->data, data->depth + 1, child_level_index);
        }
 
        split_leafs(data->leafs_array, nth_positions, data->tree_type, split_axis);
 
        /* Setup children and totnode counters
-        * Not really needed but currently most of BVH code relies on having an explicit children structure */
+        * Not really needed but currently most of BVH code
+        * relies on having an explicit children structure */
        for (k = 0; k < data->tree_type; k++) {
                const int child_index = j * data->tree_type + data->tree_offset + k;
-               const int child_level_index = child_index - data->first_of_next_level; /* child level index */
+               /* child level index */
+               const int child_level_index = child_index - data->first_of_next_level;
 
                const int child_leafs_begin = implicit_leafs_index(data->data, data->depth + 1, child_level_index);
                const int child_leafs_end   = implicit_leafs_index(data->data, data->depth + 1, child_level_index + 1);
@@ -751,7 +758,9 @@ static void non_recursive_bvh_div_nodes(
        int i;
 
        const int tree_type   = tree->tree_type;
-       const int tree_offset = 2 - tree->tree_type; /* this value is 0 (on binary trees) and negative on the others */
+       /* this value is 0 (on binary trees) and negative on the others */
+       const int tree_offset = 2 - tree->tree_type;
+
        const int num_branches = implicit_needed_branches(tree_type, num_leafs);
 
        BVHBuildHelper data;
@@ -785,7 +794,8 @@ static void non_recursive_bvh_div_nodes(
        /* Loop tree levels (log N) loops */
        for (i = 1, depth = 1; i <= num_branches; i = i * tree_type + tree_offset, depth++) {
                const int first_of_next_level = i * tree_type + tree_offset;
-               const int i_stop = min_ii(first_of_next_level, num_branches + 1);  /* index of last branch on this level */
+               /* index of last branch on this level */
+               const int i_stop = min_ii(first_of_next_level, num_branches + 1);
 
                /* Loop all branches on this level */
                cb_data.first_of_next_level = first_of_next_level;
@@ -834,7 +844,8 @@ BVHTree *BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis)
 
        /* tree epsilon must be >= FLT_EPSILON
         * so that tangent rays can still hit a bounding volume..
-        * this bug would show up when casting a ray aligned with a kdop-axis and with an edge of 2 faces */
+        * this bug would show up when casting a ray aligned with a kdop-axis
+        * and with an edge of 2 faces */
        epsilon = max_ff(FLT_EPSILON, epsilon);
 
        if (tree) {
@@ -1259,7 +1270,8 @@ BVHTreeOverlap *BLI_bvhtree_overlap(
 /** \name BLI_bvhtree_find_nearest
  * \{ */
 
-/* Determines the nearest point of the given node BV. Returns the squared distance to that point. */
+/* Determines the nearest point of the given node BV.
+ * Returns the squared distance to that point. */
 static float calc_nearest_point_squared(const float proj[3], BVHNode *node, float nearest[3])
 {
        int i;
@@ -1743,7 +1755,8 @@ static void dfs_range_query(RangeQueryData *data, BVHNode *node)
 {
        if (node->totnode == 0) {
 #if 0   /*UNUSED*/
-               /* Calculate the node min-coords (if the node was a point then this is the point coordinates) */
+               /* Calculate the node min-coords
+                * (if the node was a point then this is the point coordinates) */
                float co[3];
                co[0] = node->bv[0];
                co[1] = node->bv[2];
index e331e07..c49f37d 100644 (file)
@@ -443,7 +443,8 @@ static void insert_check_3(DLRBT_Tree *tree, DLRBT_Node *node)
 {
        DLRBT_Node *gp = get_grandparent(node);
 
-       /* check that grandparent and node->parent exist (jut in case... really shouldn't happen on a good tree) */
+       /* check that grandparent and node->parent exist
+        * (jut in case... really shouldn't happen on a good tree) */
        if (node && node->parent && gp) {
                /* a left rotation will switch the roles of node and its parent, assuming that
                 * the parent is the left child of the grandparent... otherwise, rotation direction
@@ -466,13 +467,13 @@ static void insert_check_3(DLRBT_Tree *tree, DLRBT_Node *node)
                        /* get 'new' grandparent (i.e. grandparent for old-parent (node)) */
                        gp = get_grandparent(node);
 
-                       /* modify the coloring of the grandparent and parent so that they still satisfy the constraints */
+                       /* modify the coloring of the grandparent and parent
+                        * so that they still satisfy the constraints */
                        node->parent->tree_col = DLRBT_BLACK;
                        gp->tree_col = DLRBT_RED;
 
-                       /* if there are several nodes that all form a left chain, do a right rotation to correct this
-                        * (or a rotation in the opposite direction if they all form a right chain)
-                        */
+                       /* if there are several nodes that all form a left chain, do a right rotation to correct
+                        * this (or a rotation in the opposite direction if they all form a right chain) */
                        if ((node == node->parent->left) && (node->parent == gp->left))
                                rotate_right(tree, gp);
                        else //if ((node == node->parent->right) && (node->parent == gp->right))
@@ -502,7 +503,8 @@ void BLI_dlrbTree_insert(DLRBT_Tree *tree, DLRBT_Node *node)
 /* ----- */
 
 /* Add the given data to the tree, and return the node added */
-/* NOTE: for duplicates, the update_cb is called (if available), and the existing node is returned */
+/* NOTE: for duplicates, the update_cb is called (if available),
+ * and the existing node is returned */
 DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
                              DLRBT_NAlloc_FP new_cb, DLRBT_NUpdate_FP update_cb, void *data)
 {
index 153ba3e..c914260 100644 (file)
@@ -473,7 +473,8 @@ static void bchunk_list_ensure_min_size_last(
                                BLI_mempool_free(bs_mem->chunk_ref, cref);
                        }
                        else {
-                               /* If we always merge small slices, we should _almost_ never end up having very large chunks.
+                               /* If we always merge small slices, we should _almost_
+                                * never end up having very large chunks.
                                 * Gradual expanding on contracting will cause this.
                                 *
                                 * if we do, the code below works (test by setting 'BCHUNK_SIZE_MAX_MUL = 1.2') */
@@ -1324,8 +1325,8 @@ static BChunkList *bchunk_list_from_data_merge(
                                        BChunk *chunk_found = cref_found->link;
 
                                        if (bchunk_data_compare(chunk_found, data, data_len, i_prev)) {
-                                               /* may be useful to remove table data, assuming we dont have repeating memory
-                                                * where it would be useful to re-use chunks. */
+                                               /* may be useful to remove table data, assuming we dont have
+                                                * repeating memory where it would be useful to re-use chunks. */
                                                i += chunk_found->data_len;
                                                bchunk_list_append(info, bs_mem, chunk_list, chunk_found);
                                                /* chunk_found may be freed! */
@@ -1377,7 +1378,8 @@ static BChunkList *bchunk_list_from_data_merge(
                        BChunk *chunk = cref->link;
                        // BLI_assert(bchunk_data_compare(chunk, data, data_len, i_prev));
                        i_prev += chunk->data_len;
-                       /* use simple since we assume the references chunks have already been sized correctly. */
+                       /* use simple since we assume the references chunks
+                        * have already been sized correctly. */
                        bchunk_list_append_only(bs_mem, chunk_list, chunk);
                        ASSERT_CHUNKLIST_DATA(chunk_list, data);
                        cref = cref->next;
index 4a94c38..2997518 100644 (file)
@@ -237,7 +237,8 @@ bool BLI_astar_graph_solve(
                LinkData *ld;
 
                if (BLI_BITMAP_TEST(done_nodes, node_curr_idx)) {
-                       /* Might happen, because we always add nodes to heap when evaluating them, without ever removing them. */
+                       /* Might happen, because we always add nodes to heap when evaluating them,
+                        * without ever removing them. */
                        continue;
                }
 
@@ -268,8 +269,8 @@ bool BLI_astar_graph_solve(
                                        prev_links[node_next_idx] = link;
                                        g_costs[node_next_idx] = g_cst;
                                        g_steps[node_next_idx] = g_steps[node_curr_idx] + 1;
-                                       /* We might have this node already in heap, but since this 'instance' will be evaluated first,
-                                        * no problem. */
+                                       /* We might have this node already in heap, but since this 'instance'
+                                        * will be evaluated first, no problem. */
                                        BLI_heapsimple_insert(
                                                todo_nodes,
                                                f_cost_cb(as_graph, r_solution, link, node_curr_idx, node_next_idx, node_index_dst),
index 7bcf32d..9586ef9 100644 (file)
@@ -706,7 +706,8 @@ static bool parse_unary(ExprParseState *state)
                        return parse_next_token(state);
 
                case TOKEN_ID:
-                       /* Parameters: search in reverse order in case of duplicate names - the last one should win. */
+                       /* Parameters: search in reverse order in case of duplicate names -
+                        * the last one should win. */
                        for (i = state->param_names_len - 1; i >= 0; i--) {
                                if (STREQ(state->tokenbuf, state->param_names[i])) {
                                        parse_add_op(state, OPCODE_PARAMETER, 1)->arg.ival = i;
index 77b2949..f7deebc 100644 (file)
@@ -486,7 +486,8 @@ VChar *BLI_vfontchar_from_freetypefont(VFont *vfont, unsigned long character)
 }
 
 /* Yeah, this is very bad... But why is this in BLI in the first place, since it uses Nurb data?
- * Anyway, do not feel like duplicating whole Nurb copy code here, so unless someone has a better idea... */
+ * Anyway, do not feel like duplicating whole Nurb copy code here,
+ * so unless someone has a better idea... */
 #include "../../blenkernel/BKE_curve.h"
 
 VChar *BLI_vfontchar_copy(const VChar *vchar_src, const int UNUSED(flag))
index c73fe7a..f4573f1 100644 (file)
 #  include <limits.h>
 #endif
 
-/* The following contortions are an attempt to use the C preprocessor to determine an unsigned integral type
- * that is 32 bits wide. An alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but doing that
- * would require that the configure script compile and *run* the resulting executable.
+/* The following contortions are an attempt to use the C preprocessor to determine an unsigned
+ * integral type that is 32 bits wide.
+ * An alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but doing that would require
+ * that the configure script compile and *run* the resulting executable.
  * Locally running cross-compiled executables is usually not possible.
  */
 
@@ -94,7 +95,8 @@ struct md5_ctx {
 #  define SWAP(n) (n)
 #endif
 
-/* This array contains the bytes used to pad the buffer to the next 64-byte boundary.  (RFC 1321, 3.1: Step 1) */
+/* This array contains the bytes used to pad the buffer to the next 64-byte boundary.
+ * (RFC 1321, 3.1: Step 1) */
 static const unsigned char fillbuf[64] = {0x80, 0 /* , 0, 0, ...  */};
 
 /** Initialize structure containing state of computation.
@@ -108,14 +110,16 @@ static void md5_init_ctx(struct md5_ctx *ctx)
        ctx->D = 0x10325476;
 }
 
-/** Starting with the result of former calls of this function (or the initialization), this function updates
- *  the 'ctx' context for the next 'len' bytes starting at 'buffer'.
- *  It is necessary that 'len' is a multiple of 64!!!
+/**
+ * Starting with the result of former calls of this function (or the initialization),
+ * this function updates the 'ctx' context for the next 'len' bytes starting at 'buffer'.
+ * It is necessary that 'len' is a multiple of 64!!!
  */
 static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
 {
-/* These are the four functions used in the four steps of the MD5 algorithm and defined in the RFC 1321.
- * The first function is a little bit optimized (as found in Colin Plumbs public domain implementation).
+/* These are the four functions used in the four steps of the MD5 algorithm and defined in the
+ * RFC 1321. The first function is a little bit optimized
+ * (as found in Colin Plumbs public domain implementation).
  */
 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
 #define FF(b, c, d) (d ^ (b & (c ^ d)))
@@ -123,7 +127,8 @@ static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ct
 #define FH(b, c, d) (b ^ c ^ d)
 #define FI(b, c, d) (c ^ (b | ~d))
 
-/* It is unfortunate that C does not provide an operator for cyclic rotation.  Hope the C compiler is smart enough. */
+/* It is unfortunate that C does not provide an operator for cyclic rotation.
+ * Hope the C compiler is smart enough. */
 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
 
        md5_uint32 correct_words[16];
@@ -143,10 +148,11 @@ static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ct
                md5_uint32 C_save = C;
                md5_uint32 D_save = D;
 
-               /* First round: using the given function, the context and a constant the next context is computed.
-                * Because the algorithms processing unit is a 32-bit word and it is determined to work on words in
-                * little endian byte order we perhaps have to change the byte order before the computation.
-                * To reduce the work for the next steps we store the swapped words in the array CORRECT_WORDS.
+               /* First round: using the given function, the context and a constant the next context is
+                * computed. Because the algorithms processing unit is a 32-bit word and it is determined
+                * to work on words in little endian byte order we perhaps have to change the byte order
+                * before the computation. To reduce the work for the next steps we store the swapped words
+                * in the array CORRECT_WORDS.
                 */
 #define OP(a, b, c, d, s, T)                                   \
                a += FF(b, c, d) + (*cwp++ = SWAP(*words)) + T;        \
@@ -264,8 +270,10 @@ static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ct
 #undef CYCLIC
 }
 
-/** Put result from 'ctx' in first 16 bytes of 'resbuf'. The result is always in little endian byte order,
- *  so that a byte-wise output yields to the wanted ASCII representation of the message digest.
+/**
+ * Put result from 'ctx' in first 16 bytes of 'resbuf'.
+ * The result is always in little endian byte order,
+ * so that a byte-wise output yields to the wanted ASCII representation of the message digest.
  */
 static void *md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
 {
@@ -300,8 +308,9 @@ int BLI_hash_md5_stream(FILE *stream, void *resblock)
 
        /* Iterate over full file contents. */
        while (1) {
-               /* We read the file in blocks of BLOCKSIZE bytes. One call of the computation function processes
-                * the whole buffer so that with the next round of the loop another block can be read.
+               /* We read the file in blocks of BLOCKSIZE bytes.
+                * One call of the computation function processes the whole buffer
+                * so that with the next round of the loop another block can be read.
                 */
                size_t n;
                sum = 0;
@@ -330,7 +339,8 @@ int BLI_hash_md5_stream(FILE *stream, void *resblock)
                md5_process_block(buffer, BLOCKSIZE, &ctx);
        }
 
-       /* We can copy 64 bytes because the buffer is always big enough. 'fillbuf' contains the needed bits. */
+       /* We can copy 64 bytes because the buffer is always big enough.
+        * 'fillbuf' contains the needed bits. */
        memcpy(&buffer[sum], fillbuf, 64);
 
        /* Compute amount of padding bytes needed. Alignment is done to (N + PAD) % 64 == 56.
@@ -373,10 +383,12 @@ void *BLI_hash_md5_buffer(const char *buffer, size_t len, void *resblock)
        rest = len - blocks;
        /* Copy to own buffer.  */
        memcpy(restbuf, &buffer[blocks], rest);
-       /* Append needed fill bytes at end of buffer. We can copy 64 bytes because the buffer is always big enough. */
+       /* Append needed fill bytes at end of buffer.
+        * We can copy 64 bytes because the buffer is always big enough. */
        memcpy(&restbuf[rest], fillbuf, 64);
 
-       /* PAD bytes are used for padding to correct alignment. Note that always at least one byte is padded. */
+       /* PAD bytes are used for padding to correct alignment.
+        * Note that always at least one byte is padded. */
        pad = rest >= 56 ? 64 + 56 - rest : 56 - rest;
 
        /* Put length of buffer in *bits* in last eight bytes. */
index 91d733e..a778a97 100644 (file)
@@ -479,7 +479,7 @@ int constrain_rgb(float *r, float *g, float *b)
        return 0; /* Color within RGB gamut */
 }
 
-/* ********************************* lift/gamma/gain / ASC-CDL conversion ********************************* */
+/* ********************** lift/gamma/gain / ASC-CDL conversion ********************************* */
 
 void lift_gamma_gain_to_asc_cdl(float *lift, float *gamma, float *gain, float *offset, float *slope, float *power)
 {
@@ -494,7 +494,7 @@ void lift_gamma_gain_to_asc_cdl(float *lift, float *gamma, float *gain, float *o
        }
 }
 
-/* ******************************************** other ************************************************* */
+/* ************************************* other ************************************************* */
 
 /* Applies an hue offset to a float rgb color */
 void rgb_float_set_hue_float_offset(float rgb[3], float hue_offset)
index 930c12d..d9f4183 100644 (file)
@@ -2200,7 +2200,8 @@ bool isect_tri_tri_epsilon_v3(
                                /* ignore collinear lines, they are either an edge shared between 2 tri's
                                 * (which runs along [co_proj, plane_no], but can be safely ignored).
                                 *
-                                * or a collinear edge placed away from the ray - which we don't intersect with & can ignore. */
+                                * or a collinear edge placed away from the ray -
+                                * which we don't intersect with & can ignore. */
                                if (UNLIKELY(edge_fac == -1.0f)) {
                                        /* pass */
                                }
@@ -3424,7 +3425,8 @@ void transform_point_by_tri_v3(
         * axis where its barycentric weights can be calculated in 2D and its Z offset can
         * be re-applied. The weights are applied directly to the targets 3D points and the
         * z-depth is used to scale the targets normal as an offset.
-        * This saves transforming the target into its Z-Up orientation and back (which could also work) */
+        * This saves transforming the target into its Z-Up orientation and back
+        * (which could also work) */
        float no_tar[3], no_src[3];
        float mat_src[3][3];
        float pt_src_xy[3];
@@ -3631,7 +3633,8 @@ void interp_weights_poly_v3(float *w, float v[][3], const int n, const float co[
 
        while (i_next < n) {
                /* Mark Mayer et al algorithm that is used here does not operate well if vertex is close
-                * to borders of face. In that case, do simple linear interpolation between the two edge vertices */
+                * to borders of face.
+                * In that case, do simple linear interpolation between the two edge vertices */
 
                /* 'd_next.len' is infact 'd_curr.len', just avoid copy to begin with */
                if (UNLIKELY(d_next.len < eps)) {
@@ -3704,7 +3707,8 @@ void interp_weights_poly_v2(float *w, float v[][2], const int n, const float co[
 
        while (i_next < n) {
                /* Mark Mayer et al algorithm that is used here does not operate well if vertex is close
-                * to borders of face. In that case, do simple linear interpolation between the two edge vertices */
+                * to borders of face. In that case,
+                * do simple linear interpolation between the two edge vertices */
 
                /* 'd_next.len' is infact 'd_curr.len', just avoid copy to begin with */
                if (UNLIKELY(d_next.len < eps)) {
@@ -3786,7 +3790,8 @@ void interp_cubic_v3(float x[3], float v[3], const float x1[3], const float v1[3
        v[2] = 3 * a[2] * t2 + 2 * b[2] * t + v1[2];
 }
 
-/* unfortunately internal calculations have to be done at double precision to achieve correct/stable results. */
+/* unfortunately internal calculations have to be done at double precision
+ * to achieve correct/stable results. */
 
 #define IS_ZERO(x) ((x > (-DBL_EPSILON) && x < DBL_EPSILON) ? 1 : 0)
 
@@ -4056,7 +4061,8 @@ void perspective_m4(float mat[4][4], const float left, const float right, const
 
 }
 
-/* translate a matrix created by orthographic_m4 or perspective_m4 in XY coords (used to jitter the view) */
+/* translate a matrix created by orthographic_m4 or perspective_m4 in XY coords
+ * (used to jitter the view) */
 void window_translate_m4(float winmat[4][4], float perspmat[4][4], const float x, const float y)
 {
        if (winmat[2][3] == -1.0f) {
@@ -4550,7 +4556,8 @@ void vcloud_estimate_transform_v3(
                if (lloc) copy_v3_v3(lloc, accu_com);
                if (rloc) copy_v3_v3(rloc, accu_rcom);
                if (lrot || lscale) { /* caller does not want rot nor scale, strange but legal */
-                       /*so now do some reverse engineering and see if we can split rotation from scale ->Polardecompose*/
+                       /* so now do some reverse engineering and see if we can
+                        * split rotation from scale -> Polardecompose */
                        /* build 'projection' matrix */
                        float m[3][3], mr[3][3], q[3][3], qi[3][3];
                        float va[3], vb[3], stunt[3];
index b93a7f5..a432cfa 100644 (file)
@@ -146,7 +146,8 @@ BLI_INLINE void bicubic_interpolation(const unsigned char *byte_buffer, const fl
                        CLAMP(y1, 0, height - 1);
                        /* normally we could do this */
                        /* w = P(n-a) * P(b-m); */
-                       /* except that would call P() 16 times per pixel therefor pow() 64 times, better precalc these */
+                       /* except that would call P() 16 times per pixel therefor pow() 64 times,
+                        * better precalc these */
                        w = wx * wy[m + 1];
 
                        if (float_output) {
@@ -414,7 +415,8 @@ void BLI_bilinear_interpolation_wrap_char(const unsigned char *buffer, unsigned
 
 /**************************************************************************
  * Filtering method based on
- * "Creating raster omnimax images from multiple perspective views using the elliptical weighted average filter"
+ * "Creating raster omnimax images from multiple perspective views
+ * using the elliptical weighted average filter"
  * by Ned Greene and Paul S. Heckbert (1986)
  ***************************************************************************/
 
index 462d073..15858e8 100644 (file)
@@ -1788,11 +1788,13 @@ void blend_m4_m4m4(float out[4][4], const float dst[4][4], const float src[4][4]
  */
 void interp_m3_m3m3(float R[3][3], const float A[3][3], const float B[3][3], const float t)
 {
-       /* 'Rotation' component ('U' part of polar decomposition, the closest orthogonal matrix to M3 rot/scale
+       /* 'Rotation' component ('U' part of polar decomposition,
+        * the closest orthogonal matrix to M3 rot/scale
         * transformation matrix), spherically interpolated. */
        float U_A[3][3], U_B[3][3], U[3][3];
        float quat_A[4], quat_B[4], quat[4];
-       /* 'Scaling' component ('P' part of polar decomposition, i.e. scaling in U-defined space), linearly interpolated. */
+       /* 'Scaling' component ('P' part of polar decomposition, i.e. scaling in U-defined space),
+        * linearly interpolated. */
        float P_A[3][3], P_B[3][3], P[3][3];
 
        int i;
index 8e5b3f0..97f456d 100644 (file)
@@ -197,7 +197,8 @@ void sub_qt_qtqt(float q[4], const float q1[4], const float q2[4])
 void pow_qt_fl_normalized(float q[4], const float fac)
 {
        BLI_ASSERT_UNIT_QUAT(q);
-       const float angle = fac * saacos(q[0]); /* quat[0] = cos(0.5 * angle), but now the 0.5 and 2.0 rule out */
+       const float angle = fac * saacos(q[0]); /* quat[0] = cos(0.5 * angle),
+                                                * but now the 0.5 and 2.0 rule out */
        const float co = cosf(angle);
        const float si = sinf(angle);
        q[0] = co;
@@ -2011,12 +2012,18 @@ void quat_apply_track(float quat[4], short axis, short upflag)
        /* rotations are hard coded to match vec_to_quat */
        const float sqrt_1_2 = (float)M_SQRT1_2;
        const float quat_track[][4] = {
-               {sqrt_1_2, 0.0, -sqrt_1_2, 0.0}, /* pos-y90 */
-               {0.5, 0.5, 0.5, 0.5}, /* Quaternion((1,0,0), radians(90)) * Quaternion((0,1,0), radians(90)) */
-               {sqrt_1_2, 0.0, 0.0, sqrt_1_2}, /* pos-z90 */
-               {sqrt_1_2, 0.0, sqrt_1_2, 0.0}, /* neg-y90 */
-               {0.5, -0.5, -0.5, 0.5}, /* Quaternion((1,0,0), radians(-90)) * Quaternion((0,1,0), radians(-90)) */
-               {0.0, sqrt_1_2, sqrt_1_2, 0.0} /* no rotation */
+               /* pos-y90 */
+               {sqrt_1_2, 0.0, -sqrt_1_2, 0.0},
+               /* Quaternion((1,0,0), radians(90)) * Quaternion((0,1,0), radians(90)) */
+               {0.5, 0.5, 0.5, 0.5},
+               /* pos-z90 */
+               {sqrt_1_2, 0.0, 0.0, sqrt_1_2},
+               /* neg-y90 */
+               {sqrt_1_2, 0.0, sqrt_1_2, 0.0},
+               /* Quaternion((1,0,0), radians(-90)) * Quaternion((0,1,0), radians(-90)) */
+               {0.5, -0.5, -0.5, 0.5},
+               /* no rotation */
+               {0.0, sqrt_1_2, sqrt_1_2, 0.0}
        };
 
        assert(axis >= 0 && axis <= 5);
index ee2bab1..87f1adc 100644 (file)
@@ -288,7 +288,9 @@ static float newPerlin(float x, float y, float z)
 {
        int A, AA, AB, B, BA, BB;
        float u = floor(x), v = floor(y), w = floor(z);
-       int X = ((int)u) & 255, Y = ((int)v) & 255, Z = ((int)w) & 255;   /* FIND UNIT CUBE THAT CONTAINS POINT */
+       int X = ((int)u) & 255,
+               Y = ((int)v) & 255,
+               Z = ((int)w) & 255;   /* FIND UNIT CUBE THAT CONTAINS POINT */
        x -= u;             /* FIND RELATIVE X,Y,Z */
        y -= v;             /* OF POINT IN CUBE. */
        z -= w;
@@ -1304,7 +1306,8 @@ static float voronoi_Cr(float x, float y, float z)
 }
 
 
-/* Signed version of all 6 of the above, just 2x-1, not really correct though (range is potentially (0, sqrt(6)).
+/* Signed version of all 6 of the above, just 2x-1, not really correct though
+ * (range is potentially (0, sqrt(6)).
  * Used in the musgrave functions */
 static float voronoi_F1S(float x, float y, float z)
 {
index 5c9a56e..dd4077d 100644 (file)
@@ -342,14 +342,16 @@ bool BLI_filename_make_safe(char *fname)
                        changed = true;
                }
 
-               /* Check for forbidden names - not we have to check all combination of upper and lower cases, hence the usage
-                * of lower_fname (more efficient than using BLI_strcasestr repeatedly). */
+               /* Check for forbidden names - not we have to check all combination
+                * of upper and lower cases, hence the usage of lower_fname
+                * (more efficient than using BLI_strcasestr repeatedly). */
                BLI_str_tolower_ascii(lower_fname, len);
                for (iname = invalid_names; *iname; iname++) {
                        if (strstr(lower_fname, *iname) == lower_fname) {
                                const size_t iname_len = strlen(*iname);
-                               /* Only invalid if the whole name is made of the invalid chunk, or it has an (assumed extension) dot
-                                * just after. This means it will also catch 'valid' names like 'aux.foo.bar', but should be
+                               /* Only invalid if the whole name is made of the invalid chunk, or it has an
+                                * (assumed extension) dot just after. This means it will also catch 'valid'
+                                * names like 'aux.foo.bar', but should be
                                 * good enough for us! */
                                if ((iname_len == len) || (lower_fname[iname_len] == '.')) {
                                        *fname = '_';
@@ -1048,7 +1050,8 @@ bool BLI_path_abs(char *path, const char *basepath)
                BLI_str_replace_char(base + BLI_path_unc_prefix_len(base), '\\', '/');
 
                if (lslash) {
-                       const int baselen = (int) (lslash - base) + 1;  /* length up to and including last "/" */
+                       /* length up to and including last "/" */
+                       const int baselen = (int) (lslash - base) + 1;
                        /* use path for temp storage here, we copy back over it right away */
                        BLI_strncpy(path, tmp + 2, FILE_MAX);  /* strip "//" */
 
@@ -1501,7 +1504,8 @@ bool BLI_path_extension_glob_validate(char *ext_fnmatch)
 
        for (size_t i = strlen(ext_fnmatch); i-- > 0; ) {
                if (ext_fnmatch[i] == ';') {
-                       /* Group separator, we truncate here if we only had wildcards so far. Otherwise, all is sound and fine. */
+                       /* Group separator, we truncate here if we only had wildcards so far.
+                        * Otherwise, all is sound and fine. */
                        if (only_wildcards) {
                                ext_fnmatch[i] = '\0';
                                return true;
@@ -1515,7 +1519,8 @@ bool BLI_path_extension_glob_validate(char *ext_fnmatch)
                /* So far, only wildcards in last group of the pattern... */
                only_wildcards = true;
        }
-       /* Only one group in the pattern, so even if its only made of wildcard(s), it is assumed vaid. */
+       /* Only one group in the pattern, so even if its only made of wildcard(s),
+        * it is assumed vaid. */
        return false;
 }
 
@@ -1613,7 +1618,8 @@ void BLI_split_dirfile(const char *string, char *dir, char *file, const size_t d
 
        if (dir) {
                if (lslash) {
-                       BLI_strncpy(dir, string, MIN2(dirlen, lslash + 1)); /* +1 to include the slash and the last char */
+                       /* +1 to include the slash and the last char */
+                       BLI_strncpy(dir, string, MIN2(dirlen, lslash + 1));
                }
                else {
                        dir[0] = '\0';
index 8c0870f..5a171cd 100644 (file)
@@ -650,10 +650,13 @@ static PolyIndex *pf_ear_tip_find(
 #endif
        }
 
-       /* Desperate mode: if no vertex is an ear tip, we are dealing with a degenerate polygon (e.g. nearly collinear).
-        * Note that the input was not necessarily degenerate, but we could have made it so by clipping some valid ears.
+       /* Desperate mode: if no vertex is an ear tip,
+        * we are dealing with a degenerate polygon (e.g. nearly collinear).
+        * Note that the input was not necessarily degenerate,
+        * but we could have made it so by clipping some valid ears.
         *
-        * Idea taken from Martin Held, "FIST: Fast industrial-strength triangulation of polygons", Algorithmica (1998),
+        * Idea taken from Martin Held, "FIST: Fast industrial-strength triangulation of polygons",
+        * Algorithmica (1998),
         * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.115.291
         *
         * Return a convex or tangential vertex if one exists.
@@ -736,19 +739,22 @@ static bool pf_ear_tip_check(PolyFill *pf, PolyIndex *pi_ear_tip)
        v3 = coords[pi_ear_tip->next->index];
 
        /* Check if any point is inside the triangle formed by previous, current and next vertices.
-        * Only consider vertices that are not part of this triangle, or else we'll always find one inside. */
+        * Only consider vertices that are not part of this triangle,
+        * or else we'll always find one inside. */
 
        for (pi_curr = pi_ear_tip->next->next; pi_curr != pi_ear_tip->prev; pi_curr = pi_curr->next) {
-               /* Concave vertices can obviously be inside the candidate ear, but so can tangential vertices
-                * if they coincide with one of the triangle's vertices. */
+               /* Concave vertices can obviously be inside the candidate ear,
+                * but so can tangential vertices if they coincide with one of the triangle's vertices. */
                if (pi_curr->sign != CONVEX) {
                        const float *v = coords[pi_curr->index];
                        /* Because the polygon has clockwise winding order,
                         * the area sign will be positive if the point is strictly inside.
                         * It will be 0 on the edge, which we want to include as well. */
 
-                       /* note: check (v3, v1) first since it fails _far_ more often then the other 2 checks (those fail equally).
-                        * It's logical - the chance is low that points exist on the same side as the ear we're clipping off. */
+                       /* note: check (v3, v1) first since it fails _far_ more often then the other 2 checks
+                        * (those fail equally).
+                        * It's logical - the chance is low that points exist on the
+                        * same side as the ear we're clipping off. */
                        if ((span_tri_v2_sign(v3, v1, v) != CONCAVE) &&
                            (span_tri_v2_sign(v1, v2, v) != CONCAVE) &&
                            (span_tri_v2_sign(v2, v3, v) != CONCAVE))
index 17f3205..2266a04 100644 (file)
@@ -221,8 +221,9 @@ static void polyedge_beauty_cost_update_single(
        const uint i = e->base_index;
        /* recalculate edge */
        const float cost = polyedge_rotate_beauty_calc(coords, edges, e);
-       /* We can get cases where both choices generate very small negative costs, which leads to infinite loop.
-        * Anyway, costs above that are not worth recomputing, maybe we could even optimize it to a smaller limit?
+       /* We can get cases where both choices generate very small negative costs,
+        * which leads to infinite loop. Anyway, costs above that are not worth recomputing,
+        * maybe we could even optimize it to a smaller limit?
         * Actually, FLT_EPSILON is too small in some cases, 1e-6f seems to work OK hopefully?
         * See T43578, T49478. */
        if (cost < -1e-6f) {
index 5b1e378..ba808c7 100644 (file)
@@ -179,7 +179,8 @@ bool BLI_rcti_inside_rcti(const rcti *rct_a, const rcti *rct_b)
 }
 
 
-/* based closely on 'isect_seg_seg_v2_int', but in modified so corner cases are treated as intersections */
+/* based closely on 'isect_seg_seg_v2_int',
+ * but in modified so corner cases are treated as intersections */
 static int isect_segments_i(const int v1[2], const int v2[2], const int v3[2], const int v4[2])
 {
        const double div = (double)((v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]));
index 427a3eb..cad0490 100644 (file)
@@ -201,7 +201,8 @@ static bool boundisect(PolyFill *pf2, PolyFill *pf1)
 }
 
 
-static void mergepolysSimp(ScanFillContext *sf_ctx, PolyFill *pf1, PolyFill *pf2)    /* add pf2 to pf1 */
+/* add pf2 to pf1 */
+static void mergepolysSimp(ScanFillContext *sf_ctx, PolyFill *pf1, PolyFill *pf2)
 {
        ScanFillVert *eve;
        ScanFillEdge *eed;
@@ -502,7 +503,8 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
                                eve->f = SF_VERT_NEW;  /* flag for connectedges later on */
                                sc->vert = eve;
                                sc->edge_first = sc->edge_last = NULL;
-                               /* if (even->tmp.v == NULL) eve->tmp.u = verts; */ /* Note, debug print only will work for curve polyfill, union is in use for mesh */
+                               /* Note, debug print only will work for curve polyfill, union is in use for mesh */
+                               /* if (even->tmp.v == NULL) eve->tmp.u = verts; */
                                sc++;
                        }
                }
@@ -570,7 +572,8 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
                maxface = 2 * verts;       /* 2*verts: based at a filled circle within a triangle */
        }
        else {
-               maxface = verts - 2;       /* when we don't calc any holes, we assume face is a non overlapping loop */
+               /* when we don't calc any holes, we assume face is a non overlapping loop */
+               maxface = verts - 2;
        }
 
        sc = scdata;
@@ -593,7 +596,8 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
                        ed1 = sc->edge_first;
                        ed2 = ed1->next;
 
-                       /* commented out... the ESC here delivers corrupted memory (and doesnt work during grab) */
+                       /* commented out... the ESC here delivers corrupted memory
+                        * (and doesnt work during grab) */
                        /* if (callLocalInterruptCallBack()) break; */
                        if (totface >= maxface) {
                                /* printf("Fill error: endless loop. Escaped at vert %d,  tot: %d.\n", a, verts); */
@@ -634,15 +638,16 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
                                                                if (testedgeside(v3->xy, v1->xy, sc1->vert->xy)) {
                                                                        /* point is in triangle */
 
-                                                                       /* because multiple points can be inside triangle (concave holes) */
-                                                                       /* we continue searching and pick the one with sharpest corner */
-
+                                                                       /* Because multiple points can be inside triangle
+                                                                        * (concave holes) we continue searching and pick the
+                                                                        * one with sharpest corner. */
                                                                        if (best_sc == NULL) {
                                                                                /* even without holes we need to keep checking [#35861] */
                                                                                best_sc = sc1;
                                                                        }
                                                                        else {
-                                                                               /* prevent angle calc for the simple cases only 1 vertex is found */
+                                                                               /* Prevent angle calc for the simple cases
+                                                                                * only 1 vertex is found. */
                                                                                if (firsttime == false) {
                                                                                        angle_best_cos = cos_v2v2v2(v2->xy, v1->xy, best_sc->vert->xy);
                                                                                        firsttime = true;
index ef1df47..59ba039 100644 (file)
@@ -214,7 +214,10 @@ static bool scanfill_preprocess_self_isect(
                                                copy_v2_v2(isect->co, pt);
                                                isect->co[2] = eed->v1->co[2];
                                                isect->v = BLI_scanfill_vert_add(sf_ctx, isect->co);
-                                               isect->v->poly_nr = eed->v1->poly_nr;  /* NOTE: vert may belong to 2 polys now */
+
+                                               /* NOTE: vert may belong to 2 polys now */
+                                               isect->v->poly_nr = eed->v1->poly_nr;
+
                                                VFLAG_SET(isect->v, V_ISISECT);
                                                edge_isect_ls_add(isect_hash, eed, isect);
                                                edge_isect_ls_add(isect_hash, eed_other, isect);
index f092d27..032041d 100644 (file)
@@ -380,7 +380,8 @@ char *BLI_str_quoted_substrN(const char *__restrict str, const char *__restrict
 {
        const char *startMatch, *endMatch;
 
-       /* get the starting point (i.e. where prefix starts, and add prefixLen+1 to it to get be after the first " */
+       /* get the starting point (i.e. where prefix starts, and add prefixLen+1
+        * to it to get be after the first " */
        startMatch = strstr(str, prefix);
        if (startMatch) {
                const size_t prefixLen = strlen(prefix);
@@ -438,8 +439,8 @@ char *BLI_str_replaceN(const char *__restrict str, const char *__restrict substr
                 * copy the text up to this position and advance the current position in the string
                 */
                if (str != match) {
-                       /* add the segment of the string from str to match to the buffer, then restore the value at match
-                        */
+                       /* add the segment of the string from str to match to the buffer,
+                        * then restore the value at match */
                        BLI_dynstr_nappend(ds, str, (match - str));
 
                        /* now our current position should be set on the start of the match */
index 1e2a962..c2022f9 100644 (file)
@@ -48,7 +48,8 @@
 // #define DEBUG_STRSIZE
 
 /* array copied from glib's gutf8.c, */
-/* Note: last two values (0xfe and 0xff) are forbidden in utf-8, so they are considered 1 byte length too. */
+/* Note: last two values (0xfe and 0xff) are forbidden in utf-8,
+ * so they are considered 1 byte length too. */
 static const size_t utf8_skip_data[256] = {
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -90,8 +91,8 @@ ptrdiff_t BLI_utf8_invalid_byte(const char *str, size_t length)
                if ((c & 0xc0) != 0xc0)
                        goto utf8_error;
 
-               /* Note that since we always increase p (and decrease length) by one byte in main loop, we only add/subtract
-                * extra utf8 bytes in code below
+               /* Note that since we always increase p (and decrease length) by one byte in main loop,
+                * we only add/subtract extra utf8 bytes in code below
                 * (ab number, aka number of bytes remaining in the utf8 sequence after the initial one). */
                ab = (int)utf8_skip_data[c] - 1;
                if (length <= ab) {
@@ -272,7 +273,8 @@ char *BLI_strncat_utf8(char *__restrict dst, const char *__restrict src, size_t
 size_t BLI_strncpy_wchar_as_utf8(char *__restrict dst, const wchar_t *__restrict src, const size_t maxncpy)
 {
        const size_t maxlen = maxncpy - 1;
-       const int64_t maxlen_secured = (int64_t)maxlen - 6;  /* 6 is max utf8 length of an unicode char. */
+       /* 6 is max utf8 length of an unicode char. */
+       const int64_t maxlen_secured = (int64_t)maxlen - 6;
        size_t len = 0;
 
        BLI_assert(maxncpy != 0);
@@ -285,8 +287,8 @@ size_t BLI_strncpy_wchar_as_utf8(char *__restrict dst, const wchar_t *__restrict
                len += BLI_str_utf8_from_unicode((uint)*src++, dst + len);
        }
 
-       /* We have to be more careful for the last six bytes, to avoid buffer overflow in case utf8-encoded char
-        * would be too long for our dst buffer. */
+       /* We have to be more careful for the last six bytes,
+        * to avoid buffer overflow in case utf8-encoded char would be too long for our dst buffer. */
        while (*src) {
                char t[6];
                size_t l = BLI_str_utf8_from_unicode((uint)*src++, t);
index 4c6f27a..76d46e3 100644 (file)
@@ -364,12 +364,13 @@ static bool task_scheduler_thread_wait_pop(TaskScheduler *scheduler, Task **task
        do {
                Task *current_task;
 
-               /* Assuming we can only have a void queue in 'exit' case here seems logical (we should only be here after
-                * our worker thread has been woken up from a condition_wait(), which only happens after a new task was
-                * added to the queue), but it is wrong.
-                * Waiting on condition may wake up the thread even if condition is not signaled (spurious wake-ups), and some
-                * race condition may also empty the queue **after** condition has been signaled, but **before** awoken thread
-                * reaches this point...
+               /* Assuming we can only have a void queue in 'exit' case here seems logical
+                * (we should only be here after our worker thread has been woken up from a
+                * condition_wait(), which only happens after a new task was added to the queue),
+                * but it is wrong.
+                * Waiting on condition may wake up the thread even if condition is not signaled
+                * (spurious wake-ups), and some race condition may also empty the queue **after**
+                * condition has been signaled, but **before** awoken thread reaches this point...
                 * See http://stackoverflow.com/questions/8594591
                 *
                 * So we only abort here if do_exit is set.
@@ -635,7 +636,8 @@ static TaskPool *task_pool_create_ex(TaskScheduler *scheduler,
        TaskPool *pool = MEM_mallocN(sizeof(TaskPool), "TaskPool");
 
 #ifndef NDEBUG
-       /* Assert we do not try to create a background pool from some parent task - those only work OK from main thread. */
+       /* Assert we do not try to create a background pool from some parent task -
+        * those only work OK from main thread. */
        if (is_background) {
                const pthread_t thread_id = pthread_self();
                int i = scheduler->num_threads;
index ab7766d..5f710ad 100644 (file)
@@ -135,7 +135,8 @@ size_t BLI_timecode_string_from_time(
                }
                case USER_TIMECODE_SMPTE_MSF:
                {
-                       /* reduced SMPTE format that always shows minutes, seconds, frames. Hours only shown as needed. */
+                       /* reduced SMPTE format that always shows minutes, seconds, frames.
+                        * Hours only shown as needed. */
                        if (hours) {
                                rlen = BLI_snprintf_rlen(str, maxncpy, "%s%02d:%02d:%02d:%02d", neg, hours, minutes, seconds, frames);
                        }
@@ -165,7 +166,8 @@ size_t BLI_timecode_string_from_time(
                }
                case USER_TIMECODE_SUBRIP:
                {
-                       /* SubRip, like SMPTE milliseconds but seconds and milliseconds are separated by a comma, not a dot... */
+                       /* SubRip, like SMPTE milliseconds but seconds and milliseconds
+                        * are separated by a comma, not a dot... */
 
                        /* precision of decimal part */
                        const int ms_dp = (power <= 0) ? (1 - power) : 1;
index 37b7ca3..e7e5807 100644 (file)
@@ -63,7 +63,8 @@ BLI_INLINE int FLOORI(float x)
        return ((x >= 0.f) || (float)r == x) ? r : (r - 1);
 }
 
-/* clamp function, cannot use the CLAMPIS macro, it sometimes returns unwanted results apparently related to
+/* clamp function, cannot use the CLAMPIS macro,
+ * it sometimes returns unwanted results apparently related to
  * gcc optimization flag -fstrict-overflow which is enabled at -O2
  *
  * this causes the test (x + 2) < 0 with int x == 2147483647 to return false (x being an integer,