Cleanup: style, use braces for blenlib
authorCampbell Barton <ideasman42@gmail.com>
Wed, 27 Mar 2019 02:16:10 +0000 (13:16 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 27 Mar 2019 02:17:30 +0000 (13:17 +1100)
53 files changed:
source/blender/blenlib/intern/BLI_args.c
source/blender/blenlib/intern/BLI_dial_2d.c
source/blender/blenlib/intern/BLI_dynstr.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/BLI_linklist.c
source/blender/blenlib/intern/BLI_timer.c
source/blender/blenlib/intern/DLRB_tree.c
source/blender/blenlib/intern/boxpack_2d.c
source/blender/blenlib/intern/convexhull_2d.c
source/blender/blenlib/intern/dynlib.c
source/blender/blenlib/intern/easing.c
source/blender/blenlib/intern/edgehash.c
source/blender/blenlib/intern/expr_pylike_eval.c
source/blender/blenlib/intern/fileops.c
source/blender/blenlib/intern/freetypefont.c
source/blender/blenlib/intern/gsqueue.c
source/blender/blenlib/intern/hash_md5.c
source/blender/blenlib/intern/jitter_2d.c
source/blender/blenlib/intern/lasso_2d.c
source/blender/blenlib/intern/listbase.c
source/blender/blenlib/intern/math_base.c
source/blender/blenlib/intern/math_base_inline.c
source/blender/blenlib/intern/math_color.c
source/blender/blenlib/intern/math_color_inline.c
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/math_geom_inline.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/math_solvers.c
source/blender/blenlib/intern/math_statistics.c
source/blender/blenlib/intern/math_vector.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/rand.c
source/blender/blenlib/intern/rct.c
source/blender/blenlib/intern/scanfill.c
source/blender/blenlib/intern/smallhash.c
source/blender/blenlib/intern/sort.c
source/blender/blenlib/intern/sort_utils.c
source/blender/blenlib/intern/storage.c
source/blender/blenlib/intern/string.c
source/blender/blenlib/intern/string_utf8.c
source/blender/blenlib/intern/string_utils.c
source/blender/blenlib/intern/task.c
source/blender/blenlib/intern/threads.c
source/blender/blenlib/intern/uvproject.c
source/blender/blenlib/intern/voronoi_2d.c
source/blender/blenlib/intern/winstuff.c
source/blender/blenlib/intern/winstuff_dir.c

index dbd609d..61619bc 100644 (file)
@@ -71,8 +71,9 @@ static uint case_strhash(const void *ptr)
        uint i = 0;
        unsigned char c;
 
-       while ( (c = tolower(*s++)) )
+       while ((c = tolower(*s++))) {
                i = i * 37 + c;
+       }
 
        return i;
 }
@@ -150,8 +151,9 @@ static bArgDoc *internalDocs(struct bArgs *ba, const char *short_arg, const char
 
        d = MEM_callocN(sizeof(bArgDoc), "bArgDoc");
 
-       if (doc == NULL)
+       if (doc == NULL) {
                doc = NO_DOCS;
+       }
 
        d->short_arg = short_arg;
        d->long_arg = long_arg;
@@ -200,11 +202,13 @@ void BLI_argsAddCase(struct bArgs *ba, int pass,
 {
        bArgDoc *d = internalDocs(ba, short_arg, long_arg, doc);
 
-       if (short_arg)
+       if (short_arg) {
                internalAdd(ba, short_arg, pass, short_case, cb, data, d);
+       }
 
-       if (long_arg)
+       if (long_arg) {
                internalAdd(ba, long_arg, pass, long_case, cb, data, d);
+       }
 }
 
 void BLI_argsAdd(struct bArgs *ba, int pass,
@@ -216,12 +220,15 @@ void BLI_argsAdd(struct bArgs *ba, int pass,
 
 static void internalDocPrint(bArgDoc *d)
 {
-       if (d->short_arg && d->long_arg)
+       if (d->short_arg && d->long_arg) {
                printf("%s or %s", d->short_arg, d->long_arg);
-       else if (d->short_arg)
+       }
+       else if (d->short_arg) {
                printf("%s", d->short_arg);
-       else if (d->long_arg)
+       }
+       else if (d->long_arg) {
                printf("%s", d->long_arg);
+       }
 
        printf(" %s\n\n", d->documentation);
 }
@@ -284,8 +291,9 @@ void BLI_argsParse(struct bArgs *ba, int pass, BA_ArgCallback default_cb, void *
                                }
                                else if (retval == -1) {
                                        if (a) {
-                                               if (a->key->pass != -1)
+                                               if (a->key->pass != -1) {
                                                        ba->passes[i] = pass;
+                                               }
                                        }
                                        break;
                                }
index 882d239..dd983fe 100644 (file)
@@ -88,10 +88,12 @@ float BLI_dial_angle(Dial *dial, const float current_position[2])
                if ((angle * dial->last_angle < 0.0f) &&
                    (fabsf(dial->last_angle) > (float)M_PI_2))
                {
-                       if (dial->last_angle < 0.0f)
+                       if (dial->last_angle < 0.0f) {
                                dial->rotations--;
-                       else
+                       }
+                       else {
                                dial->rotations++;
+                       }
                }
                dial->last_angle = angle;
 
index 9868210..ef45d7b 100644 (file)
@@ -112,10 +112,12 @@ void BLI_dynstr_append(DynStr *__restrict ds, const char *cstr)
        memcpy(dse->str, cstr, cstrlen + 1);
        dse->next = NULL;
 
-       if (!ds->last)
+       if (!ds->last) {
                ds->last = ds->elems = dse;
-       else
+       }
+       else {
                ds->last = ds->last->next = dse;
+       }
 
        ds->curlen += cstrlen;
 }
@@ -137,10 +139,12 @@ void BLI_dynstr_nappend(DynStr *__restrict ds, const char *cstr, int len)
        dse->str[cstrlen] = '\0';
        dse->next = NULL;
 
-       if (!ds->last)
+       if (!ds->last) {
                ds->last = ds->elems = dse;
-       else
+       }
+       else {
                ds->last = ds->last->next = dse;
+       }
 
        ds->curlen += cstrlen;
 }
@@ -154,10 +158,12 @@ void BLI_dynstr_vappendf(DynStr *__restrict ds, const char *__restrict format, v
 
        while (1) {
                va_list args_cpy;
-               if (len == sizeof(fixedmessage))
+               if (len == sizeof(fixedmessage)) {
                        message = fixedmessage;
-               else
+               }
+               else {
                        message = MEM_callocN(sizeof(char) * len, "BLI_dynstr_appendf");
+               }
 
                /* cant reuse the same args, so work on a copy */
                va_copy(args_cpy, args);
@@ -167,8 +173,9 @@ void BLI_dynstr_vappendf(DynStr *__restrict ds, const char *__restrict format, v
                if (retval == -1) {
                        /* -1 means not enough space, but on windows it may also mean
                         * there is a formatting error, so we impose a maximum length */
-                       if (message != fixedmessage)
+                       if (message != fixedmessage) {
                                MEM_freeN(message);
+                       }
                        message = NULL;
 
                        len *= 2;
@@ -179,22 +186,25 @@ void BLI_dynstr_vappendf(DynStr *__restrict ds, const char *__restrict format, v
                }
                else if (retval >= len) {
                        /* in C99 the actual length required is returned */
-                       if (message != fixedmessage)
+                       if (message != fixedmessage) {
                                MEM_freeN(message);
+                       }
                        message = NULL;
 
                        /* retval doesn't include \0 terminator */
                        len = retval + 1;
                }
-               else
+               else {
                        break;
+               }
        }
 
        if (message) {
                BLI_dynstr_append(ds, message);
 
-               if (message != fixedmessage)
+               if (message != fixedmessage) {
                        MEM_freeN(message);
+               }
        }
 }
 
@@ -217,10 +227,12 @@ void BLI_dynstr_appendf(DynStr *__restrict ds, const char *__restrict format, ..
         * va_start/va_end have to be called for each vsnprintf call */
 
        while (1) {
-               if (len == sizeof(fixedmessage))
+               if (len == sizeof(fixedmessage)) {
                        message = fixedmessage;
-               else
+               }
+               else {
                        message = MEM_callocN(sizeof(char) * (len), "BLI_dynstr_appendf");
+               }
 
                va_start(args, format);
                retval = vsnprintf(message, len, format, args);
@@ -229,8 +241,9 @@ void BLI_dynstr_appendf(DynStr *__restrict ds, const char *__restrict format, ..
                if (retval == -1) {
                        /* -1 means not enough space, but on windows it may also mean
                         * there is a formatting error, so we impose a maximum length */
-                       if (message != fixedmessage)
+                       if (message != fixedmessage) {
                                MEM_freeN(message);
+                       }
                        message = NULL;
 
                        len *= 2;
@@ -241,22 +254,25 @@ void BLI_dynstr_appendf(DynStr *__restrict ds, const char *__restrict format, ..
                }
                else if (retval >= len) {
                        /* in C99 the actual length required is returned */
-                       if (message != fixedmessage)
+                       if (message != fixedmessage) {
                                MEM_freeN(message);
+                       }
                        message = NULL;
 
                        /* retval doesn't include \0 terminator */
                        len = retval + 1;
                }
-               else
+               else {
                        break;
+               }
        }
 
        if (message) {
                BLI_dynstr_append(ds, message);
 
-               if (message != fixedmessage)
+               if (message != fixedmessage) {
                        MEM_freeN(message);
+               }
        }
 }
 
index 8cbba21..243c7d9 100644 (file)
@@ -65,28 +65,36 @@ static int bli_compare(struct direntry *entry1, struct direntry *entry2)
 
        /* directories come before non-directories */
        if (S_ISDIR(entry1->type)) {
-               if (S_ISDIR(entry2->type) == 0) return (-1);
+               if (S_ISDIR(entry2->type) == 0) {
+                       return -1;
+               }
        }
        else {
-               if (S_ISDIR(entry2->type)) return (1);
+               if (S_ISDIR(entry2->type)) {
+                       return 1;
+               }
        }
        /* non-regular files come after regular files */
        if (S_ISREG(entry1->type)) {
-               if (S_ISREG(entry2->type) == 0) return (-1);
+               if (S_ISREG(entry2->type) == 0) {
+                       return -1;
+               }
        }
        else {
-               if (S_ISREG(entry2->type)) return (1);
+               if (S_ISREG(entry2->type)) {
+                       return 1;
+               }
        }
        /* arbitrary, but consistent, ordering of different types of non-regular files */
-       if ((entry1->type & S_IFMT) < (entry2->type & S_IFMT)) return (-1);
-       if ((entry1->type & S_IFMT) > (entry2->type & S_IFMT)) return (1);
+       if ((entry1->type & S_IFMT) < (entry2->type & S_IFMT)) { return -1; }
+       if ((entry1->type & S_IFMT) > (entry2->type & S_IFMT)) { return  1; }
 
        /* OK, now we know their S_IFMT fields are the same, go on to a name comparison */
        /* make sure "." and ".." are always first */
-       if (FILENAME_IS_CURRENT(entry1->relname)) return (-1);
-       if (FILENAME_IS_CURRENT(entry2->relname)) return (1);
-       if (FILENAME_IS_PARENT(entry1->relname)) return (-1);
-       if (FILENAME_IS_PARENT(entry2->relname)) return (1);
+       if (FILENAME_IS_CURRENT(entry1->relname)) { return -1; }
+       if (FILENAME_IS_CURRENT(entry2->relname)) { return  1; }
+       if (FILENAME_IS_PARENT(entry1->relname))  { return -1; }
+       if (FILENAME_IS_PARENT(entry2->relname))  { return  1; }
 
        return (BLI_natstrcmp(entry1->relname, entry2->relname));
 }
@@ -159,8 +167,9 @@ static void bli_builddir(struct BuildDirCtx *dir_ctx, const char *dirname)
                                }
                        }
 
-                       if (dir_ctx->files == NULL)
+                       if (dir_ctx->files == NULL) {
                                dir_ctx->files = (struct direntry *)MEM_mallocN(newnum * sizeof(struct direntry), __func__);
+                       }
 
                        if (dir_ctx->files) {
                                struct dirlink * dlink = (struct dirlink *) dirbase.first;
@@ -253,7 +262,9 @@ void BLI_filelist_entry_size_to_string(
 
        if (size > 1024.0) {
                const char **u;
-               for (u = compact ? units_compact : units, size /= 1024.0; size > 1024.0 && *(u + 1); u++, size /= 1024.0);
+               for (u = compact ? units_compact : units, size /= 1024.0; size > 1024.0 && *(u + 1); u++, size /= 1024.0) {
+                       /* pass */
+               }
                fmt =  size > 100.0 ? "%.0f %s" : (size > 10.0 ? "%.1f %s" : "%.2f %s");
                unit = *u;
        }
@@ -284,18 +295,30 @@ void BLI_filelist_entry_mode_to_string(
        BLI_strncpy(r_mode2, types[(mode & 0070) >> 3], sizeof(*r_mode2) * FILELIST_DIRENTRY_MODE_LEN);
        BLI_strncpy(r_mode3, types[(mode & 0007)],      sizeof(*r_mode3) * FILELIST_DIRENTRY_MODE_LEN);
 
-       if (((mode & S_ISGID) == S_ISGID) && (r_mode2[2] == '-')) r_mode2[2] = 'l';
+       if (((mode & S_ISGID) == S_ISGID) && (r_mode2[2] == '-')) {
+               r_mode2[2] = 'l';
+       }
 
        if (mode & (S_ISUID | S_ISGID)) {
-               if (r_mode1[2] == 'x') r_mode1[2] = 's';
-               else r_mode1[2] = 'S';
+               if (r_mode1[2] == 'x') {
+                       r_mode1[2] = 's';
+               }
+               else {
+                       r_mode1[2] = 'S';
+               }
 
-               if (r_mode2[2] == 'x') r_mode2[2] = 's';
+               if (r_mode2[2] == 'x') {
+                       r_mode2[2] = 's';
+               }
        }
 
        if (mode & S_ISVTX) {
-               if (r_mode3[2] == 'x') r_mode3[2] = 't';
-               else r_mode3[2] = 'T';
+               if (r_mode3[2] == 'x') {
+                       r_mode3[2] = 't';
+               }
+               else {
+                       r_mode3[2] = 'T';
+               }
        }
 #endif
 }
index fc432c8..af3a7a4 100644 (file)
@@ -241,7 +241,9 @@ static void ghash_buckets_resize(GHash *gh, const uint nbuckets)
                                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;
-                               for (e = buckets_old[i]; e && e->next; e = e->next);
+                               for (e = buckets_old[i]; e && e->next; e = e->next) {
+                                       /* pass */
+                               }
                                if (e) {
                                        e->next = buckets_new[bucket_index];
                                        buckets_new[bucket_index] = buckets_old[i];
@@ -983,8 +985,9 @@ void BLI_ghash_clear_ex(
         GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp,
         const uint nentries_reserve)
 {
-       if (keyfreefp || valfreefp)
+       if (keyfreefp || valfreefp) {
                ghash_free_cb(gh, keyfreefp, valfreefp);
+       }
 
        ghash_buckets_reset(gh, nentries_reserve);
        BLI_mempool_clear_ex(gh->entrypool, nentries_reserve ? (int)nentries_reserve : -1);
@@ -1008,8 +1011,9 @@ void BLI_ghash_clear(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfree
 void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
 {
        BLI_assert((int)gh->nentries == BLI_mempool_len(gh->entrypool));
-       if (keyfreefp || valfreefp)
+       if (keyfreefp || valfreefp) {
                ghash_free_cb(gh, keyfreefp, valfreefp);
+       }
 
        MEM_freeN(gh->buckets);
        BLI_mempool_destroy(gh->entrypool);
@@ -1069,8 +1073,9 @@ void BLI_ghashIterator_init(GHashIterator *ghi, GHash *gh)
        if (gh->nentries) {
                do {
                        ghi->curBucket++;
-                       if (UNLIKELY(ghi->curBucket == ghi->gh->nbuckets))
+                       if (UNLIKELY(ghi->curBucket == ghi->gh->nbuckets)) {
                                break;
+                       }
                        ghi->curEntry = ghi->gh->buckets[ghi->curBucket];
                } while (!ghi->curEntry);
        }
@@ -1087,8 +1092,9 @@ void BLI_ghashIterator_step(GHashIterator *ghi)
                ghi->curEntry = ghi->curEntry->next;
                while (!ghi->curEntry) {
                        ghi->curBucket++;
-                       if (ghi->curBucket == ghi->gh->nbuckets)
+                       if (ghi->curBucket == ghi->gh->nbuckets) {
                                break;
+                       }
                        ghi->curEntry = ghi->gh->buckets[ghi->curBucket];
                }
        }
index 7199c41..7887c55 100644 (file)
@@ -272,24 +272,30 @@ 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)
 {
        if ((a[mid])->bv[axis] < (a[lo])->bv[axis]) {
-               if ((a[hi])->bv[axis] < (a[mid])->bv[axis])
+               if ((a[hi])->bv[axis] < (a[mid])->bv[axis]) {
                        return a[mid];
+               }
                else {
-                       if ((a[hi])->bv[axis] < (a[lo])->bv[axis])
+                       if ((a[hi])->bv[axis] < (a[lo])->bv[axis]) {
                                return a[hi];
-                       else
+                       }
+                       else {
                                return a[lo];
+                       }
                }
        }
        else {
                if ((a[hi])->bv[axis] < (a[mid])->bv[axis]) {
-                       if ((a[hi])->bv[axis] < (a[lo])->bv[axis])
+                       if ((a[hi])->bv[axis] < (a[lo])->bv[axis]) {
                                return a[lo];
-                       else
+                       }
+                       else {
                                return a[hi];
+                       }
                }
-               else
+               else {
                        return a[mid];
+               }
        }
 }
 
@@ -320,10 +326,12 @@ static void build_skip_links(BVHTree *tree, BVHNode *node, BVHNode *left, BVHNod
        node->skip[1] = right;
 
        for (i = 0; i < node->totnode; i++) {
-               if (i + 1 < node->totnode)
+               if (i + 1 < node->totnode) {
                        build_skip_links(tree, node->children[i], left, node->children[i + 1]);
-               else
+               }
+               else {
                        build_skip_links(tree, node->children[i], left, right);
+               }
 
                left = node->children[i];
        }
@@ -349,10 +357,12 @@ static void create_kdop_hull(const BVHTree *tree, BVHNode *node, const float *co
                /* for all Axes. */
                for (axis_iter = tree->start_axis; axis_iter < tree->stop_axis; axis_iter++) {
                        newminmax = dot_v3v3(&co[k * 3], bvhtree_kdop_axes[axis_iter]);
-                       if (newminmax < bv[2 * axis_iter])
+                       if (newminmax < bv[2 * axis_iter]) {
                                bv[2 * axis_iter] = newminmax;
-                       if (newminmax > bv[(2 * axis_iter) + 1])
+                       }
+                       if (newminmax > bv[(2 * axis_iter) + 1]) {
                                bv[(2 * axis_iter) + 1] = newminmax;
+                       }
                }
        }
 }
@@ -375,12 +385,14 @@ static void refit_kdop_hull(const BVHTree *tree, BVHNode *node, int start, int e
                /* for all Axes. */
                for (axis_iter = tree->start_axis; axis_iter < tree->stop_axis; axis_iter++) {
                        newmin = node_bv[(2 * axis_iter)];
-                       if ((newmin < bv[(2 * axis_iter)]))
+                       if ((newmin < bv[(2 * axis_iter)])) {
                                bv[(2 * axis_iter)] = newmin;
+                       }
 
                        newmax = node_bv[(2 * axis_iter) + 1];
-                       if ((newmax > bv[(2 * axis_iter) + 1]))
+                       if ((newmax > bv[(2 * axis_iter) + 1])) {
                                bv[(2 * axis_iter) + 1] = newmax;
+                       }
                }
        }
 
@@ -397,16 +409,20 @@ static char get_largest_axis(const float *bv)
        middle_point[1] = (bv[3]) - (bv[2]); /* y axis */
        middle_point[2] = (bv[5]) - (bv[4]); /* z axis */
        if (middle_point[0] > middle_point[1]) {
-               if (middle_point[0] > middle_point[2])
+               if (middle_point[0] > middle_point[2]) {
                        return 1;  /* max x axis */
-               else
+               }
+               else {
                        return 5;  /* max z axis */
+               }
        }
        else {
-               if (middle_point[1] > middle_point[2])
+               if (middle_point[1] > middle_point[2]) {
                        return 3;  /* max y axis */
-               else
+               }
+               else {
                        return 5;  /* max z axis */
+               }
        }
 }
 
@@ -424,16 +440,19 @@ static void node_join(BVHTree *tree, BVHNode *node)
                if (node->children[i]) {
                        for (axis_iter = tree->start_axis; axis_iter < tree->stop_axis; axis_iter++) {
                                /* update minimum */
-                               if (node->children[i]->bv[(2 * axis_iter)] < node->bv[(2 * axis_iter)])
+                               if (node->children[i]->bv[(2 * axis_iter)] < node->bv[(2 * axis_iter)]) {
                                        node->bv[(2 * axis_iter)] = node->children[i]->bv[(2 * axis_iter)];
+                               }
 
                                /* update maximum */
-                               if (node->children[i]->bv[(2 * axis_iter) + 1] > node->bv[(2 * axis_iter) + 1])
+                               if (node->children[i]->bv[(2 * axis_iter) + 1] > node->bv[(2 * axis_iter) + 1]) {
                                        node->bv[(2 * axis_iter) + 1] = node->children[i]->bv[(2 * axis_iter) + 1];
+                               }
                        }
                }
-               else
+               else {
                        break;
+               }
        }
 }
 
@@ -448,7 +467,9 @@ static void bvhtree_print_tree(BVHTree *tree, BVHNode *node, int depth)
        int i;
        axis_t axis_iter;
 
-       for (i = 0; i < depth; i++) printf(" ");
+       for (i = 0; i < depth; i++) {
+               printf(" ");
+       }
        printf(" - %d (%ld): ", node->index, (long int)(node - tree->nodearray));
        for (axis_iter = (axis_t)(2 * tree->start_axis);
             axis_iter < (axis_t)(2 * tree->stop_axis);
@@ -458,9 +479,11 @@ static void bvhtree_print_tree(BVHTree *tree, BVHNode *node, int depth)
        }
        printf("\n");
 
-       for (i = 0; i < tree->tree_type; i++)
-               if (node->children[i])
+       for (i = 0; i < tree->tree_type; i++) {
+               if (node->children[i]) {
                        bvhtree_print_tree(tree, node->children[i], depth + 1);
+               }
+       }
 }
 
 static void bvhtree_info(BVHTree *tree)
@@ -498,8 +521,9 @@ static void bvhtree_verify(BVHTree *tree)
                }
                else {
                        for (j = 0; j < tree->tree_type; j++) {
-                               if (tree->nodes[i]->parent->children[j] == tree->nodes[i])
+                               if (tree->nodes[i]->parent->children[j] == tree->nodes[i]) {
                                        check = 1;
+                               }
                        }
                        if (!check) {
                                printf("Parent child relationship doesn't match: %d\n", i);
@@ -515,8 +539,9 @@ static void bvhtree_verify(BVHTree *tree)
                }
                else {
                        for (j = 0; j < tree->tree_type; j++) {
-                               if (tree->nodearray[i].parent->children[j] == &tree->nodearray[i])
+                               if (tree->nodearray[i].parent->children[j] == &tree->nodearray[i]) {
                                        check = 1;
+                               }
                        }
                        if (!check) {
                                printf("Parent child relationship doesn't match: %d\n", i);
@@ -580,12 +605,15 @@ static void build_implicit_tree_helper(const BVHTree *tree, BVHBuildHelper *data
 static int implicit_leafs_index(const BVHBuildHelper *data, const int depth, const int child_index)
 {
        int min_leaf_index = child_index * data->leafs_per_child[depth - 1];
-       if (min_leaf_index <= data->remain_leafs)
+       if (min_leaf_index <= data->remain_leafs) {
                return min_leaf_index;
-       else if (data->leafs_per_child[depth])
+       }
+       else if (data->leafs_per_child[depth]) {
                return data->totleafs - (data->branches_on_level[depth - 1] - child_index) * data->leafs_per_child[depth];
-       else
+       }
+       else {
                return data->remain_leafs;
+       }
 }
 
 /**
@@ -636,8 +664,9 @@ static void split_leafs(BVHNode **leafs_array, const int nth[], const int partit
 {
        int i;
        for (i = 0; i < partitions - 1; i++) {
-               if (nth[i] >= nth[partitions])
+               if (nth[i] >= nth[partitions]) {
                        break;
+               }
 
                partition_nth_element(leafs_array, nth[i], nth[partitions], nth[i + 1], split_axis);
        }
@@ -970,15 +999,17 @@ bool BLI_bvhtree_update_node(BVHTree *tree, int index, const float co[3], const
        axis_t axis_iter;
 
        /* check if index exists */
-       if (index > tree->totleaf)
+       if (index > tree->totleaf) {
                return false;
+       }
 
        node = tree->nodearray + index;
 
        create_kdop_hull(tree, node, co, numpoints, 0);
 
-       if (co_moving)
+       if (co_moving) {
                create_kdop_hull(tree, node, co_moving, numpoints, 1);
+       }
 
        /* inflate the bv with some epsilon */
        for (axis_iter = tree->start_axis; axis_iter < tree->stop_axis; axis_iter++) {
@@ -999,8 +1030,9 @@ void BLI_bvhtree_update_tree(BVHTree *tree)
        BVHNode **root  = tree->nodes + tree->totleaf;
        BVHNode **index = tree->nodes + tree->totleaf + tree->totbranch - 1;
 
-       for (; index >= root; index--)
+       for (; index >= root; index--) {
                node_join(tree, *index);
+       }
 }
 /**
  * Number of times #BLI_bvhtree_insert has been called.
@@ -1225,8 +1257,9 @@ BVHTreeOverlap *BLI_bvhtree_overlap(
                    bvhtree_overlap_task_cb,
                    &settings);
 
-       for (j = 0; j < thread_num; j++)
+       for (j = 0; j < thread_num; j++) {
                total += BLI_stack_count(data[j].overlap);
+       }
 
        to = overlap = MEM_mallocN(sizeof(BVHTreeOverlap) * total, "BVHTreeOverlap");
 
@@ -1258,10 +1291,12 @@ static float calc_nearest_point_squared(const float proj[3], BVHNode *node, floa
        /* nearest on AABB hull */
        for (i = 0; i != 3; i++, bv += 2) {
                float val = proj[i];
-               if (bv[0] > val)
+               if (bv[0] > val) {
                        val = bv[0];
-               if (bv[1] < val)
+               }
+               if (bv[1] < val) {
                        val = bv[1];
+               }
                nearest[i] = val;
        }
 
@@ -1272,8 +1307,9 @@ static float calc_nearest_point_squared(const float proj[3], BVHNode *node, floa
 static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
 {
        if (node->totnode == 0) {
-               if (data->callback)
+               if (data->callback) {
                        data->callback(data->userdata, node->index, data->co, &data->nearest);
+               }
                else {
                        data->nearest.index = node->index;
                        data->nearest.dist_sq = calc_nearest_point_squared(data->proj, node, data->nearest.co);
@@ -1287,15 +1323,17 @@ static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
                if (data->proj[node->main_axis] <= node->children[0]->bv[node->main_axis * 2 + 1]) {
 
                        for (i = 0; i != node->totnode; i++) {
-                               if (calc_nearest_point_squared(data->proj, node->children[i], nearest) >= data->nearest.dist_sq)
+                               if (calc_nearest_point_squared(data->proj, node->children[i], nearest) >= data->nearest.dist_sq) {
                                        continue;
+                               }
                                dfs_find_nearest_dfs(data, node->children[i]);
                        }
                }
                else {
                        for (i = node->totnode - 1; i >= 0; i--) {
-                               if (calc_nearest_point_squared(data->proj, node->children[i], nearest) >= data->nearest.dist_sq)
+                               if (calc_nearest_point_squared(data->proj, node->children[i], nearest) >= data->nearest.dist_sq) {
                                        continue;
+                               }
                                dfs_find_nearest_dfs(data, node->children[i]);
                        }
                }
@@ -1316,8 +1354,9 @@ static void dfs_find_nearest_begin(BVHNearestData *data, BVHNode *node)
 static void heap_find_nearest_inner(BVHNearestData *data, HeapSimple *heap, BVHNode *node)
 {
        if (node->totnode == 0) {
-               if (data->callback)
+               if (data->callback) {
                        data->callback(data->userdata, node->index, data->co, &data->nearest);
+               }
                else {
                        data->nearest.index = node->index;
                        data->nearest.dist_sq = calc_nearest_point_squared(data->proj, node, data->nearest.co);
@@ -1441,15 +1480,25 @@ static float ray_nearest_hit(const BVHRayCastData *data, const float bv[6])
                        float lu = (bv[1] + data->ray.radius - data->ray.origin[i]) / data->ray_dot_axis[i];
 
                        if (data->ray_dot_axis[i] > 0.0f) {
-                               if (ll > low) low = ll;
-                               if (lu < upper) upper = lu;
+                               if (ll > low) {
+                                       low = ll;
+                               }
+                               if (lu < upper) {
+                                       upper = lu;
+                               }
                        }
                        else {
-                               if (lu > low) low = lu;
-                               if (ll < upper) upper = ll;
+                               if (lu > low) {
+                                       low = lu;
+                               }
+                               if (ll < upper) {
+                                       upper = ll;
+                               }
                        }
 
-                       if (low > upper) return FLT_MAX;
+                       if (low > upper) {
+                               return FLT_MAX;
+                       }
                }
        }
        return low;
@@ -1622,8 +1671,9 @@ int BLI_bvhtree_ray_cast_ex(
        }
 
 
-       if (hit)
+       if (hit) {
                memcpy(hit, &data.hit, sizeof(*hit));
+       }
 
        return data.hit.index;
 }
@@ -1750,8 +1800,9 @@ static void dfs_range_query(RangeQueryData *data, BVHNode *node)
                                        data->hits++;
                                        data->callback(data->userdata, node->children[i]->index, data->center, dist_sq);
                                }
-                               else
+                               else {
                                        dfs_range_query(data, node->children[i]);
+                               }
                        }
                }
        }
@@ -1781,8 +1832,9 @@ int BLI_bvhtree_range_query(
                                data.hits++;
                                data.callback(data.userdata, root->index, co, dist_sq);
                        }
-                       else
+                       else {
                                dfs_range_query(&data, root);
+                       }
                }
        }
 
index 4649927..3f99f65 100644 (file)
@@ -41,8 +41,9 @@ int BLI_linklist_count(const LinkNode *list)
 {
        int len;
 
-       for (len = 0; list; list = list->next)
+       for (len = 0; list; list = list->next) {
                len++;
+       }
 
        return len;
 }
@@ -51,9 +52,11 @@ int BLI_linklist_index(const LinkNode *list, void *ptr)
 {
        int index;
 
-       for (index = 0; list; list = list->next, index++)
-               if (list->link == ptr)
+       for (index = 0; list; list = list->next, index++) {
+               if (list->link == ptr) {
                        return index;
+               }
+       }
 
        return -1;
 }
@@ -62,9 +65,11 @@ LinkNode *BLI_linklist_find(LinkNode *list, int index)
 {
        int i;
 
-       for (i = 0; list; list = list->next, i++)
-               if (i == index)
+       for (i = 0; list; list = list->next, i++) {
+               if (i == index) {
                        return list;
+               }
+       }
 
        return NULL;
 }
@@ -268,8 +273,9 @@ void BLI_linklist_free(LinkNode *list, LinkNodeFreeFP freefunc)
        while (list) {
                LinkNode *next = list->next;
 
-               if (freefunc)
+               if (freefunc) {
                        freefunc(list->link);
+               }
                MEM_freeN(list);
 
                list = next;
@@ -281,8 +287,9 @@ void BLI_linklist_free_pool(LinkNode *list, LinkNodeFreeFP freefunc, struct BLI_
        while (list) {
                LinkNode *next = list->next;
 
-               if (freefunc)
+               if (freefunc) {
                        freefunc(list->link);
+               }
                BLI_mempool_free(mempool, list);
 
                list = next;
@@ -303,8 +310,9 @@ void BLI_linklist_freeN(LinkNode *list)
 
 void BLI_linklist_apply(LinkNode *list, LinkNodeApplyFP applyfunc, void *userdata)
 {
-       for (; list; list = list->next)
+       for (; list; list = list->next) {
                applyfunc(list->link, userdata);
+       }
 }
 
 /* -------------------------------------------------------------------- */
index d361a1c..5fcdd85 100644 (file)
@@ -112,8 +112,12 @@ static void execute_functions_if_necessary(void)
        double current_time = GET_TIME();
 
        LISTBASE_FOREACH(TimedFunction *, timed_func, &GlobalTimer.funcs) {
-               if (timed_func->tag_removal) continue;
-               if (timed_func->next_time > current_time) continue;
+               if (timed_func->tag_removal) {
+                       continue;
+               }
+               if (timed_func->next_time > current_time) {
+                       continue;
+               }
 
                double ret = timed_func->func(timed_func->uuid, timed_func->user_data);
 
index e74b101..46818c5 100644 (file)
@@ -40,8 +40,9 @@ DLRBT_Tree *BLI_dlrbTree_new(void)
 /* Just zero out the pointers used */
 void BLI_dlrbTree_init(DLRBT_Tree *tree)
 {
-       if (tree == NULL)
+       if (tree == NULL) {
                return;
+       }
 
        tree->first = tree->last = tree->root = NULL;
 }
@@ -50,8 +51,9 @@ void BLI_dlrbTree_init(DLRBT_Tree *tree)
 static void recursive_tree_free_nodes(DLRBT_Node *node)
 {
        /* sanity check */
-       if (node == NULL)
+       if (node == NULL) {
                return;
+       }
 
        /* free child nodes + subtrees */
        recursive_tree_free_nodes(node->left);
@@ -64,8 +66,9 @@ static void recursive_tree_free_nodes(DLRBT_Node *node)
 /* Free the given tree's data but not the tree itself */
 void BLI_dlrbTree_free(DLRBT_Tree *tree)
 {
-       if (tree == NULL)
+       if (tree == NULL) {
                return;
+       }
 
        /* if the list-base stuff is set, just use that (and assume its set),
         * otherwise, we'll need to traverse the tree...
@@ -89,8 +92,9 @@ void BLI_dlrbTree_free(DLRBT_Tree *tree)
 static void linkedlist_sync_add_node(DLRBT_Tree *tree, DLRBT_Node *node)
 {
        /* sanity checks */
-       if ((tree == NULL) || (node == NULL))
+       if ((tree == NULL) || (node == NULL)) {
                return;
+       }
 
        /* add left-node (and its subtree) */
        linkedlist_sync_add_node(tree, node->left);
@@ -110,8 +114,9 @@ static void linkedlist_sync_add_node(DLRBT_Tree *tree, DLRBT_Node *node)
 void BLI_dlrbTree_linkedlist_sync(DLRBT_Tree *tree)
 {
        /* sanity checks */
-       if (tree == NULL)
+       if (tree == NULL) {
                return;
+       }
 
        /* clear list-base pointers so that the new list can be added properly */
        tree->first = tree->last = NULL;
@@ -131,8 +136,9 @@ DLRBT_Node *BLI_dlrbTree_search(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, vo
 
        /* check that there is a comparator to use */
        /* TODO: if no comparator is supplied, try using the one supplied with the tree... */
-       if (cmp_cb == NULL)
+       if (cmp_cb == NULL) {
                return NULL;
+       }
 
        /* iteratively perform this search */
        while (node && found == 0) {
@@ -141,17 +147,21 @@ DLRBT_Node *BLI_dlrbTree_search(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, vo
                 */
                switch (cmp_cb(node, search_data)) {
                        case -1:    /* data less than node */
-                               if (node->left)
+                               if (node->left) {
                                        node = node->left;
-                               else
+                               }
+                               else {
                                        found = 1;
+                               }
                                break;
 
                        case 1:  /* data greater than node */
-                               if (node->right)
+                               if (node->right) {
                                        node = node->right;
-                               else
+                               }
+                               else {
                                        found = 1;
+                               }
                                break;
 
                        default:  /* data equals node */
@@ -172,8 +182,9 @@ DLRBT_Node *BLI_dlrbTree_search_exact(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_
 
        /* check that there is a comparator to use */
        /* TODO: if no comparator is supplied, try using the one supplied with the tree... */
-       if (cmp_cb == NULL)
+       if (cmp_cb == NULL) {
                return NULL;
+       }
 
        /* iteratively perform this search */
        while (node && found == 0) {
@@ -182,17 +193,21 @@ DLRBT_Node *BLI_dlrbTree_search_exact(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_
                 */
                switch (cmp_cb(node, search_data)) {
                        case -1:  /* data less than node */
-                               if (node->left)
+                               if (node->left) {
                                        node = node->left;
-                               else
+                               }
+                               else {
                                        found = -1;
+                               }
                                break;
 
                        case 1:  /* data greater than node */
-                               if (node->right)
+                               if (node->right) {
                                        node = node->right;
-                               else
+                               }
+                               else {
                                        found = -1;
+                               }
                                break;
 
                        default:  /* data equals node */
@@ -212,16 +227,18 @@ DLRBT_Node *BLI_dlrbTree_search_prev(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_c
 
        /* check that there is a comparator to use */
        /* TODO: if no comparator is supplied, try using the one supplied with the tree... */
-       if (cmp_cb == NULL)
+       if (cmp_cb == NULL) {
                return NULL;
+       }
 
        /* get the node which best matches this description */
        node = BLI_dlrbTree_search(tree, cmp_cb, search_data);
 
        if (node) {
                /* if the item we're searching for is greater than the node found, we've found the match */
-               if (cmp_cb(node, search_data) > 0)
+               if (cmp_cb(node, search_data) > 0) {
                        return node;
+               }
 
                /* return the previous node otherwise */
                /* NOTE: what happens if there is no previous node? */
@@ -239,16 +256,18 @@ DLRBT_Node *BLI_dlrbTree_search_next(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_c
 
        /* check that there is a comparator to use */
        /* TODO: if no comparator is supplied, try using the one supplied with the tree... */
-       if (cmp_cb == NULL)
+       if (cmp_cb == NULL) {
                return NULL;
+       }
 
        /* get the node which best matches this description */
        node = BLI_dlrbTree_search(tree, cmp_cb, search_data);
 
        if (node) {
                /* if the item we're searching for is less than the node found, we've found the match */
-               if (cmp_cb(node, search_data) < 0)
+               if (cmp_cb(node, search_data) < 0) {
                        return node;
+               }
 
                /* return the previous node otherwise */
                /* NOTE: what happens if there is no previous node? */
@@ -273,20 +292,24 @@ short BLI_dlrbTree_contains(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *
 /* get the 'grandparent' - the parent of the parent - of the given node */
 static DLRBT_Node *get_grandparent(DLRBT_Node *node)
 {
-       if (node && node->parent)
+       if (node && node->parent) {
                return node->parent->parent;
-       else
+       }
+       else {
                return NULL;
+       }
 }
 
 /* get the sibling node (e.g. if node is left child of parent, return right child of parent) */
 static DLRBT_Node *get_sibling(DLRBT_Node *node)
 {
        if (node && node->parent) {
-               if (node == node->parent->left)
+               if (node == node->parent->left) {
                        return node->parent->right;
-               else
+               }
+               else {
                        return node->parent->left;
+               }
        }
 
        /* sibling not found */
@@ -296,9 +319,10 @@ static DLRBT_Node *get_sibling(DLRBT_Node *node)
 /* get the 'uncle' - the sibling of the parent - of the given node */
 static DLRBT_Node *get_uncle(DLRBT_Node *node)
 {
-       if (node)
+       if (node) {
                /* return the child of the grandparent which isn't the node's parent */
                return get_sibling(node->parent);
+       }
 
        /* uncle not found */
        return NULL;
@@ -314,31 +338,38 @@ static void rotate_left(DLRBT_Tree *tree, DLRBT_Node *root)
 
        /* pivot is simply the root's right child, to become the root's parent */
        pivot = root->right;
-       if (pivot == NULL)
+       if (pivot == NULL) {
                return;
+       }
 
        if (root->parent) {
-               if (root == root->parent->left)
+               if (root == root->parent->left) {
                        root_slot = &root->parent->left;
-               else
+               }
+               else {
                        root_slot = &root->parent->right;
+               }
        }
-       else
+       else {
                root_slot = ((DLRBT_Node **)&tree->root);  /* &((DLRBT_Node *)tree->root); */
+       }
 
        /* - pivot's left child becomes root's right child
         * - root now becomes pivot's left child
         */
        root->right = pivot->left;
-       if (pivot->left) pivot->left->parent = root;
+       if (pivot->left) {
+               pivot->left->parent = root;
+       }
 
        pivot->left = root;
        pivot->parent = root->parent;
        root->parent = pivot;
 
        /* make the pivot the new root */
-       if (root_slot)
+       if (root_slot) {
                *root_slot = pivot;
+       }
 }
 
 /* make the left child of the 'root' the new root */
@@ -348,31 +379,38 @@ static void rotate_right(DLRBT_Tree *tree, DLRBT_Node *root)
 
        /* pivot is simply the root's left child, to become the root's parent */
        pivot = root->left;
-       if (pivot == NULL)
+       if (pivot == NULL) {
                return;
+       }
 
        if (root->parent) {
-               if (root == root->parent->left)
+               if (root == root->parent->left) {
                        root_slot = &root->parent->left;
-               else
+               }
+               else {
                        root_slot = &root->parent->right;
+               }
        }
-       else
+       else {
                root_slot = ((DLRBT_Node **)&tree->root);  /* &((DLRBT_Node *)tree->root); */
+       }
 
        /* - pivot's right child becomes root's left child
         * - root now becomes pivot's right child
         */
        root->left = pivot->right;
-       if (pivot->right) pivot->right->parent = root;
+       if (pivot->right) {
+               pivot->right->parent = root;
+       }
 
        pivot->right = root;
        pivot->parent = root->parent;
        root->parent = pivot;
 
        /* make the pivot the new root */
-       if (root_slot)
+       if (root_slot) {
                *root_slot = pivot;
+       }
 }
 
 /* *********************************************** */
@@ -390,10 +428,12 @@ static void insert_check_1(DLRBT_Tree *tree, DLRBT_Node *node)
 {
        if (node) {
                /* if this is the root, just ensure that it is black */
-               if (node->parent == NULL)
+               if (node->parent == NULL) {
                        node->tree_col = DLRBT_BLACK;
-               else
+               }
+               else {
                        insert_check_2(tree, node);
+               }
        }
 }
 
@@ -468,10 +508,12 @@ static void insert_check_3(DLRBT_Tree *tree, DLRBT_Node *node)
 
                        /* 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))
+                       if ((node == node->parent->left) && (node->parent == gp->left)) {
                                rotate_right(tree, gp);
-                       else //if ((node == node->parent->right) && (node->parent == gp->right))
+                       }
+                       else { //if ((node == node->parent->right) && (node->parent == gp->right))
                                rotate_left(tree, gp);
+                       }
                }
        }
 }
@@ -484,8 +526,9 @@ static void insert_check_3(DLRBT_Tree *tree, DLRBT_Node *node)
 void BLI_dlrbTree_insert(DLRBT_Tree *tree, DLRBT_Node *node)
 {
        /* sanity checks */
-       if ((tree == NULL) || (node == NULL))
+       if ((tree == NULL) || (node == NULL)) {
                return;
+       }
 
        /* firstly, the node we just added should be red by default */
        node->tree_col = DLRBT_RED;
@@ -506,15 +549,18 @@ DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
        short new_node = 0;
 
        /* sanity checks */
-       if (tree == NULL)
+       if (tree == NULL) {
                return NULL;
+       }
 
        /* TODO: if no comparator is supplied, try using the one supplied with the tree... */
-       if (cmp_cb == NULL)
+       if (cmp_cb == NULL) {
                return NULL;
+       }
        /* TODO: if no allocator is supplied, try using the one supplied with the tree... */
-       if (new_cb == NULL)
+       if (new_cb == NULL) {
                return NULL;
+       }
        /* TODO: if no updater is supplied, try using the one supplied with the tree... */
 
        /* try to find the nearest node to this one */
@@ -548,8 +594,9 @@ DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
                        }
                        default:  /* update the duplicate node as appropriate */
                        {
-                               if (update_cb)
+                               if (update_cb) {
                                        update_cb(parNode, data);
+                               }
                                break;
                        }
                }
index 357fa57..c90038b 100644 (file)
@@ -214,8 +214,8 @@ static int box_areasort(const void *p1, const void *p2)
        const float a1 = box_area(b1);
        const float a2 = box_area(b2);
 
-       if      (a1 < a2) return  1;
-       else if (a1 > a2) return -1;
+       if      (a1 < a2) { return  1; }
+       else if (a1 > a2) { return -1; }
        return 0;
 }
 
@@ -240,9 +240,9 @@ static int vertex_sort(const void *p1, const void *p2, void *vs_ctx_p)
 
 #ifdef USE_FREE_STRIP
        /* push free verts to the end so we can strip */
-       if      (UNLIKELY(v1->free == 0 && v2->free == 0)) return  0;
-       else if (UNLIKELY(v1->free == 0))                  return  1;
-       else if (UNLIKELY(v2->free == 0))                  return -1;
+       if      (UNLIKELY(v1->free == 0 && v2->free == 0)) { return  0; }
+       else if (UNLIKELY(v1->free == 0))                  { return  1; }
+       else if (UNLIKELY(v2->free == 0))                  { return -1; }
 #endif
 
        a1 = max_ff(v1->x + vs_ctx->box_width, v1->y + vs_ctx->box_height);
@@ -254,8 +254,8 @@ static int vertex_sort(const void *p1, const void *p2, void *vs_ctx_p)
 #endif
 
        /* sort largest to smallest */
-       if      (a1 > a2) return 1;
-       else if (a1 < a2) return -1;
+       if      (a1 > a2) { return 1; }
+       else if (a1 < a2) { return -1; }
        return 0;
 }
 /** \} */
@@ -365,8 +365,9 @@ void BLI_box_pack_2d(BoxPack *boxarray, const uint len, float *r_tot_x, float *r
 #endif
        }
 
-       for (i = 0; i < 3; i++)
+       for (i = 0; i < 3; i++) {
                vertex_pack_indices[i] = box->v[i + 1]->index;
+       }
        verts_pack_len = 3;
        box++; /* next box, needed for the loop below */
        /* ...done packing the first box */
index a59d440..87471ea 100644 (file)
@@ -83,8 +83,10 @@ int BLI_convexhull_2d_sorted(const float (*points)[2], const int n, int r_points
        minmax = i - 1;
        if (minmax == n - 1) {  /* degenerate case: all x-coords == xmin */
                r_points[++top] = minmin;
-               if (points[minmax][1] != points[minmin][1])  /* a nontrivial segment */
+               if (points[minmax][1] != points[minmin][1]) {
+                       /* a nontrivial segment */
                        r_points[++top] = minmax;
+               }
                r_points[++top] = minmin;  /* add polygon endpoint */
                return top + 1;
        }
@@ -168,13 +170,13 @@ static int pointref_cmp_yx(const void *a_, const void *b_)
        const struct PointRef *a = a_;
        const struct PointRef *b = b_;
 
-       if      (a->pt[1] > b->pt[1]) return  1;
-       else if (a->pt[1] < b->pt[1]) return -1;
+       if      (a->pt[1] > b->pt[1]) { return  1; }
+       else if (a->pt[1] < b->pt[1]) { return -1; }
 
-       if      (a->pt[0] > b->pt[0]) return  1;
-       else if (a->pt[0] < b->pt[0]) return -1;
+       if      (a->pt[0] > b->pt[0]) { return  1; }
+       else if (a->pt[0] < b->pt[0]) { return -1; }
 
-       else                          return  0;
+       else                          { return  0; }
 }
 
 /**
index b172ae7..31f8d9d 100644 (file)
@@ -51,8 +51,9 @@ DynamicLibrary *BLI_dynlib_open(const char *name)
        handle = LoadLibraryW(name_16);
        UTF16_UN_ENCODE(name);
 
-       if (!handle)
+       if (!handle) {
                return NULL;
+       }
 
        lib = MEM_callocN(sizeof(*lib), "Dynamic Library");
        lib->handle = handle;
@@ -71,8 +72,9 @@ char *BLI_dynlib_get_error_as_string(DynamicLibrary *lib)
 
        /* if lib is NULL reset the last error code */
        err = GetLastError();
-       if (!lib)
+       if (!lib) {
                SetLastError(ERROR_SUCCESS);
+       }
 
        if (err) {
                static char buf[1024];
@@ -103,8 +105,9 @@ DynamicLibrary *BLI_dynlib_open(const char *name)
        DynamicLibrary *lib;
        void *handle = dlopen(name, RTLD_LAZY);
 
-       if (!handle)
+       if (!handle) {
                return NULL;
+       }
 
        lib = MEM_callocN(sizeof(*lib), "Dynamic Library");
        lib->handle = handle;
index b1df6e4..99077ed 100644 (file)
@@ -91,10 +91,12 @@ float BLI_easing_bounce_ease_in(float time, float begin, float change, float dur
 
 float BLI_easing_bounce_ease_in_out(float time, float begin, float change, float duration)
 {
-       if (time < duration / 2)
+       if (time < duration / 2) {
                return BLI_easing_bounce_ease_in(time * 2, 0, change, duration) * 0.5f + begin;
-       else
+       }
+       else {
                return BLI_easing_bounce_ease_out(time * 2 - duration, 0, change, duration) * 0.5f + change * 0.5f + begin;
+       }
 }
 
 float BLI_easing_circ_ease_in(float time, float begin, float change, float duration)
@@ -111,8 +113,9 @@ float BLI_easing_circ_ease_out(float time, float begin, float change, float dura
 
 float BLI_easing_circ_ease_in_out(float time, float begin, float change, float duration)
 {
-       if ((time /= duration / 2) < 1.0f)
+       if ((time /= duration / 2) < 1.0f) {
                return -change / 2 * (sqrtf(1 - time * time) - 1) + begin;
+       }
        time -= 2.0f;
        return change / 2 * (sqrtf(1 - time * time) + 1) + begin;
 }
@@ -131,8 +134,9 @@ float BLI_easing_cubic_ease_out(float time, float begin, float change, float dur
 
 float BLI_easing_cubic_ease_in_out(float time, float begin, float change, float duration)
 {
-       if ((time /= duration / 2) < 1.0f)
+       if ((time /= duration / 2) < 1.0f) {
                return change / 2 * time * time * time + begin;
+       }
        time -= 2.0f;
        return change / 2 * (time * time * time + 2) + begin;
 }
@@ -170,14 +174,17 @@ float BLI_easing_elastic_ease_in(float time, float begin, float change, float du
        float s;
        float f = 1.0f;
 
-       if (time == 0.0f)
+       if (time == 0.0f) {
                return begin;
+       }
 
-       if ((time /= duration) == 1.0f)
+       if ((time /= duration) == 1.0f) {
                return begin + change;
+       }
        time -= 1.0f;
-       if (!period)
+       if (!period) {
                period = duration * 0.3f;
+       }
        if (!amplitude || amplitude < fabsf(change)) {
                s = period / 4;
 #ifdef USE_ELASTIC_BLEND
@@ -185,8 +192,9 @@ float BLI_easing_elastic_ease_in(float time, float begin, float change, float du
 #endif
                amplitude = change;
        }
-       else
+       else {
                s = period / (2 * (float)M_PI) * asinf(change / amplitude);
+       }
 
        return (-f * (amplitude * powf(2, 10 * time) * sinf((time * duration - s) * (2 * (float)M_PI) / period))) + begin;
 }
@@ -196,13 +204,16 @@ float BLI_easing_elastic_ease_out(float time, float begin, float change, float d
        float s;
        float f = 1.0f;
 
-       if (time == 0.0f)
+       if (time == 0.0f) {
                return begin;
-       if ((time /= duration) == 1.0f)
+       }
+       if ((time /= duration) == 1.0f) {
                return begin + change;
+       }
        time = -time;
-       if (!period)
+       if (!period) {
                period = duration * 0.3f;
+       }
        if (!amplitude || amplitude < fabsf(change)) {
                s = period / 4;
 #ifdef USE_ELASTIC_BLEND
@@ -210,8 +221,9 @@ float BLI_easing_elastic_ease_out(float time, float begin, float change, float d
 #endif
                amplitude = change;
        }
-       else
+       else {
                s = period / (2 * (float)M_PI) * asinf(change / amplitude);
+       }
 
        return (f * (amplitude * powf(2, 10 * time) * sinf((time * duration - s) * (2 * (float)M_PI) / period))) + change + begin;
 }
@@ -221,13 +233,16 @@ float BLI_easing_elastic_ease_in_out(float time, float begin, float change, floa
        float s;
        float f = 1.0f;
 
-       if (time == 0.0f)
+       if (time == 0.0f) {
                return begin;
-       if ((time /= duration / 2) == 2.0f)
+       }
+       if ((time /= duration / 2) == 2.0f) {
                return begin + change;
+       }
        time -= 1.0f;
-       if (!period)
+       if (!period) {
                period = duration * (0.3f * 1.5f);
+       }
        if (!amplitude || amplitude < fabsf(change)) {
                s = period / 4;
 #ifdef USE_ELASTIC_BLEND
@@ -235,8 +250,9 @@ float BLI_easing_elastic_ease_in_out(float time, float begin, float change, floa
 #endif
                amplitude = change;
        }
-       else
+       else {
                s = period / (2 * (float)M_PI) * asinf(change / amplitude);
+       }
 
        if (time < 0.0f) {
                f *= -0.5f;
@@ -301,8 +317,9 @@ float BLI_easing_quad_ease_out(float time, float begin, float change, float dura
 
 float BLI_easing_quad_ease_in_out(float time, float begin, float change, float duration)
 {
-       if ((time /= duration / 2) < 1.0f)
+       if ((time /= duration / 2) < 1.0f) {
                return change / 2 * time * time + begin;
+       }
        time -= 1.0f;
        return -change / 2 * (time * (time - 2) - 1) + begin;
 }
@@ -322,8 +339,9 @@ float BLI_easing_quart_ease_out(float time, float begin, float change, float dur
 
 float BLI_easing_quart_ease_in_out(float time, float begin, float change, float duration)
 {
-       if ((time /= duration / 2) < 1.0f)
+       if ((time /= duration / 2) < 1.0f) {
                return change / 2 * time * time * time * time + begin;
+       }
        time -= 2.0f;
        return -change / 2 * ( time * time * time * time - 2) + begin;
 }
@@ -340,8 +358,9 @@ float BLI_easing_quint_ease_out(float time, float begin, float change, float dur
 }
 float BLI_easing_quint_ease_in_out(float time, float begin, float change, float duration)
 {
-       if ((time /= duration / 2) < 1.0f)
+       if ((time /= duration / 2) < 1.0f) {
                return change / 2 * time * time * time * time * time + begin;
+       }
        time -= 2.0f;
        return change / 2 * (time * time * time * time * time + 2) + begin;
 }
index f3d69bc..55c9a18 100644 (file)
@@ -113,7 +113,9 @@ BLI_INLINE bool edges_equal(Edge e1, Edge e2)
 static uint calc_capacity_exp_for_reserve(uint reserve)
 {
        uint result = 1;
-       while (reserve >>= 1) result++;
+       while (reserve >>= 1) {
+               result++;
+       }
        return result;
 }
 
@@ -255,7 +257,9 @@ void BLI_edgehash_print(EdgeHash *eh)
        }
        printf("  Entries:\n");
        for (uint i = 0; i < ENTRIES_CAPACITY(eh); i++) {
-               if (i == eh->length) printf("    **** below is rest capacity ****\n");
+               if (i == eh->length) {
+                       printf("    **** below is rest capacity ****\n");
+               }
                EdgeHashEntry entry = eh->entries[i];
                printf("    %u: (%u, %u) -> %p\n", i, entry.edge.v_low, entry.edge.v_high, entry.value);
 
@@ -374,7 +378,9 @@ bool BLI_edgehash_remove(EdgeHash *eh, uint v0, uint v1, EdgeHashFreeFP free_val
 {
        uint old_length = eh->length;
        void *value = BLI_edgehash_popkey(eh, v0, v1);
-       if (free_value && value) free_value(value);
+       if (free_value && value) {
+               free_value(value);
+       }
        return old_length > eh->length;
 }
 
index cd5b43f..51a004f 100644 (file)
@@ -554,28 +554,32 @@ static bool parse_next_token(ExprParseState *state)
                char *end, *out = state->tokenbuf;
                bool is_float = false;
 
-               while (isdigit(*state->cur))
+               while (isdigit(*state->cur)) {
                        *out++ = *state->cur++;
+               }
 
                if (*state->cur == '.') {
                        is_float = true;
                        *out++ = *state->cur++;
 
-                       while (isdigit(*state->cur))
+                       while (isdigit(*state->cur)) {
                                *out++ = *state->cur++;
+                       }
                }
 
                if (ELEM(*state->cur, 'e', 'E')) {
                        is_float = true;
                        *out++ = *state->cur++;
 
-                       if (ELEM(*state->cur, '+', '-'))
+                       if (ELEM(*state->cur, '+', '-')) {
                                *out++ = *state->cur++;
+                       }
 
                        CHECK_ERROR(isdigit(*state->cur));
 
-                       while (isdigit(*state->cur))
+                       while (isdigit(*state->cur)) {
                                *out++ = *state->cur++;
+                       }
                }
 
                *out = 0;
@@ -611,8 +615,9 @@ static bool parse_next_token(ExprParseState *state)
        if (isalpha(*state->cur) || ELEM(*state->cur, '_')) {
                char *out = state->tokenbuf;
 
-               while (isalnum(*state->cur) || ELEM(*state->cur, '_'))
+               while (isalnum(*state->cur) || ELEM(*state->cur, '_')) {
                        *out++ = *state->cur++;
+               }
 
                *out = 0;
 
index 2339025..afedd19 100644 (file)
@@ -140,8 +140,9 @@ char *BLI_file_ungzip_to_mem(const char *from_file, int *r_size)
                MEM_freeN(mem);
                mem = NULL;
        }
-       else if (alloc_size != size)
+       else if (alloc_size != size) {
                mem = MEM_reallocN(mem, size);
+       }
 
        *r_size = size;
 
@@ -249,8 +250,9 @@ void *BLI_gzopen(const char *filename, const char *mode)
        BLI_assert(!BLI_path_is_rel(filename));
 
        /* xxx Creates file before transcribing the path */
-       if (mode[0] == 'w')
+       if (mode[0] == 'w') {
                fclose(ufopen(filename, "a"));
+       }
 
        /* temporary #if until we update all libraries to 1.2.7
         * for correct wide char path handling */
@@ -293,11 +295,15 @@ static bool delete_unique(const char *path, const bool dir)
 
        if (dir) {
                err = !RemoveDirectoryW(path_16);
-               if (err) printf("Unable to remove directory\n");
+               if (err) {
+                       printf("Unable to remove directory\n");
+               }
        }
        else {
                err = !DeleteFileW(path_16);
-               if (err) callLocalErrorCallBack("Unable to delete file");
+               if (err) {
+                       callLocalErrorCallBack("Unable to delete file");
+               }
        }
 
        UTF16_UN_ENCODE(path);
@@ -487,11 +493,16 @@ bool BLI_dir_create_recursive(const char *dirname)
 
 int BLI_rename(const char *from, const char *to)
 {
-       if (!BLI_exists(from)) return 0;
+       if (!BLI_exists(from)) {
+               return 0;
+       }
 
        /* make sure the filenames are different (case insensitive) before removing */
-       if (BLI_exists(to) && BLI_strcasecmp(from, to))
-               if (BLI_delete(to, false, false)) return 1;
+       if (BLI_exists(to) && BLI_strcasecmp(from, to)) {
+               if (BLI_delete(to, false, false)) {
+                       return 1;
+               }
+       }
 
        return urename(from, to);
 }
@@ -517,10 +528,12 @@ static void join_dirfile_alloc(char **dst, size_t *alloc_len, const char *dir, c
 {
        size_t len = strlen(dir) + strlen(file) + 1;
 
-       if (*dst == NULL)
+       if (*dst == NULL) {
                *dst = MEM_mallocN(len + 1, "join_dirfile_alloc path");
-       else if (*alloc_len < len)
+       }
+       else if (*alloc_len < len) {
                *dst = MEM_reallocN(*dst, len + 1);
+       }
 
        *alloc_len = len;
 
@@ -564,21 +577,24 @@ static int recursive_operation(const char *startfrom, const char *startto,
        do {  /* once */
                /* ensure there's no trailing slash in file path */
                from = strip_last_slash(startfrom);
-               if (startto)
+               if (startto) {
                        to = strip_last_slash(startto);
+               }
 
                ret = lstat(from, &st);
-               if (ret < 0)
+               if (ret < 0) {
                        /* source wasn't found, nothing to operate with */
                        break;
+               }
 
                if (!S_ISDIR(st.st_mode)) {
                        /* source isn't a directory, can't do recursive walking for it,
                         * so just call file callback and leave */
                        if (callback_file != NULL) {
                                ret = callback_file(from, to);
-                               if (ret != RecursiveOp_Callback_OK)
+                               if (ret != RecursiveOp_Callback_OK) {
                                        ret = -1;
+                               }
                        }
                        break;
                }
@@ -594,11 +610,13 @@ static int recursive_operation(const char *startfrom, const char *startto,
                if (callback_dir_pre != NULL) {
                        ret = callback_dir_pre(from, to);
                        if (ret != RecursiveOp_Callback_OK) {
-                               if (ret == RecursiveOp_Callback_StopRecurs)
+                               if (ret == RecursiveOp_Callback_StopRecurs) {
                                        /* callback requested not to perform recursive walking, not an error */
                                        ret = 0;
-                               else
+                               }
+                               else {
                                        ret = -1;
+                               }
                                break;
                        }
                }
@@ -606,12 +624,14 @@ static int recursive_operation(const char *startfrom, const char *startto,
                for (i = 0; i < n; i++) {
                        const struct dirent * const dirent = dirlist[i];
 
-                       if (FILENAME_IS_CURRPAR(dirent->d_name))
+                       if (FILENAME_IS_CURRPAR(dirent->d_name)) {
                                continue;
+                       }
 
                        join_dirfile_alloc(&from_path, &from_alloc_len, from, dirent->d_name);
-                       if (to)
+                       if (to) {
                                join_dirfile_alloc(&to_path, &to_alloc_len, to, dirent->d_name);
+                       }
 
                        bool is_dir;
 
@@ -633,23 +653,26 @@ static int recursive_operation(const char *startfrom, const char *startto,
                        }
                        else if (callback_file != NULL) {
                                ret = callback_file(from_path, to_path);
-                               if (ret != RecursiveOp_Callback_OK)
+                               if (ret != RecursiveOp_Callback_OK) {
                                        ret = -1;
+                               }
                        }
 
-                       if (ret != 0)
+                       if (ret != 0) {
                                break;
+                       }
                }
-               if (ret != 0)
+               if (ret != 0) {
                        break;
+               }
 
                if (callback_dir_post != NULL) {
                        ret = callback_dir_post(from, to);
-                       if (ret != RecursiveOp_Callback_OK)
+                       if (ret != RecursiveOp_Callback_OK) {
                                ret = -1;
+                       }
                }
-       }
-       while (false);
+       } while (false);
 
        if (dirlist != NULL) {
                for (i = 0; i < n; i++) {
@@ -657,14 +680,18 @@ static int recursive_operation(const char *startfrom, const char *startto,
                }
                free(dirlist);
        }
-       if (from_path != NULL)
+       if (from_path != NULL) {
                MEM_freeN(from_path);
-       if (to_path != NULL)
+       }
+       if (to_path != NULL) {
                MEM_freeN(to_path);
-       if (from != NULL)
+       }
+       if (from != NULL) {
                MEM_freeN(from);
-       if (to != NULL)
+       }
+       if (to != NULL) {
                MEM_freeN(to);
+       }
 
        return ret;
 }
@@ -748,11 +775,13 @@ static bool check_the_same(const char *path_a, const char *path_b)
 {
        struct stat st_a, st_b;
 
-       if (lstat(path_a, &st_a))
+       if (lstat(path_a, &st_a)) {
                return false;
+       }
 
-       if (lstat(path_b, &st_b))
+       if (lstat(path_b, &st_b)) {
                return false;
+       }
 
        return st_a.st_dev == st_b.st_dev && st_a.st_ino == st_b.st_ino;
 }
@@ -843,7 +872,9 @@ static int copy_single_file(const char *from, const char *to)
                if (link_len < 0) {
                        perror("readlink");
 
-                       if (need_free) MEM_freeN(link_buffer);
+                       if (need_free) {
+                               MEM_freeN(link_buffer);
+                       }
 
                        return RecursiveOp_Callback_Error;
                }
@@ -852,12 +883,15 @@ static int copy_single_file(const char *from, const char *to)
 
                if (symlink(link_buffer, to)) {
                        perror("symlink");
-                       if (need_free) MEM_freeN(link_buffer);
+                       if (need_free) {
+                               MEM_freeN(link_buffer);
+                       }
                        return RecursiveOp_Callback_Error;
                }
 
-               if (need_free)
+               if (need_free) {
                        MEM_freeN(link_buffer);
+               }
 
                return RecursiveOp_Callback_OK;
        }
@@ -872,8 +906,9 @@ static int copy_single_file(const char *from, const char *to)
                        return RecursiveOp_Callback_Error;
                }
 
-               if (set_permissions(to, &st))
+               if (set_permissions(to, &st)) {
                        return RecursiveOp_Callback_Error;
+               }
 
                return RecursiveOp_Callback_OK;
        }
@@ -902,8 +937,9 @@ static int copy_single_file(const char *from, const char *to)
        fclose(to_stream);
        fclose(from_stream);
 
-       if (set_permissions(to, &st))
+       if (set_permissions(to, &st)) {
                return RecursiveOp_Callback_Error;
+       }
 
        return RecursiveOp_Callback_OK;
 }
@@ -985,8 +1021,9 @@ int BLI_copy(const char *file, const char *to)
 
        ret = recursive_operation(file, actual_to, copy_callback_pre, copy_single_file, NULL);
 
-       if (actual_to != to)
+       if (actual_to != to) {
                MEM_freeN((void *)actual_to);
+       }
 
        return ret;
 }
@@ -1057,8 +1094,11 @@ int BLI_rename(const char *from, const char *to)
                return 1;
        }
 
-       if (BLI_exists(to))
-               if (BLI_delete(to, false, false)) return 1;
+       if (BLI_exists(to)) {
+               if (BLI_delete(to, false, false)) {
+                       return 1;
+               }
+       }
 
        return rename(from, to);
 }
index fba3c82..36051e3 100644 (file)
@@ -104,10 +104,13 @@ static VChar *freetypechar_to_vchar(FT_Face face, FT_ULong charcode, VFontData *
 
                        for (k = 0; k < n; k++) {
                                l = (j > 0) ? (k + ftoutline.contours[j - 1] + 1) : k;
-                               if (k == 0) l_first = l;
+                               if (k == 0) {
+                                       l_first = l;
+                               }
 
-                               if (ftoutline.tags[l] == FT_Curve_Tag_On)
+                               if (ftoutline.tags[l] == FT_Curve_Tag_On) {
                                        onpoints[j]++;
+                               }
 
                                {
                                        const int l_next = (k < n - 1) ? (l + 1) : l_first;
@@ -140,7 +143,9 @@ static VChar *freetypechar_to_vchar(FT_Face face, FT_ULong charcode, VFontData *
                        /* individual curve loop, start-end */
                        for (k = 0; k < n; k++) {
                                l = (j > 0) ? (k + ftoutline.contours[j - 1] + 1) : k;
-                               if (k == 0) l_first = l;
+                               if (k == 0) {
+                                       l_first = l;
+                               }
 
                                /* virtual conic on-curve points */
                                {
@@ -291,7 +296,9 @@ static VFontData *objfnt_to_ftvfontdata(PackedFile *pf)
                                 0,
                                 &face);
 
-       if (err) return NULL;
+       if (err) {
+               return NULL;
+       }
 
        /* allocate blender font */
        vfd = MEM_callocN(sizeof(*vfd), "FTVFontData");
@@ -319,8 +326,9 @@ static VFontData *objfnt_to_ftvfontdata(PackedFile *pf)
 
                err = FT_Set_Charmap(face, found);
 
-               if (err)
+               if (err) {
                        return NULL;
+               }
 
                lcode = charcode = FT_Get_First_Char(face, &glyph_index);
        }
@@ -362,8 +370,9 @@ static VFontData *objfnt_to_ftvfontdata(PackedFile *pf)
                charcode = FT_Get_Next_Char(face, charcode, &glyph_index);
 
                /* Check that we won't start infinite loop */
-               if (charcode <= lcode)
+               if (charcode <= lcode) {
                        break;
+               }
                lcode = charcode;
        }
 
@@ -460,7 +469,9 @@ VChar *BLI_vfontchar_from_freetypefont(VFont *vfont, unsigned long character)
 {
        VChar *che = NULL;
 
-       if (!vfont) return NULL;
+       if (!vfont) {
+               return NULL;
+       }
 
        /* Init Freetype */
        err = FT_Init_FreeType(&library);
index 226e6cd..4089022 100644 (file)
@@ -78,8 +78,9 @@ int BLI_gsqueue_len(GSQueue *gq)
        GSQueueElem *elem;
        int size = 0;
 
-       for (elem = gq->head; elem; elem = elem->next)
+       for (elem = gq->head; elem; elem = elem->next) {
                size++;
+       }
 
        return size;
 }
@@ -132,8 +133,9 @@ void BLI_gsqueue_push(GSQueue *gq, const void *item)
 
        /* compare: prevent events added double in row */
        if (!BLI_gsqueue_is_empty(gq)) {
-               if (0 == memcmp(item, gq->head->data, gq->elem_size))
+               if (0 == memcmp(item, gq->head->data, gq->elem_size)) {
                        return;
+               }
        }
        elem = MEM_mallocN(sizeof(*elem) + gq->elem_size, "gqueue_push");
        memcpy(elem->data, item, gq->elem_size);
index 895b558..1a8e78d 100644 (file)
@@ -316,19 +316,22 @@ int BLI_hash_md5_stream(FILE *stream, void *resblock)
                        sum += n;
                } while (sum < BLOCKSIZE && n != 0);
 
-               if (n == 0 && ferror(stream))
+               if (n == 0 && ferror(stream)) {
                        return 1;
+               }
 
                /* RFC 1321 specifies the possible length of the file up to 2^64 bits.
                 * Here we only compute the number of bytes. Do a double word increment.
                 */
                len[0] += sum;
-               if (len[0] < sum)
+               if (len[0] < sum) {
                        ++len[1];
+               }
 
                /* If end of file is reached, end the loop.  */
-               if (n == 0)
+               if (n == 0) {
                        break;
+               }
 
                /* Process buffer with BLOCKSIZE bytes. Note that BLOCKSIZE % 64 == 0. */
                md5_process_block(buffer, BLOCKSIZE, &ctx);
index 0a1ee08..bbf1948 100644 (file)
@@ -104,17 +104,17 @@ void BLI_jitterate2(float (*jit1)[2], float (*jit2)[2], int num, float rad2)
                                vecx = jit1[j][0] - x - 1.0f;
                                vecy = jit1[j][1] - y - 1.0f;
 
-                               if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
+                               if (fabsf(vecx) < rad2) { dvecx += vecx * rad2; }
                                vecx += 1.0f;
-                               if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
+                               if (fabsf(vecx) < rad2) { dvecx += vecx * rad2; }
                                vecx += 1.0f;
-                               if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
+                               if (fabsf(vecx) < rad2) { dvecx += vecx * rad2; }
 
-                               if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
+                               if (fabsf(vecy) < rad2) { dvecy += vecy * rad2; }
                                vecy += 1.0f;
-                               if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
+                               if (fabsf(vecy) < rad2) { dvecy += vecy * rad2; }
                                vecy += 1.0f;
-                               if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
+                               if (fabsf(vecy) < rad2) { dvecy += vecy * rad2; }
 
                        }
                }
index 37d4d6e..a8eb9f0 100644 (file)
@@ -36,10 +36,10 @@ void BLI_lasso_boundbox(rcti *rect, const int mcords[][2], const unsigned int mo
        rect->ymin = rect->ymax = mcords[0][1];
 
        for (a = 1; a < moves; a++) {
-               if      (mcords[a][0] < rect->xmin) rect->xmin = mcords[a][0];
-               else if (mcords[a][0] > rect->xmax) rect->xmax = mcords[a][0];
-               if      (mcords[a][1] < rect->ymin) rect->ymin = mcords[a][1];
-               else if (mcords[a][1] > rect->ymax) rect->ymax = mcords[a][1];
+               if      (mcords[a][0] < rect->xmin) { rect->xmin = mcords[a][0]; }
+               else if (mcords[a][0] > rect->xmax) { rect->xmax = mcords[a][0]; }
+               if      (mcords[a][1] < rect->ymin) { rect->ymin = mcords[a][1]; }
+               else if (mcords[a][1] > rect->ymax) { rect->ymax = mcords[a][1]; }
        }
 }
 
@@ -70,14 +70,22 @@ bool BLI_lasso_is_edge_inside(const int mcords[][2], const unsigned int moves,
        const int v1[2] = {x0, y0}, v2[2] = {x1, y1};
 
        /* check points in lasso */
-       if (BLI_lasso_is_point_inside(mcords, moves, v1[0], v1[1], error_value)) return true;
-       if (BLI_lasso_is_point_inside(mcords, moves, v2[0], v2[1], error_value)) return true;
+       if (BLI_lasso_is_point_inside(mcords, moves, v1[0], v1[1], error_value)) {
+               return true;
+       }
+       if (BLI_lasso_is_point_inside(mcords, moves, v2[0], v2[1], error_value)) {
+               return true;
+       }
 
        /* no points in lasso, so we have to intersect with lasso edge */
 
-       if (isect_seg_seg_v2_int(mcords[0], mcords[moves - 1], v1, v2) > 0) return true;
+       if (isect_seg_seg_v2_int(mcords[0], mcords[moves - 1], v1, v2) > 0) {
+               return true;
+       }
        for (unsigned int a = 0; a < moves - 1; a++) {
-               if (isect_seg_seg_v2_int(mcords[a], mcords[a + 1], v1, v2) > 0) return true;
+               if (isect_seg_seg_v2_int(mcords[a], mcords[a + 1], v1, v2) > 0) {
+                       return true;
+               }
        }
 
        return false;
index 5fd7564..8e6de3a 100644 (file)
@@ -44,7 +44,9 @@
  */
 void BLI_movelisttolist(ListBase *dst, ListBase *src)
 {
-       if (src->first == NULL) return;
+       if (src->first == NULL) {
+               return;
+       }
 
        if (dst->first == NULL) {
                dst->first = src->first;
@@ -63,7 +65,9 @@ void BLI_movelisttolist(ListBase *dst, ListBase *src)
  */
 void BLI_movelisttolist_reverse(ListBase *dst, ListBase *src)
 {
-       if (src->first == NULL) return;
+       if (src->first == NULL) {
+               return;
+       }
 
        if (dst->first == NULL) {
                dst->first = src->first;
@@ -85,13 +89,19 @@ void BLI_addhead(ListBase *listbase, void *vlink)
 {
        Link *link = vlink;
 
-       if (link == NULL) return;
+       if (link == NULL) {
+               return;
+       }
 
        link->next = listbase->first;
        link->prev = NULL;
 
-       if (listbase->first) ((Link *)listbase->first)->prev = link;
-       if (listbase->last == NULL) listbase->last = link;
+       if (listbase->first) {
+               ((Link *)listbase->first)->prev = link;
+       }
+       if (listbase->last == NULL) {
+               listbase->last = link;
+       }
        listbase->first = link;
 }
 
@@ -103,13 +113,19 @@ void BLI_addtail(ListBase *listbase, void *vlink)
 {
        Link *link = vlink;
 
-       if (link == NULL) return;
+       if (link == NULL) {
+               return;
+       }
 
        link->next = NULL;
        link->prev = listbase->last;
 
-       if (listbase->last) ((Link *)listbase->last)->next = link;
-       if (listbase->first == NULL) listbase->first = link;
+       if (listbase->last) {
+               ((Link *)listbase->last)->next = link;
+       }
+       if (listbase->first == NULL) {
+               listbase->first = link;
+       }
        listbase->last = link;
 }
 
@@ -121,13 +137,23 @@ void BLI_remlink(ListBase *listbase, void *vlink)
 {
        Link *link = vlink;
 
-       if (link == NULL) return;
+       if (link == NULL) {
+               return;
+       }
 
-       if (link->next) link->next->prev = link->prev;
-       if (link->prev) link->prev->next = link->next;
+       if (link->next) {
+               link->next->prev = link->prev;
+       }
+       if (link->prev) {
+               link->prev->next = link->next;
+       }
 
-       if (listbase->last == link) listbase->last = link->prev;
-       if (listbase->first == link) listbase->first = link->next;
+       if (listbase->last == link) {
+               listbase->last = link->prev;
+       }
+       if (listbase->first == link) {
+               listbase->first = link->next;
+       }
 }
 
 /**
@@ -152,8 +178,9 @@ void BLI_listbase_swaplinks(ListBase *listbase, void *vlinka, void *vlinkb)
        Link *linka = vlinka;
        Link *linkb = vlinkb;
 
-       if (!linka || !linkb)
+       if (!linka || !linkb) {
                return;
+       }
 
        if (linkb->next == linka) {
                SWAP(Link *, linka, linkb);
@@ -171,15 +198,32 @@ void BLI_listbase_swaplinks(ListBase *listbase, void *vlinka, void *vlinkb)
        }
 
        /* Update neighbors of linka and linkb. */
-       if (linka->prev) linka->prev->next = linka;
-       if (linka->next) linka->next->prev = linka;
-       if (linkb->prev) linkb->prev->next = linkb;
-       if (linkb->next) linkb->next->prev = linkb;
+       if (linka->prev) {
+               linka->prev->next = linka;
+       }
+       if (linka->next) {
+               linka->next->prev = linka;
+       }
+       if (linkb->prev) {
+               linkb->prev->next = linkb;
+       }
+       if (linkb->next) {
+               linkb->next->prev = linkb;
+       }
 
-       if (listbase->last == linka) listbase->last = linkb;
-       else if (listbase->last == linkb) listbase->last = linka;
-       if (listbase->first == linka) listbase->first = linkb;
-       else if (listbase->first == linkb) listbase->first = linka;
+       if (listbase->last == linka) {
+               listbase->last = linkb;
+       }
+       else if (listbase->last == linkb) {
+               listbase->last = linka;
+       }
+
+       if (listbase->first == linka) {
+               listbase->first = linkb;
+       }
+       else if (listbase->first == linkb) {
+               listbase->first = linka;
+       }
 }
 
 /**
@@ -242,7 +286,9 @@ void BLI_freelinkN(ListBase *listbase, void *vlink)
 {
        Link *link = vlink;
 
-       if (link == NULL) return;
+       if (link == NULL) {
+               return;
+       }
 
        BLI_remlink(listbase, link);
        MEM_freeN(link);
@@ -311,7 +357,9 @@ void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink)
        Link *newlink = vnewlink;
 
        /* newlink before nextlink */
-       if (newlink == NULL) return;
+       if (newlink == NULL) {
+               return;
+       }
 
        /* empty list */
        if (listbase->first == NULL) {
@@ -352,7 +400,9 @@ void BLI_insertlinkbefore(ListBase *listbase, void *vnextlink, void *vnewlink)
        Link *newlink = vnewlink;
 
        /* newlink before nextlink */
-       if (newlink == NULL) return;
+       if (newlink == NULL) {
+               return;
+       }
 
        /* empty list */
        if (listbase->first == NULL) {
@@ -566,12 +616,15 @@ int BLI_findindex(const ListBase *listbase, const void *vlink)
        Link *link = NULL;
        int number = 0;
 
-       if (vlink == NULL) return -1;
+       if (vlink == NULL) {
+               return -1;
+       }
 
        link = listbase->first;
        while (link) {
-               if (link == vlink)
+               if (link == vlink) {
                        return number;
+               }
 
                number++;
                link = link->next;
@@ -589,8 +642,9 @@ void *BLI_findstring(const ListBase *listbase, const char *id, const int offset)
        Link *link = NULL;
        const char *id_iter;
 
-       if (id == NULL)
+       if (id == NULL) {
                return NULL;
+       }
 
        for (link = listbase->first; link; link = link->next) {
                id_iter = ((const char *)link) + offset;
@@ -761,8 +815,9 @@ int BLI_findstringindex(const ListBase *listbase, const char *id, const int offs
        while (link) {
                id_iter = ((const char *)link) + offset;
 
-               if (id[0] == id_iter[0] && STREQ(id, id_iter))
+               if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
                        return i;
+               }
                i++;
                link = link->next;
        }
@@ -845,8 +900,9 @@ LinkData *BLI_genericNodeN(void *data)
 {
        LinkData *ld;
 
-       if (data == NULL)
+       if (data == NULL) {
                return NULL;
+       }
 
        /* create new link, and make it hold the given data */
        ld = MEM_callocN(sizeof(LinkData), __func__);
index c4b0172..ed75cac 100644 (file)
@@ -53,8 +53,9 @@ double double_round(double x, int ndigits)
                pow2 = 1.0;
                y = (x * pow1) * pow2;
                /* if y overflows, then rounded value is exactly x */
-               if (!isfinite(y))
+               if (!isfinite(y)) {
                        return x;
+               }
        }
        else {
                pow1 = pow(10.0, (double)-ndigits);
@@ -63,14 +64,17 @@ double double_round(double x, int ndigits)
        }
 
        z = round(y);
-       if (fabs(y - z) == 0.5)
+       if (fabs(y - z) == 0.5) {
                /* halfway between two integers; use round-half-even */
                z = 2.0 * round(y / 2.0);
+       }
 
-       if (ndigits >= 0)
+       if (ndigits >= 0) {
                z = (z / pow2) / pow1;
-       else
+       }
+       else {
                z *= pow1;
+       }
 
        /* if computation resulted in overflow, raise OverflowError */
        return z;
index 1ad0dc6..b8a5a13 100644 (file)
@@ -65,16 +65,16 @@ MINLINE float pow7f(float x)
 
 MINLINE float sqrt3f(float f)
 {
-       if      (UNLIKELY(f == 0.0f)) return 0.0f;
-       else if (UNLIKELY(f <  0.0f)) return -(float)(exp(log(-f) / 3.0));
-       else                          return  (float)(exp(log( f) / 3.0));
+       if      (UNLIKELY(f == 0.0f)) { return 0.0f; }
+       else if (UNLIKELY(f <  0.0f)) { return -(float)(exp(log(-f) / 3.0)); }
+       else                          { return  (float)(exp(log( f) / 3.0)); }
 }
 
 MINLINE double sqrt3d(double d)
 {
-       if      (UNLIKELY(d == 0.0)) return 0.0;
-       else if (UNLIKELY(d <  0.0)) return -exp(log(-d) / 3.0);
-       else                         return  exp(log( d) / 3.0);
+       if      (UNLIKELY(d == 0.0)) { return 0.0; }
+       else if (UNLIKELY(d <  0.0)) { return -exp(log(-d) / 3.0); }
+       else                         { return  exp(log( d) / 3.0); }
 }
 
 MINLINE float sqrtf_signed(float f)
@@ -84,42 +84,42 @@ MINLINE float sqrtf_signed(float f)
 
 MINLINE float saacos(float fac)
 {
-       if      (UNLIKELY(fac <= -1.0f)) return (float)M_PI;
-       else if (UNLIKELY(fac >=  1.0f)) return 0.0f;
-       else                             return acosf(fac);
+       if      (UNLIKELY(fac <= -1.0f)) { return (float)M_PI; }
+       else if (UNLIKELY(fac >=  1.0f)) { return 0.0f; }
+       else                             { return acosf(fac); }
 }
 
 MINLINE float saasin(float fac)
 {
-       if      (UNLIKELY(fac <= -1.0f)) return (float)-M_PI / 2.0f;
-       else if (UNLIKELY(fac >=  1.0f)) return (float) M_PI / 2.0f;
-       else                             return asinf(fac);
+       if      (UNLIKELY(fac <= -1.0f)) { return (float)-M_PI / 2.0f; }
+       else if (UNLIKELY(fac >=  1.0f)) { return (float) M_PI / 2.0f; }
+       else                             { return asinf(fac); }
 }
 
 MINLINE float sasqrt(float fac)
 {
-       if (UNLIKELY(fac <= 0.0f)) return 0.0f;
-       else                       return sqrtf(fac);
+       if (UNLIKELY(fac <= 0.0f)) { return 0.0f; }
+       else                       { return sqrtf(fac); }
 }
 
 MINLINE float saacosf(float fac)
 {
-       if      (UNLIKELY(fac <= -1.0f)) return (float)M_PI;
-       else if (UNLIKELY(fac >=  1.0f)) return 0.0f;
-       else                             return acosf(fac);
+       if      (UNLIKELY(fac <= -1.0f)) { return (float)M_PI; }
+       else if (UNLIKELY(fac >=  1.0f)) { return 0.0f; }
+       else                             { return acosf(fac); }
 }
 
 MINLINE float saasinf(float fac)
 {
-       if      (UNLIKELY(fac <= -1.0f)) return (float)-M_PI / 2.0f;
-       else if (UNLIKELY(fac >=  1.0f)) return (float) M_PI / 2.0f;
-       else                             return asinf(fac);
+       if      (UNLIKELY(fac <= -1.0f)) { return (float)-M_PI / 2.0f; }
+       else if (UNLIKELY(fac >=  1.0f)) { return (float) M_PI / 2.0f; }
+       else                             { return asinf(fac); }
 }
 
 MINLINE float sasqrtf(float fac)
 {
-       if (UNLIKELY(fac <= 0.0f)) return 0.0f;
-       else                       return sqrtf(fac);
+       if (UNLIKELY(fac <= 0.0f)) { return 0.0f; }
+       else                       { return sqrtf(fac); }
 }
 
 MINLINE float interpf(float target, float origin, float fac)
@@ -140,8 +140,9 @@ MINLINE int is_power_of_2_i(int n)
 
 MINLINE int power_of_2_max_i(int n)
 {
-       if (is_power_of_2_i(n))
+       if (is_power_of_2_i(n)) {
                return n;
+       }
 
        do {
                n = n & (n - 1);
@@ -152,8 +153,9 @@ MINLINE int power_of_2_max_i(int n)
 
 MINLINE int power_of_2_min_i(int n)
 {
-       while (!is_power_of_2_i(n))
+       while (!is_power_of_2_i(n)) {
                n = n & (n - 1);
+       }
 
        return n;
 }
@@ -387,16 +389,16 @@ MINLINE float signf(float f)
 
 MINLINE int signum_i_ex(float a, float eps)
 {
-       if (a >  eps) return  1;
-       if (a < -eps) return -1;
-       else          return  0;
+       if (a >  eps) { return  1; }
+       if (a < -eps) { return -1; }
+       else          { return  0; }
 }
 
 MINLINE int signum_i(float a)
 {
-       if (a > 0.0f) return  1;
-       if (a < 0.0f) return -1;
-       else          return  0;
+       if (a > 0.0f) { return  1; }
+       if (a < 0.0f) { return -1; }
+       else          { return  0; }
 }
 
 /** Returns number of (base ten) *significant* digits of integer part of given float
index dbc5ee1..54698dd 100644 (file)
@@ -201,7 +201,9 @@ void hex_to_rgb(char *hexcol, float *r, float *g, float *b)
 {
        unsigned int ri, gi, bi;
 
-       if (hexcol[0] == '#') hexcol++;
+       if (hexcol[0] == '#') {
+               hexcol++;
+       }
 
        if (sscanf(hexcol, "%02x%02x%02x", &ri, &gi, &bi) == 3) {
                /* six digit hex colors */
@@ -385,9 +387,9 @@ unsigned int rgb_to_cpack(float r, float g, float b)
        ig = (unsigned int)floorf(255.0f * max_ff(g, 0.0f));
        ib = (unsigned int)floorf(255.0f * max_ff(b, 0.0f));
 
-       if (ir > 255) ir = 255;
-       if (ig > 255) ig = 255;
-       if (ib > 255) ib = 255;
+       if (ir > 255) { ir = 255; }
+       if (ig > 255) { ig = 255; }
+       if (ib > 255) { ib = 255; }
 
        return (ir + (ig * 256) + (ib * 256 * 256));
 }
@@ -429,28 +431,46 @@ void rgba_float_to_uchar(unsigned char r_col[4], const float col_f[4])
 
 float srgb_to_linearrgb(float c)
 {
-       if (c < 0.04045f)
+       if (c < 0.04045f) {
                return (c < 0.0f) ? 0.0f : c * (1.0f / 12.92f);
-       else
+       }
+       else {
                return powf((c + 0.055f) * (1.0f / 1.055f), 2.4f);
+       }
 }
 
 float linearrgb_to_srgb(float c)
 {
-       if (c < 0.0031308f)
+       if (c < 0.0031308f) {
                return (c < 0.0f) ? 0.0f : c * 12.92f;
-       else
+       }
+       else {
                return 1.055f * powf(c, 1.0f / 2.4f) - 0.055f;
+       }
 }
 
 void minmax_rgb(short c[3])
 {
-       if (c[0] > 255) c[0] = 255;
-       else if (c[0] < 0) c[0] = 0;
-       if (c[1] > 255) c[1] = 255;
-       else if (c[1] < 0) c[1] = 0;
-       if (c[2] > 255) c[2] = 255;
-       else if (c[2] < 0) c[2] = 0;
+       if (c[0] > 255) {
+               c[0] = 255;
+       }
+       else if (c[0] < 0) {
+               c[0] = 0;
+       }
+
+       if (c[1] > 255) {
+               c[1] = 255;
+       }
+       else if (c[1] < 0) {
+               c[1] = 0;
+       }
+
+       if (c[2] > 255) {
+               c[2] = 255;
+       }
+       else if (c[2] < 0) {
+               c[2] = 0;
+       }
 }
 
 /* If the requested RGB shade contains a negative weight for
@@ -484,10 +504,12 @@ void lift_gamma_gain_to_asc_cdl(float *lift, float *gamma, float *gain, float *o
        for (c = 0; c < 3; c++) {
                offset[c] = lift[c] * gain[c];
                slope[c] = gain[c] * (1.0f - lift[c]);
-               if (gamma[c] == 0)
+               if (gamma[c] == 0) {
                        power[c] = FLT_MAX;
-               else
+               }
+               else {
                        power[c] = 1.0f / gamma[c];
+               }
        }
 }
 
@@ -501,8 +523,12 @@ void rgb_float_set_hue_float_offset(float rgb[3], float hue_offset)
        rgb_to_hsv(rgb[0], rgb[1], rgb[2], hsv, hsv + 1, hsv + 2);
 
        hsv[0] += hue_offset;
-       if (hsv[0] > 1.0f) hsv[0] -= 1.0f;
-       else if (hsv[0] < 0.0f) hsv[0] += 1.0f;
+       if (hsv[0] > 1.0f) {
+               hsv[0] -= 1.0f;
+       }
+       else if (hsv[0] < 0.0f) {
+               hsv[0] += 1.0f;
+       }
 
        hsv_to_rgb(hsv[0], hsv[1], hsv[2], rgb, rgb + 1, rgb + 2);
 }
@@ -551,10 +577,16 @@ static float index_to_float(const unsigned short i)
        } tmp;
 
        /* positive and negative zeros, and all gradual underflow, turn into zero: */
-       if (i < 0x80 || (i >= 0x8000 && i < 0x8080)) return 0;
+       if (i < 0x80 || (i >= 0x8000 && i < 0x8080)) {
+               return 0;
+       }
        /* All NaN's and infinity turn into the largest possible legal float: */
-       if (i >= 0x7f80 && i < 0x8000) return FLT_MAX;
-       if (i >= 0xff80) return -FLT_MAX;
+       if (i >= 0x7f80 && i < 0x8000) {
+               return FLT_MAX;
+       }
+       if (i >= 0xff80) {
+               return -FLT_MAX;
+       }
 
 #ifdef __BIG_ENDIAN__
        tmp.us[0] = i;
@@ -572,16 +604,23 @@ void BLI_init_srgb_conversion(void)
        static bool initialized = false;
        unsigned int i, b;
 
-       if (initialized)
+       if (initialized) {
                return;
+       }
        initialized = true;
 
        /* Fill in the lookup table to convert floats to bytes: */
        for (i = 0; i < 0x10000; i++) {
                float f = linearrgb_to_srgb(index_to_float((unsigned short)i)) * 255.0f;
-               if (f <= 0) BLI_color_to_srgb_table[i] = 0;
-               else if (f < 255) BLI_color_to_srgb_table[i] = (unsigned short) (f * 0x100 + 0.5f);
-               else BLI_color_to_srgb_table[i] = 0xff00;
+               if (f <= 0) {
+                       BLI_color_to_srgb_table[i] = 0;
+               }
+               else if (f < 255) {
+                       BLI_color_to_srgb_table[i] = (unsigned short) (f * 0x100 + 0.5f);
+               }
+               else {
+                       BLI_color_to_srgb_table[i] = 0xff00;
+               }
        }
 
        /* Fill in the lookup table to convert bytes to float: */
index 5396f3a..bfe060a 100644 (file)
@@ -222,8 +222,9 @@ MINLINE void srgb_to_linearrgb_uchar4_predivide(float linear[4], const unsigned
                return;
        }
 
-       for (i = 0; i < 4; i++)
+       for (i = 0; i < 4; i++) {
                fsrgb[i] = srgb[i] * (1.0f / 255.0f);
+       }
 
        srgb_to_linearrgb_predivide_v4(linear, fsrgb);
 }
index 619a73f..7c9c384 100644 (file)
@@ -133,8 +133,9 @@ float area_tri_signed_v3(const float v1[3], const float v2[3], const float v3[3]
        area = len_v3(n) * 0.5f;
 
        /* negate area for flipped triangles */
-       if (dot_v3v3(n, normal) < 0.0f)
+       if (dot_v3v3(n, normal) < 0.0f) {
                area = -area;
+       }
 
        return area;
 }
@@ -1075,14 +1076,18 @@ int isect_seg_seg_v2_int(const int v1[2], const int v2[2], const int v3[2], cons
        float div, lambda, mu;
 
        div = (float)((v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]));
-       if (div == 0.0f) return ISECT_LINE_LINE_COLINEAR;
+       if (div == 0.0f) {
+               return ISECT_LINE_LINE_COLINEAR;
+       }
 
        lambda = (float)((v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div;
 
        mu = (float)((v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div;
 
        if (lambda >= 0.0f && lambda <= 1.0f && mu >= 0.0f && mu <= 1.0f) {
-               if (lambda == 0.0f || lambda == 1.0f || mu == 0.0f || mu == 1.0f) return ISECT_LINE_LINE_EXACT;
+               if (lambda == 0.0f || lambda == 1.0f || mu == 0.0f || mu == 1.0f) {
+                       return ISECT_LINE_LINE_EXACT;
+               }
                return ISECT_LINE_LINE_CROSS;
        }
        return ISECT_LINE_LINE_NONE;
@@ -1118,14 +1123,18 @@ int isect_seg_seg_v2(const float v1[2], const float v2[2], const float v3[2], co
        float div, lambda, mu;
 
        div = (v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]);
-       if (div == 0.0f) return ISECT_LINE_LINE_COLINEAR;
+       if (div == 0.0f) {
+               return ISECT_LINE_LINE_COLINEAR;
+       }
 
        lambda = ((float)(v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div;
 
        mu = ((float)(v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div;
 
        if (lambda >= 0.0f && lambda <= 1.0f && mu >= 0.0f && mu <= 1.0f) {
-               if (lambda == 0.0f || lambda == 1.0f || mu == 0.0f || mu == 1.0f) return ISECT_LINE_LINE_EXACT;
+               if (lambda == 0.0f || lambda == 1.0f || mu == 0.0f || mu == 1.0f) {
+                       return ISECT_LINE_LINE_EXACT;
+               }
                return ISECT_LINE_LINE_CROSS;
        }
        return ISECT_LINE_LINE_NONE;
@@ -1293,8 +1302,9 @@ int isect_seg_seg_v2_point_ex(
                        u_a = dot_v2v2(s20, s10) / dot_v2v2(s10, s10);
                        u_b = dot_v2v2(s30, s10) / dot_v2v2(s10, s10);
 
-                       if (u_a > u_b)
+                       if (u_a > u_b) {
                                SWAP(float, u_a, u_b);
+                       }
 
                        if (u_a > endpoint_max || u_b < endpoint_min) {
                                /* non-overlapping segments */
@@ -1573,21 +1583,29 @@ bool isect_line_segment_tri_v3(
 
        cross_v3_v3v3(p, d, e2);
        a = dot_v3v3(e1, p);
-       if (a == 0.0f) return false;
+       if (a == 0.0f) {
+               return false;
+       }
        f = 1.0f / a;
 
        sub_v3_v3v3(s, p1, v0);
 
        u = f * dot_v3v3(s, p);
-       if ((u < 0.0f) || (u > 1.0f)) return false;
+       if ((u < 0.0f) || (u > 1.0f)) {
+               return false;
+       }
 
        cross_v3_v3v3(q, s, e1);
 
        v = f * dot_v3v3(d, q);
-       if ((v < 0.0f) || ((u + v) > 1.0f)) return false;
+       if ((v < 0.0f) || ((u + v) > 1.0f)) {
+               return false;
+       }
 
        *r_lambda = f * dot_v3v3(e2, q);
-       if ((*r_lambda < 0.0f) || (*r_lambda > 1.0f)) return false;
+       if ((*r_lambda < 0.0f) || (*r_lambda > 1.0f)) {
+               return false;
+       }
 
        if (r_uv) {
                r_uv[0] = u;
@@ -1613,21 +1631,29 @@ bool isect_line_segment_tri_epsilon_v3(
 
        cross_v3_v3v3(p, d, e2);
        a = dot_v3v3(e1, p);
-       if (a == 0.0f) return false;
+       if (a == 0.0f) {
+               return false;
+       }
        f = 1.0f / a;
 
        sub_v3_v3v3(s, p1, v0);
 
        u = f * dot_v3v3(s, p);
-       if ((u < -epsilon) || (u > 1.0f + epsilon)) return false;
+       if ((u < -epsilon) || (u > 1.0f + epsilon)) {
+               return false;
+       }
 
        cross_v3_v3v3(q, s, e1);
 
        v = f * dot_v3v3(d, q);
-       if ((v < -epsilon) || ((u + v) > 1.0f + epsilon)) return false;
+       if ((v < -epsilon) || ((u + v) > 1.0f + epsilon)) {
+               return false;
+       }
 
        *r_lambda = f * dot_v3v3(e2, q);
-       if ((*r_lambda < 0.0f) || (*r_lambda > 1.0f)) return false;
+       if ((*r_lambda < 0.0f) || (*r_lambda > 1.0f)) {
+               return false;
+       }
 
        if (r_uv) {
                r_uv[0] = u;
@@ -1657,21 +1683,29 @@ bool isect_ray_tri_v3(
 
        cross_v3_v3v3(p, ray_direction, e2);
        a = dot_v3v3(e1, p);
-       if ((a > -epsilon) && (a < epsilon)) return false;
+       if ((a > -epsilon) && (a < epsilon)) {
+               return false;
+       }
        f = 1.0f / a;
 
        sub_v3_v3v3(s, ray_origin, v0);
 
        u = f * dot_v3v3(s, p);
-       if ((u < 0.0f) || (u > 1.0f)) return false;
+       if ((u < 0.0f) || (u > 1.0f)) {
+               return false;
+       }
 
        cross_v3_v3v3(q, s, e1);
 
        v = f * dot_v3v3(ray_direction, q);
-       if ((v < 0.0f) || ((u + v) > 1.0f)) return false;
+       if ((v < 0.0f) || ((u + v) > 1.0f)) {
+               return false;
+       }
 
        *r_lambda = f * dot_v3v3(e2, q);
-       if ((*r_lambda < 0.0f)) return false;
+       if ((*r_lambda < 0.0f)) {
+               return false;
+       }
 
        if (r_uv) {
                r_uv[0] = u;
@@ -1721,21 +1755,29 @@ bool isect_ray_tri_epsilon_v3(
 
        cross_v3_v3v3(p, ray_direction, e2);
        a = dot_v3v3(e1, p);
-       if (a == 0.0f) return false;
+       if (a == 0.0f) {
+               return false;
+       }
        f = 1.0f / a;
 
        sub_v3_v3v3(s, ray_origin, v0);
 
        u = f * dot_v3v3(s, p);
-       if ((u < -epsilon) || (u > 1.0f + epsilon)) return false;
+       if ((u < -epsilon) || (u > 1.0f + epsilon)) {
+               return false;
+       }
 
        cross_v3_v3v3(q, s, e1);
 
        v = f * dot_v3v3(ray_direction, q);
-       if ((v < -epsilon) || ((u + v) > 1.0f + epsilon)) return false;
+       if ((v < -epsilon) || ((u + v) > 1.0f + epsilon)) {
+               return false;
+       }
 
        *r_lambda = f * dot_v3v3(e2, q);
-       if ((*r_lambda < 0.0f)) return false;
+       if ((*r_lambda < 0.0f)) {
+               return false;
+       }
 
        if (r_uv) {
                r_uv[0] = u;
@@ -2264,8 +2306,9 @@ static bool getLowestRoot(const float a, const float b, const float c, const flo
                float r2 = (-b + sqrtD) / (2.0f * a);
 
                /* Sort so x1 <= x2 */
-               if (r1 > r2)
+               if (r1 > r2) {
                        SWAP(float, r1, r2);
+               }
 
                /* Get lowest root: */
                if (r1 > 0.0f && r1 < maxR) {
@@ -2335,7 +2378,9 @@ bool isect_sweeping_sphere_tri_v3(const float p1[3], const float p2[3], const fl
        normalize_v3(nor);
 
        /* flip normal */
-       if (dot_v3v3(nor, vel) > 0.0f) negate_v3(nor);
+       if (dot_v3v3(nor, vel) > 0.0f) {
+               negate_v3(nor);
+       }
 
        a = dot_v3v3(p1, nor) - dot_v3v3(v0, nor);
        nordotv = dot_v3v3(nor, vel);
@@ -2349,10 +2394,13 @@ bool isect_sweeping_sphere_tri_v3(const float p1[3], const float p2[3], const fl
                float t0 = (-a + radius) / nordotv;
                float t1 = (-a - radius) / nordotv;
 
-               if (t0 > t1)
+               if (t0 > t1) {
                        SWAP(float, t0, t1);
+               }
 
-               if (t0 > 1.0f || t1 < 0.0f) return false;
+               if (t0 > 1.0f || t1 < 0.0f) {
+                       return false;
+               }
 
                /* clamp to [0, 1] */
                CLAMP(t0, 0.0f, 1.0f);
@@ -2518,25 +2566,36 @@ bool isect_axial_line_segment_tri_v3(
        sub_v3_v3v3(p, v0, p1);
 
        f = (e2[a1] * e1[a2] - e2[a2] * e1[a1]);
-       if ((f > -epsilon) && (f < epsilon)) return false;
+       if ((f > -epsilon) && (f < epsilon)) {
+               return false;
+       }
 
        v = (p[a2] * e1[a1] - p[a1] * e1[a2]) / f;
-       if ((v < 0.0f) || (v > 1.0f)) return false;
+       if ((v < 0.0f) || (v > 1.0f)) {
+               return false;
+       }
 
        f = e1[a1];
        if ((f > -epsilon) && (f < epsilon)) {
                f = e1[a2];
-               if ((f > -epsilon) && (f < epsilon)) return false;
+               if ((f > -epsilon) && (f < epsilon)) {
+                       return false;
+               }
                u = (-p[a2] - v * e2[a2]) / f;
        }
-       else
+       else {
                u = (-p[a1] - v * e2[a1]) / f;
+       }
 
-       if ((u < 0.0f) || ((u + v) > 1.0f)) return false;
+       if ((u < 0.0f) || ((u + v) > 1.0f)) {
+               return false;
+       }
 
        *r_lambda = (p[a0] + u * e1[a0] + v * e2[a0]) / (p2[a0] - p1[a0]);
 
-       if ((*r_lambda < 0.0f) || (*r_lambda > 1.0f)) return false;
+       if ((*r_lambda < 0.0f) || (*r_lambda > 1.0f)) {
+               return false;
+       }
 
        return true;
 }
@@ -2661,7 +2720,9 @@ bool isect_line_line_strict_v3(const float v1[3], const float v2[3],
                        mul_v3_fl(a, f1);
                        add_v3_v3v3(vi, v1, a);
 
-                       if (r_lambda) *r_lambda = f1;
+                       if (r_lambda) {
+                               *r_lambda = f1;
+                       }
 
                        return true; /* intersection found */
                }
@@ -2708,30 +2769,36 @@ bool isect_ray_aabb_v3(
        const float tymin = (bbox[data->sign[1]][1] - data->ray_origin[1]) * data->ray_inv_dir[1];
        const float tymax = (bbox[1 - data->sign[1]][1] - data->ray_origin[1]) * data->ray_inv_dir[1];
 
-       if ((tmin > tymax) || (tymin > tmax))
+       if ((tmin > tymax) || (tymin > tmax)) {
                return false;
+       }
 
-       if (tymin > tmin)
+       if (tymin > tmin) {
                tmin = tymin;
+       }
 
-       if (tymax < tmax)
+       if (tymax < tmax) {
                tmax = tymax;
+       }
 
        const float tzmin = (bbox[data->sign[2]][2] - data->ray_origin[2]) * data->ray_inv_dir[2];
        const float tzmax = (bbox[1 - data->sign[2]][2] - data->ray_origin[2]) * data->ray_inv_dir[2];
 
-       if ((tmin > tzmax) || (tzmin > tmax))
+       if ((tmin > tzmax) || (tzmin > tmax)) {
                return false;
+       }
 
-       if (tzmin > tmin)
+       if (tzmin > tmin) {
                tmin = tzmin;
+       }
 
        /* Note: tmax does not need to be updated since we don't use it
         * keeping this here for future reference - jwilkins */
        //if (tzmax < tmax) tmax = tzmax;
 
-       if (tmin_out)
+       if (tmin_out) {
                (*tmin_out) = tmin;
+       }
 
        return true;
 }
@@ -2764,10 +2831,12 @@ bool isect_ray_aabb_v3_simple(
                return false;
        }
        else {
-               if (tmin)
+               if (tmin) {
                        *tmin = hit_dist[0];
-               if (tmax)
+               }
+               if (tmax) {
                        *tmax = hit_dist[1];
+               }
                return true;
        }
 }
@@ -2952,7 +3021,9 @@ static bool point_in_slice_as(float p[3], float origin[3], float normal[3])
        float h, rp[3];
        sub_v3_v3v3(rp, p, origin);
        h = dot_v3v3(normal, rp) / dot_v3v3(normal, normal);
-       if (h < 0.0f || h > 1.0f) return false;
+       if (h < 0.0f || h > 1.0f) {
+               return false;
+       }
        return true;
 }
 
@@ -2967,9 +3038,9 @@ bool point_in_slice_seg(float p[3], float l1[3], float l2[3])
 
 bool isect_point_tri_prism_v3(const float p[3], const float v1[3], const float v2[3], const float v3[3])
 {
-       if (!point_in_slice(p, v1, v2, v3)) return false;
-       if (!point_in_slice(p, v2, v3, v1)) return false;
-       if (!point_in_slice(p, v3, v1, v2)) return false;
+       if (!point_in_slice(p, v1, v2, v3)) { return false; }
+       if (!point_in_slice(p, v2, v3, v1)) { return false; }
+       if (!point_in_slice(p, v3, v1, v2)) { return false; }
        return true;
 }
 
@@ -3010,8 +3081,10 @@ bool clip_segment_v3_plane(
        sub_v3_v3v3(dp, p2, p1);
        div = dot_v3v3(dp, plane);
 
-       if (div == 0.0f) /* parallel */
+       if (div == 0.0f) {
+               /* parallel */
                return true;
+       }
 
        float t = -plane_point_side_v3(plane, p1);
 
@@ -3200,14 +3273,18 @@ void interp_weights_quad_v3(float w[4], const float v1[3], const float v2[3], co
        w[0] = w[1] = w[2] = w[3] = 0.0f;
 
        /* first check for exact match */
-       if (equals_v3v3(co, v1))
+       if (equals_v3v3(co, v1)) {
                w[0] = 1.0f;
-       else if (equals_v3v3(co, v2))
+       }
+       else if (equals_v3v3(co, v2)) {
                w[1] = 1.0f;
-       else if (equals_v3v3(co, v3))
+       }
+       else if (equals_v3v3(co, v3)) {
                w[2] = 1.0f;
-       else if (equals_v3v3(co, v4))
+       }
+       else if (equals_v3v3(co, v4)) {
                w[3] = 1.0f;
+       }
        else {
                /* otherwise compute barycentric interpolation weights */
                float n1[3], n2[3], n[3];
@@ -3487,10 +3564,12 @@ int interp_sparse_array(float *array, const int list_size, const float skipval)
        int i;
 
        for (i = 0; i < list_size; i++) {
-               if (array[i] == skipval)
+               if (array[i] == skipval) {
                        found_invalid = 1;
-               else
+               }
+               else {
                        found_valid = 1;
+               }
        }
 
        if (found_valid == 0) {
@@ -3898,8 +3977,9 @@ void resolve_quad_uv_v2_deriv(float r_uv[2], float r_deriv[2][2],
 
        if (IS_ZERO(denom) != 0) {
                const double fDen = a - fC;
-               if (IS_ZERO(fDen) == 0)
+               if (IS_ZERO(fDen) == 0) {
                        r_uv[0] = (float)(a / fDen);
+               }
        }
        else {
                const double desc_sq = b * b - a * fC;
@@ -3922,8 +4002,9 @@ void resolve_quad_uv_v2_deriv(float r_uv[2], float r_deriv[2][2],
                        denom = denom_t;
                }
 
-               if (IS_ZERO(denom) == 0)
+               if (IS_ZERO(denom) == 0) {
                        r_uv[1] = (float)((double)((1.0f - r_uv[0]) * (st0[i] - st[i]) + r_uv[0] * (st1[i] - st[i])) / denom);
+               }
        }
 
        if (r_deriv) {
@@ -3974,10 +4055,12 @@ float resolve_quad_u_v2(
 
        if (IS_ZERO(denom) != 0) {
                const double fDen = a - fC;
-               if (IS_ZERO(fDen) == 0)
+               if (IS_ZERO(fDen) == 0) {
                        return (float)(a / fDen);
-               else
+               }
+               else {
                        return 0.0f;
+               }
        }
        else {
                const double desc_sq = b * b - a * fC;
@@ -4183,12 +4266,14 @@ static void i_multmatrix(float icand[4][4], float Vm[4][4])
        int row, col;
        float temp[4][4];
 
-       for (row = 0; row < 4; row++)
-               for (col = 0; col < 4; col++)
+       for (row = 0; row < 4; row++) {
+               for (col = 0; col < 4; col++) {
                        temp[row][col] = (icand[row][0] * Vm[0][col] +
                                          icand[row][1] * Vm[1][col] +
                                          icand[row][2] * Vm[2][col] +
                                          icand[row][3] * Vm[3][col]);
+               }
+       }
        copy_m4_m4(Vm, temp);
 }
 
@@ -4270,22 +4355,24 @@ int box_clip_bounds_m4(float boundbox[2][3], const float bounds[4], float winmat
 
                fl = 0;
                if (bounds) {
-                       if (vec[0] > bounds[1] * vec[3]) fl |= 1;
-                       if (vec[0] < bounds[0] * vec[3]) fl |= 2;
-                       if (vec[1] > bounds[3] * vec[3]) fl |= 4;
-                       if (vec[1] < bounds[2] * vec[3]) fl |= 8;
+                       if (vec[0] > bounds[1] * vec[3]) { fl |= 1; }
+                       if (vec[0] < bounds[0] * vec[3]) { fl |= 2; }
+                       if (vec[1] > bounds[3] * vec[3]) { fl |= 4; }
+                       if (vec[1] < bounds[2] * vec[3]) { fl |= 8; }
                }
                else {
-                       if (vec[0] < -vec[3]) fl |= 1;
-                       if (vec[0] > vec[3]) fl |= 2;
-                       if (vec[1] < -vec[3]) fl |= 4;
-                       if (vec[1] > vec[3]) fl |= 8;
+                       if (vec[0] < -vec[3]) { fl |= 1; }
+                       if (vec[0] >  vec[3]) { fl |= 2; }
+                       if (vec[1] < -vec[3]) { fl |= 4; }
+                       if (vec[1] >  vec[3]) { fl |= 8; }
                }
-               if (vec[2] < -vec[3]) fl |= 16;
-               if (vec[2] > vec[3]) fl |= 32;
+               if (vec[2] < -vec[3]) { fl |= 16; }
+               if (vec[2] >  vec[3]) { fl |= 32; }
 
                flag &= fl;
-               if (flag == 0) return 0;
+               if (flag == 0) {
+                       return 0;
+               }
        }
 
        return flag;
@@ -4551,10 +4638,10 @@ void vcloud_estimate_transform_v3(
 
        int a;
        /* first set up a nice default response */
-       if (lloc) zero_v3(lloc);
-       if (rloc) zero_v3(rloc);
-       if (lrot) unit_m3(lrot);
-       if (lscale) unit_m3(lscale);
+       if (lloc) { zero_v3(lloc); }
+       if (rloc) { zero_v3(rloc); }
+       if (lrot) { unit_m3(lrot); }
+       if (lscale) { unit_m3(lscale); }
        /* do com for both clouds */
        if (pos && rpos && (list_size > 0)) { /* paranoya check */
                /* do com for both clouds */
@@ -4587,8 +4674,12 @@ void vcloud_estimate_transform_v3(
 
                mul_v3_fl(accu_com, 1.0f / accu_weight);
                mul_v3_fl(accu_rcom, 1.0f / accu_rweight);
-               if (lloc) copy_v3_v3(lloc, accu_com);
-               if (rloc) copy_v3_v3(rloc, accu_rcom);
+               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 */
@@ -4657,12 +4748,16 @@ void vcloud_estimate_transform_v3(
                        if (i) {
                                float scale[3][3];
                                float irot[3][3];
-                               if (lrot) copy_m3_m3(lrot, q);
+                               if (lrot) {
+                                       copy_m3_m3(lrot, q);
+                               }
                                invert_m3_m3(irot, q);
                                invert_m3_m3(qi, mr);
                                mul_m3_m3m3(q, m, qi);
                                mul_m3_m3m3(scale, irot, q);
-                               if (lscale) copy_m3_m3(lscale, scale);
+                               if (lscale) {
+                                       copy_m3_m3(lscale, scale);
+                               }
 
                        }
                }
@@ -4691,9 +4786,9 @@ bool form_factor_visible_quad(const float p[3], const float n[3],
        sd[1] = dot_v3v3(n, v1) - c;
        sd[2] = dot_v3v3(n, v2) - c;
 
-       if (fabsf(sd[0]) < epsilon) sd[0] = 0.0f;
-       if (fabsf(sd[1]) < epsilon) sd[1] = 0.0f;
-       if (fabsf(sd[2]) < epsilon) sd[2] = 0.0f;
+       if (fabsf(sd[0]) < epsilon) { sd[0] = 0.0f; }
+       if (fabsf(sd[1]) < epsilon) { sd[1] = 0.0f; }
+       if (fabsf(sd[2]) < epsilon) { sd[2] = 0.0f; }
 
        if (sd[0] > 0.0f) {
                if (sd[1] > 0.0f) {
@@ -5085,11 +5180,13 @@ float form_factor_hemi_poly(float p[3], float n[3], float v1[3], float v2[3], fl
         * covered by a quad or triangle, cosine weighted */
        float q0[3], q1[3], q2[3], q3[3], contrib = 0.0f;
 
-       if (form_factor_visible_quad(p, n, v1, v2, v3, q0, q1, q2, q3))
+       if (form_factor_visible_quad(p, n, v1, v2, v3, q0, q1, q2, q3)) {
                contrib += form_factor_quad(p, n, q0, q1, q2, q3);
+       }
 
-       if (v4 && form_factor_visible_quad(p, n, v1, v3, v4, q0, q1, q2, q3))
+       if (v4 && form_factor_visible_quad(p, n, v1, v3, v4, q0, q1, q2, q3)) {
                contrib += form_factor_quad(p, n, q0, q1, q2, q3);
+       }
 
        return contrib;
 }
index 58262b9..0922c47 100644 (file)
@@ -73,16 +73,18 @@ MINLINE void mul_sh_fl(float r[9], const float f)
 {
        int i;
 
-       for (i = 0; i < 9; i++)
+       for (i = 0; i < 9; i++) {
                r[i] *= f;
+       }
 }
 
 MINLINE void add_sh_shsh(float r[9], const float a[9], const float b[9])
 {
        int i;
 
-       for (i = 0; i < 9; i++)
+       for (i = 0; i < 9; i++) {
                r[i] = a[i] + b[i];
+       }
 }
 
 MINLINE float dot_shsh(const float a[9], const float b[9])
@@ -90,8 +92,9 @@ MINLINE float dot_shsh(const float a[9], const float b[9])
        float r = 0.0f;
        int i;
 
-       for (i = 0; i < 9; i++)
+       for (i = 0; i < 9; i++) {
                r += a[i] * b[i];
+       }
 
        return r;
 }
index 5b3f634..ed2b48f 100644 (file)
@@ -273,8 +273,12 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
 
                /* pixel value must be already wrapped, however values at boundaries may flip */
                if (wrap_x) {
-                       if (x1 < 0) x1 = width  - 1;
-                       if (x2 >= width) x2 = 0;
+                       if (x1 < 0) {
+                               x1 = width  - 1;
+                       }
+                       if (x2 >= width) {
+                               x2 = 0;
+                       }
                }
                else if (x2 < 0 || x1 >= width) {
                        copy_vn_fl(float_output, components, 0.0f);
@@ -282,8 +286,12 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
                }
 
                if (wrap_y) {
-                       if (y1 < 0) y1 = height - 1;
-                       if (y2 >= height) y2 = 0;
+                       if (y1 < 0) {
+                               y1 = height - 1;
+                       }
+                       if (y2 >= height) {
+                               y2 = 0;
+                       }
                }
                else if (y2 < 0 || y1 >= height) {
                        copy_vn_fl(float_output, components, 0.0f);
@@ -291,17 +299,33 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
                }
 
                /* sample including outside of edges of image */
-               if (x1 < 0 || y1 < 0) row1 = empty;
-               else row1 = float_buffer + width * y1 * components + components * x1;
+               if (x1 < 0 || y1 < 0) {
+                       row1 = empty;
+               }
+               else {
+                       row1 = float_buffer + width * y1 * components + components * x1;
+               }
 
-               if (x1 < 0 || y2 > height - 1) row2 = empty;
-               else row2 = float_buffer + width * y2 * components + components * x1;
+               if (x1 < 0 || y2 > height - 1) {
+                       row2 = empty;
+               }
+               else {
+                       row2 = float_buffer + width * y2 * components + components * x1;
+               }
 
-               if (x2 > width - 1 || y1 < 0) row3 = empty;
-               else row3 = float_buffer + width * y1 * components + components * x2;
+               if (x2 > width - 1 || y1 < 0) {
+                       row3 = empty;
+               }
+               else {
+                       row3 = float_buffer + width * y1 * components + components * x2;
+               }
 
-               if (x2 > width - 1 || y2 > height - 1) row4 = empty;
-               else row4 = float_buffer + width * y2 * components + components * x2;
+               if (x2 > width - 1 || y2 > height - 1) {
+                       row4 = empty;
+               }
+               else {
+                       row4 = float_buffer + width * y2 * components + components * x2;
+               }
 
                a = u - floorf(u);
                b = v - floorf(v);
@@ -328,8 +352,12 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
 
                /* pixel value must be already wrapped, however values at boundaries may flip */
                if (wrap_x) {
-                       if (x1 < 0) x1 = width  - 1;
-                       if (x2 >= width) x2 = 0;
+                       if (x1 < 0) {
+                               x1 = width  - 1;
+                       }
+                       if (x2 >= width) {
+                               x2 = 0;
+                       }
                }
                else if (x2 < 0 || x1 >= width) {
                        copy_vn_uchar(byte_output, components, 0);
@@ -337,8 +365,12 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
                }
 
                if (wrap_y) {
-                       if (y1 < 0) y1 = height - 1;
-                       if (y2 >= height) y2 = 0;
+                       if (y1 < 0) {
+                               y1 = height - 1;
+                       }
+                       if (y2 >= height) {
+                               y2 = 0;
+                       }
                }
                else if (y2 < 0 || y1 >= height) {
                        copy_vn_uchar(byte_output, components, 0);
@@ -346,17 +378,33 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
                }
 
                /* sample including outside of edges of image */
-               if (x1 < 0 || y1 < 0) row1 = empty;
-               else row1 = byte_buffer + width * y1 * components + components * x1;
+               if (x1 < 0 || y1 < 0) {
+                       row1 = empty;
+               }
+               else {
+                       row1 = byte_buffer + width * y1 * components + components * x1;
+               }
 
-               if (x1 < 0 || y2 > height - 1) row2 = empty;
-               else row2 = byte_buffer + width * y2 * components + components * x1;
+               if (x1 < 0 || y2 > height - 1) {
+                       row2 = empty;
+               }
+               else {
+                       row2 = byte_buffer + width * y2 * components + components * x1;
+               }
 
-               if (x2 > width - 1 || y1 < 0) row3 = empty;
-               else row3 = byte_buffer + width * y1 * components + components * x2;
+               if (x2 > width - 1 || y1 < 0) {
+                       row3 = empty;
+               }
+               else {
+                       row3 = byte_buffer + width * y1 * components + components * x2;
+               }
 
-               if (x2 > width - 1 || y2 > height - 1) row4 = empty;
-               else row4 = byte_buffer + width * y2 * components + components * x2;
+               if (x2 > width - 1 || y2 > height - 1) {
+                       row4 = empty;
+               }
+               else {
+                       row4 = byte_buffer + width * y2 * components + components * x2;
+               }
 
                a = u - floorf(u);
                b = v - floorf(v);
@@ -548,10 +596,10 @@ void BLI_ewa_filter(const int width, const int height,
        /* note: if eccentricity gets clamped (see above),
         * the ue/ve limits can also be lowered accordingly
         */
-       if (U0 - (float)u1 > EWA_MAXIDX) u1 = (int)U0 - EWA_MAXIDX;
-       if ((float)u2 - U0 > EWA_MAXIDX) u2 = (int)U0 + EWA_MAXIDX;
-       if (V0 - (float)v1 > EWA_MAXIDX) v1 = (int)V0 - EWA_MAXIDX;
-       if ((float)v2 - V0 > EWA_MAXIDX) v2 = (int)V0 + EWA_MAXIDX;
+       if (U0 - (float)u1 > EWA_MAXIDX) { u1 = (int)U0 - EWA_MAXIDX; }
+       if ((float)u2 - U0 > EWA_MAXIDX) { u2 = (int)U0 + EWA_MAXIDX; }
+       if (V0 - (float)v1 > EWA_MAXIDX) { v1 = (int)V0 - EWA_MAXIDX; }
+       if ((float)v2 - V0 > EWA_MAXIDX) { v2 = (int)V0 + EWA_MAXIDX; }
 
        /* Early output check for cases the whole region is outside of the buffer. */
        if ((u2 < 0 || u1 >= width) ||  (v2 < 0 || v1 >= height)) {
index 747d9a1..68c80be 100644 (file)
@@ -177,12 +177,15 @@ void swap_m4m4(float m1[4][4], float m2[4][4])
 
 void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
 {
-       if (A == R)
+       if (A == R) {
                mul_m4_m4_post(R, B);
-       else if (B == R)
+       }
+       else if (B == R) {
                mul_m4_m4_pre(R, A);
-       else
+       }
+       else {
                mul_m4_m4m4_uniq(R, A, B);
+       }
 }
 
 void mul_m4_m4m4_uniq(float R[4][4], const float A[4][4], const float B[4][4])
@@ -249,12 +252,15 @@ void mul_m4_m4_post(float R[4][4], const float B[4][4])
 
 void mul_m3_m3m3(float R[3][3], const float A[3][3], const float B[3][3])
 {
-       if (A == R)
+       if (A == R) {
                mul_m3_m3_post(R, B);
-       else if (B == R)
+       }
+       else if (B == R) {
                mul_m3_m3_pre(R, A);
-       else
+       }
+       else {
                mul_m3_m3m3_uniq(R, A, B);
+       }
 }
 
 void mul_m3_m3_pre(float R[3][3], const float A[3][3])
@@ -713,54 +719,66 @@ void mul_m3_fl(float m[3][3], float f)
 {
        int i, j;
 
-       for (i = 0; i < 3; i++)
-               for (j = 0; j < 3; j++)
+       for (i = 0; i < 3; i++) {
+               for (j = 0; j < 3; j++) {
                        m[i][j] *= f;
+               }
+       }
 }
 
 void mul_m4_fl(float m[4][4], float f)
 {
        int i, j;
 
-       for (i = 0; i < 4; i++)
-               for (j = 0; j < 4; j++)
+       for (i = 0; i < 4; i++) {
+               for (j = 0; j < 4; j++) {
                        m[i][j] *= f;
+               }
+       }
 }
 
 void mul_mat3_m4_fl(float m[4][4], float f)
 {
        int i, j;
 
-       for (i = 0; i < 3; i++)
-               for (j = 0; j < 3; j++)
+       for (i = 0; i < 3; i++) {
+               for (j = 0; j < 3; j++) {
                        m[i][j] *= f;
+               }
+       }
 }
 
 void negate_m3(float m[3][3])
 {
        int i, j;
 
-       for (i = 0; i < 3; i++)
-               for (j = 0; j < 3; j++)
+       for (i = 0; i < 3; i++) {
+               for (j = 0; j < 3; j++) {
                        m[i][j] *= -1.0f;
+               }
+       }
 }
 
 void negate_mat3_m4(float m[4][4])
 {
        int i, j;
 
-       for (i = 0; i < 3; i++)
-               for (j = 0; j < 3; j++)
+       for (i = 0; i < 3; i++) {
+               for (j = 0; j < 3; j++) {
                        m[i][j] *= -1.0f;
+               }
+       }
 }
 
 void negate_m4(float m[4][4])
 {
        int i, j;
 
-       for (i = 0; i < 4; i++)
-               for (j = 0; j < 4; j++)
+       for (i = 0; i < 4; i++) {
+               for (j = 0; j < 4; j++) {
                        m[i][j] *= -1.0f;
+               }
+       }
 }
 
 void mul_m3_v3_double(const float mat[3][3], double vec[3])
@@ -777,36 +795,44 @@ void add_m3_m3m3(float m1[3][3], const float m2[3][3], const float m3[3][3])
 {
        int i, j;
 
-       for (i = 0; i < 3; i++)
-               for (j = 0; j < 3; j++)
+       for (i = 0; i < 3; i++) {
+               for (j = 0; j < 3; j++) {
                        m1[i][j] = m2[i][j] + m3[i][j];
+               }
+       }
 }
 
 void add_m4_m4m4(float m1[4][4], const float m2[4][4], const float m3[4][4])
 {
        int i, j;
 
-       for (i = 0; i < 4; i++)
-               for (j = 0; j < 4; j++)
+       for (i = 0; i < 4; i++) {
+               for (j = 0; j < 4; j++) {
                        m1[i][j] = m2[i][j] + m3[i][j];
+               }
+       }
 }
 
 void sub_m3_m3m3(float m1[3][3], const float m2[3][3], const float m3[3][3])
 {
        int i, j;
 
-       for (i = 0; i < 3; i++)
-               for (j = 0; j < 3; j++)
+       for (i = 0; i < 3; i++) {
+               for (j = 0; j < 3; j++) {
                        m1[i][j] = m2[i][j] - m3[i][j];
+               }
+       }
 }
 
 void sub_m4_m4m4(float m1[4][4], const float m2[4][4], const float m3[4][4])
 {
        int i, j;
 
-       for (i = 0; i < 4; i++)
-               for (j = 0; j < 4; j++)
+       for (i = 0; i < 4; i++) {
+               for (j = 0; j < 4; j++) {
                        m1[i][j] = m2[i][j] - m3[i][j];
+               }
+       }
 }
 
 float determinant_m3_array(const float m[3][3])
@@ -1002,11 +1028,15 @@ void transpose_m4_m4(float rmat[4][4], const float mat[4][4])
 /* TODO: return bool */
 int compare_m4m4(const float mat1[4][4], const float mat2[4][4], float limit)
 {
-       if (compare_v4v4(mat1[0], mat2[0], limit))
-               if (compare_v4v4(mat1[1], mat2[1], limit))
-                       if (compare_v4v4(mat1[2], mat2[2], limit))
-                               if (compare_v4v4(mat1[3], mat2[3], limit))
+       if (compare_v4v4(mat1[0], mat2[0], limit)) {
+               if (compare_v4v4(mat1[1], mat2[1], limit)) {
+                       if (compare_v4v4(mat1[2], mat2[2], limit)) {
+                               if (compare_v4v4(mat1[3], mat2[3], limit)) {
                                        return 1;
+                               }
+                       }
+               }
+       }
        return 0;
 }
 
@@ -1194,8 +1224,9 @@ bool is_orthogonal_m3(const float m[3][3])
 
        for (i = 0; i < 3; i++) {
                for (j = 0; j < i; j++) {
-                       if (fabsf(dot_v3v3(m[i], m[j])) > 1e-5f)
+                       if (fabsf(dot_v3v3(m[i], m[j])) > 1e-5f) {
                                return false;
+                       }
                }
        }
 
@@ -1208,8 +1239,9 @@ bool is_orthogonal_m4(const float m[4][4])
 
        for (i = 0; i < 4; i++) {
                for (j = 0; j < i; j++) {
-                       if (fabsf(dot_v4v4(m[i], m[j])) > 1e-5f)
+                       if (fabsf(dot_v4v4(m[i], m[j])) > 1e-5f) {
                                return false;
+                       }
                }
 
        }
@@ -1222,9 +1254,11 @@ bool is_orthonormal_m3(const float m[3][3])
        if (is_orthogonal_m3(m)) {
                int i;
 
-               for (i = 0; i < 3; i++)
-                       if (fabsf(dot_v3v3(m[i], m[i]) - 1) > 1e-5f)
+               for (i = 0; i < 3; i++) {
+                       if (fabsf(dot_v3v3(m[i], m[i]) - 1) > 1e-5f) {
                                return false;
+                       }
+               }
 
                return true;
        }
@@ -1238,8 +1272,9 @@ bool is_orthonormal_m4(const float m[4][4])
                int i;
 
                for (i = 0; i < 4; i++)
-                       if (fabsf(dot_v4v4(m[i], m[i]) - 1) > 1e-5f)
+                       if (fabsf(dot_v4v4(m[i], m[i]) - 1) > 1e-5f) {
                                return false;
+                       }
 
                return true;
        }
@@ -2071,8 +2106,9 @@ void svd_m4(float U[4][4], float s[4], float V[4][4], float A_[4][4])
                        /* Place the transformation in U for subsequent back
                         * multiplication. */
 
-                       for (i = k; i < m; i++)
+                       for (i = k; i < m; i++) {
                                U[i][k] = A[i][k];
+                       }
                }
                if (k < nrt) {
 
@@ -2120,8 +2156,9 @@ void svd_m4(float U[4][4], float s[4], float V[4][4], float A_[4][4])
                        /* Place the transformation in V for subsequent
                         * back multiplication. */
 
-                       for (i = k + 1; i < n; i++)
+                       for (i = k + 1; i < n; i++) {
                                V[i][k] = e[i];
+                       }
                }
        }
 
@@ -2205,8 +2242,9 @@ void svd_m4(float U[4][4], float s[4], float V[4][4], float A_[4][4])
                int kase = 0;
 
                /* Test for maximum iterations to avoid infinite loop */
-               if (maxiter == 0)
+               if (maxiter == 0) {
                        break;
+               }
                maxiter--;
 
                /* This section of the program inspects for
@@ -2394,8 +2432,9 @@ void svd_m4(float U[4][4], float s[4], float V[4][4], float A_[4][4])
                                if (s[k] <= 0.0f) {
                                        s[k] = (s[k] < 0.0f ? -s[k] : 0.0f);
 
-                                       for (i = 0; i <= pp; i++)
+                                       for (i = 0; i <= pp; i++) {
                                                V[i][k] = -V[i][k];
+                                       }
                                }
 
                                /* Order the singular values. */
@@ -2445,8 +2484,9 @@ void pseudoinverse_m4_m4(float Ainv[4][4], const float A_[4][4], float epsilon)
        transpose_m4(V);
 
        zero_m4(Wm);
-       for (i = 0; i < 4; i++)
+       for (i = 0; i < 4; i++) {
                Wm[i][i] = (W[i] < epsilon) ? 0.0f : 1.0f / W[i];
+       }
 
        transpose_m4(V);
 
index 5f6bbcc..90eb76f 100644 (file)
@@ -137,8 +137,9 @@ void invert_qt(float q[4])
 {
        const float f = dot_qtqt(q, q);
 
-       if (f == 0.0f)
+       if (f == 0.0f) {
                return;
+       }
 
        conjugate_qt(q);
        mul_qt_fl(q, 1.0f / f);
@@ -671,8 +672,9 @@ void vec_to_quat(float q[4], const float vec[3], short axis, const short upflag)
                nor[1] = -tvec[2];
                nor[2] =  tvec[1];
 
-               if (fabsf(tvec[1]) + fabsf(tvec[2]) < eps)
+               if (fabsf(tvec[1]) + fabsf(tvec[2]) < eps) {
                        nor[1] = 1.0f;
+               }
 
                co = tvec[0];
        }
@@ -681,8 +683,9 @@ void vec_to_quat(float q[4], const float vec[3], short axis, const short upflag)
                nor[1] =  0.0;
                nor[2] = -tvec[0];
 
-               if (fabsf(tvec[0]) + fabsf(tvec[2]) < eps)
+               if (fabsf(tvec[0]) + fabsf(tvec[2]) < eps) {
                        nor[2] = 1.0f;
+               }
 
                co = tvec[1];
        }
@@ -691,8 +694,9 @@ void vec_to_quat(float q[4], const float vec[3], short axis, const short upflag)
                nor[1] =  tvec[0];
                nor[2] =  0.0;
 
-               if (fabsf(tvec[0]) + fabsf(tvec[1]) < eps)
+               if (fabsf(tvec[0]) + fabsf(tvec[1]) < eps) {
                        nor[0] = 1.0f;
+               }
 
                co = tvec[2];
        }
@@ -709,16 +713,16 @@ void vec_to_quat(float q[4], const float vec[3], short axis, const short upflag)
                quat_to_mat3(mat, q);
 
                if (axis == 0) {
-                       if (upflag == 1) angle =  0.5f * atan2f(fp[2], fp[1]);
-                       else             angle = -0.5f * atan2f(fp[1], fp[2]);
+                       if (upflag == 1) { angle =  0.5f * atan2f(fp[2], fp[1]); }
+                       else             { angle = -0.5f * atan2f(fp[1], fp[2]); }
                }
                else if (axis == 1) {
-                       if (upflag == 0) angle = -0.5f * atan2f(fp[2], fp[0]);
-                       else             angle =  0.5f * atan2f(fp[0], fp[2]);
+                       if (upflag == 0) { angle = -0.5f * atan2f(fp[2], fp[0]); }
+                       else             { angle =  0.5f * atan2f(fp[0], fp[2]); }
                }
                else {
-                       if (upflag == 0) angle =  0.5f * atan2f(-fp[1], -fp[0]);
-                       else             angle = -0.5f * atan2f(-fp[0], -fp[1]);
+                       if (upflag == 0) { angle =  0.5f * atan2f(-fp[1], -fp[0]); }
+                       else             { angle = -0.5f * atan2f(-fp[0], -fp[1]); }
                }
 
                co = cosf(angle);
@@ -954,8 +958,9 @@ void quat_to_axis_angle(float axis[3], float *angle, const float q[4])
        *angle = ha * 2;
 
        /* prevent division by zero for axis conversion */
-       if (fabsf(si) < 0.0005f)
+       if (fabsf(si) < 0.0005f) {
                si = 1.0f;
+       }
 
        axis[0] = q[1] / si;
        axis[1] = q[2] / si;
@@ -1380,9 +1385,15 @@ void rotate_eul(float beul[3], const char axis, const float ang)
        assert(axis >= 'X' && axis <= 'Z');
 
        eul[0] = eul[1] = eul[2] = 0.0f;
-       if (axis == 'X') eul[0] = ang;
-       else if (axis == 'Y') eul[1] = ang;
-       else eul[2] = ang;
+       if (axis == 'X') {
+               eul[0] = ang;
+       }
+       else if (axis == 'Y') {
+               eul[1] = ang;
+       }
+       else {
+               eul[2] = ang;
+       }
 
        eul_to_mat3(mat1, eul);
        eul_to_mat3(mat2, beul);
@@ -1418,16 +1429,16 @@ void compatible_eul(float eul[3], const float oldrot[3])
 
        /* is 1 of the axis rotations larger than 180 degrees and the other small? NO ELSE IF!! */
        if (fabsf(deul[0]) > 3.2f && fabsf(deul[1]) < 1.6f && fabsf(deul[2]) < 1.6f) {
-               if (deul[0] > 0.0f) eul[0] -= pi_x2;
-               else                eul[0] += pi_x2;
+               if (deul[0] > 0.0f) { eul[0] -= pi_x2; }
+               else                { eul[0] += pi_x2; }
        }
        if (fabsf(deul[1]) > 3.2f && fabsf(deul[2]) < 1.6f && fabsf(deul[0]) < 1.6f) {
-               if (deul[1] > 0.0f) eul[1] -= pi_x2;
-               else                eul[1] += pi_x2;
+               if (deul[1] > 0.0f) { eul[1] -= pi_x2; }
+               else                { eul[1] += pi_x2; }
        }
        if (fabsf(deul[2]) > 3.2f && fabsf(deul[0]) < 1.6f && fabsf(deul[1]) < 1.6f) {
-               if (deul[2] > 0.0f) eul[2] -= pi_x2;
-               else                eul[2] += pi_x2;
+               if (deul[2] > 0.0f) { eul[2] -= pi_x2; }
+               else                { eul[2] += pi_x2; }
        }
 }
 
@@ -1506,12 +1517,15 @@ static const RotOrderInfo rotOrders[] = {
 static const RotOrderInfo *get_rotation_order_info(const short order)
 {
        assert(order >= 0 && order <= 6);
-       if (order < 1)
+       if (order < 1) {
                return &rotOrders[0];
-       else if (order < 6)
+       }
+       else if (order < 6) {
                return &rotOrders[order - 1];
-       else
+       }
+       else {
                return &rotOrders[5];
+       }
 }
 
 /* Construct quaternion from Euler angles (in radians). */
@@ -1547,7 +1561,9 @@ void eulO_to_quat(float q[4], const float e[3], const short order)
        q[2] = (float)(a[1]);
        q[3] = (float)(a[2]);
 
-       if (R->parity) q[j + 1] = -q[j + 1];
+       if (R->parity) {
+               q[j + 1] = -q[j + 1];
+       }
 }
 
 /* Convert quaternion to Euler angles (in radians). */
@@ -1761,12 +1777,15 @@ void rotate_eulO(float beul[3], const short order, char axis, float ang)
 
        zero_v3(eul);
 
-       if (axis == 'X')
+       if (axis == 'X') {
                eul[0] = ang;
-       else if (axis == 'Y')
+       }
+       else if (axis == 'Y') {
                eul[1] = ang;
-       else
+       }
+       else {
                eul[2] = ang;
+       }
 
        eulO_to_mat3(mat1, eul, order);
        eulO_to_mat3(mat2, beul, order);
@@ -1943,8 +1962,10 @@ void add_weighted_dq_dq(DualQuat *dqsum, const DualQuat *dq, float weight)
        if (dq->scale_weight) {
                float wmat[4][4];
 
-               if (flipped) /* we don't want negative weights for scaling */
+               if (flipped) {
+                       /* we don't want negative weights for scaling */
                        weight = -weight;
+               }
 
                copy_m4_m4(wmat, (float(*)[4])dq->scale);
                mul_m4_fl(wmat, weight);
@@ -1995,8 +2016,9 @@ void mul_v3m3_dq(float co[3], float mat[3][3], DualQuat *dq)
        M[2][2] = w * w + z * z - x * x - y * y;
 
        len2 = dot_qtqt(dq->quat, dq->quat);
-       if (len2 > 0.0f)
+       if (len2 > 0.0f) {
                len2 = 1.0f / len2;
+       }
 
        /* translation */
        t[0] = 2 * (-t0 * x + w * t1 - t2 * z + y * t3);
@@ -2004,8 +2026,9 @@ void mul_v3m3_dq(float co[3], float mat[3][3], DualQuat *dq)
        t[2] = 2 * (-t0 * z + x * t2 + w * t3 - t1 * y);
 
        /* apply scaling */
-       if (dq->scale_weight)
+       if (dq->scale_weight) {
                mul_m4_v3(dq->scale, co);
+       }
 
        /* apply rotation and translation */
        mul_m3_v3(M, co);
@@ -2019,8 +2042,9 @@ void mul_v3m3_dq(float co[3], float mat[3][3], DualQuat *dq)
                        copy_m3_m4(scalemat, dq->scale);
                        mul_m3_m3m3(mat, M, scalemat);
                }
-               else
+               else {
                        copy_m3_m3(mat, M);
+               }
                mul_m3_fl(mat, len2);
        }
 }
index efaa98f..2669ac8 100644 (file)
@@ -81,15 +81,17 @@ void BLI_svd_m3(const float m3[3][3], float r_U[3][3], float r_S[3], float r_V[3
  */
 bool BLI_tridiagonal_solve(const float *a, const float *b, const float *c, const float *d, float *r_x, const int count)
 {
-       if (count < 1)
+       if (count < 1) {
                return false;
+       }
 
        size_t bytes = sizeof(double) * (unsigned)count;
        double *c1 = (double *)MEM_mallocN(bytes * 2, "tridiagonal_c1d1");
        double *d1 = c1 + count;
 
-       if (!c1)
+       if (!c1) {
                return false;
+       }
 
        int i;
        double c_prev, d_prev, x_prev;
@@ -129,8 +131,9 @@ bool BLI_tridiagonal_solve(const float *a, const float *b, const float *c, const
  */
 bool BLI_tridiagonal_solve_cyclic(const float *a, const float *b, const float *c, const float *d, float *r_x, const int count)
 {
-       if (count < 1)
+       if (count < 1) {
                return false;
+       }
 
        float a0 = a[0], cN = c[count - 1];
 
@@ -143,8 +146,9 @@ bool BLI_tridiagonal_solve_cyclic(const float *a, const float *b, const float *c
        float *tmp = (float *)MEM_mallocN(bytes * 2, "tridiagonal_ex");
        float *b2 = tmp + count;
 
-       if (!tmp)
+       if (!tmp) {
                return false;
+       }
 
        /* prepare the noncyclic system; relies on tridiagonal_solve ignoring values */
        memcpy(b2, b, bytes);
index e96638a..50fa755 100644 (file)
@@ -67,8 +67,9 @@ static void covariance_m_vn_ex_task_cb(
         */
        const int i = a / n;
        const int j = a % n;
-       if (j < i)
+       if (j < i) {
                return;
+       }
 
        if (center) {
                for (k = 0; k < nbr_cos_vn; k++) {
index bf4cd70..0aacfd6 100644 (file)
@@ -925,22 +925,22 @@ void print_vn(const char *str, const float v[], const int n)
 
 void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
 {
-       if (min[0] > vec[0]) min[0] = vec[0];
-       if (min[1] > vec[1]) min[1] = vec[1];
-       if (min[2] > vec[2]) min[2] = vec[2];
+       if (min[0] > vec[0]) { min[0] = vec[0]; }
+       if (min[1] > vec[1]) { min[1] = vec[1]; }
+       if (min[2] > vec[2]) { min[2] = vec[2]; }
 
-       if (max[0] < vec[0]) max[0] = vec[0];
-       if (max[1] < vec[1]) max[1] = vec[1];
-       if (max[2] < vec[2]) max[2] = vec[2];
+       if (max[0] < vec[0]) { max[0] = vec[0]; }
+       if (max[1] < vec[1]) { max[1] = vec[1]; }
+       if (max[2] < vec[2]) { max[2] = vec[2]; }
 }
 
 void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
 {
-       if (min[0] > vec[0]) min[0] = vec[0];
-       if (min[1] > vec[1]) min[1] = vec[1];
+       if (min[0] > vec[0]) { min[0] = vec[0]; }
+       if (min[1] > vec[1]) { min[1] = vec[1]; }
 
-       if (max[0] < vec[0]) max[0] = vec[0];
-       if (max[1] < vec[1]) max[1] = vec[1];
+       if (max[0] < vec[0]) { max[0] = vec[0]; }
+       if (max[1] < vec[1]) { max[1] = vec[1]; }
 }
 
 void minmax_v3v3_v3_array(float r_min[3], float r_max[3], const float (*vec_arr)[3], int nbr)
index e999a50..241c5ec 100644 (file)
@@ -388,8 +388,8 @@ static float orgBlenderNoise(float x, float y, float z)
        h = hashvectf + 3 * hash[b21 + b11];
        n += i * (h[0] * jx + h[1] * jy + h[2] * jz);
 
-       if      (n < 0.0f) n = 0.0f;
-       else if (n > 1.0f) n = 1.0f;
+       if      (n < 0.0f) { n = 0.0f; }
+       else if (n > 1.0f) { n = 1.0f; }
        return n;
 }
 
@@ -402,7 +402,9 @@ static float orgBlenderNoiseS(float x, float y, float z)
 /* separated from orgBlenderNoise above, with scaling */
 float BLI_hnoise(float noisesize, float x, float y, float z)
 {
-       if (noisesize == 0.0f) return 0.0f;
+       if (noisesize == 0.0f) {
+               return 0.0f;
+       }
        x = (1.0f + x) / noisesize;
        y = (1.0f + y) / noisesize;
        z = (1.0f + z) / noisesize;
@@ -1294,7 +1296,9 @@ static float voronoi_F1F2(float x, float y, float z)
 static float voronoi_Cr(float x, float y, float z)
 {
        float t = 10 * voronoi_F1F2(x, y, z);
-       if (t > 1.f) return 1.f;
+       if (t > 1.f) {
+               return 1.f;
+       }
        return t;
 }
 
@@ -1341,7 +1345,9 @@ static float voronoi_F1F2S(float x, float y, float z)
 static float voronoi_CrS(float x, float y, float z)
 {
        float t = 10 * voronoi_F1F2(x, y, z);
-       if (t > 1.f) return 1.f;
+       if (t > 1.f) {
+               return 1.f;
+       }
        return (2.0f * t - 1.0f);
 }
 
@@ -1450,7 +1456,9 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
                z *= noisesize;
        }
 
-       if (hard) return fabsf(2.0f * noisefunc(x, y, z) - 1.0f);
+       if (hard) {
+               return fabsf(2.0f * noisefunc(x, y, z) - 1.0f);
+       }
        return noisefunc(x, y, z);
 }
 
@@ -1508,7 +1516,9 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
        sum = 0;
        for (i = 0; i <= oct; i++, amp *= 0.5f, fscale *= 2.0f) {
                t = noisefunc(fscale * x, fscale * y, fscale * z);
-               if (hard) t = fabsf(2.0f * t - 1.0f);
+               if (hard) {
+                       t = fabsf(2.0f * t - 1.0f);
+               }
                sum += t * amp;
        }
 
@@ -1583,7 +1593,9 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
        }
 
        rmd = octaves - floorf(octaves);
-       if (rmd != 0.f) value += rmd * noisefunc(x, y, z) * pwr;
+       if (rmd != 0.0f) {
+               value += rmd * noisefunc(x, y, z) * pwr;
+       }
 
        return value;
 
@@ -1654,7 +1666,9 @@ float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, floa
                z *= lacunarity;
        }
        rmd = octaves - floorf(octaves);
-       if (rmd != 0.0f) value *= (rmd * noisefunc(x, y, z) * pwr + 1.0f);
+       if (rmd != 0.0f) {
+               value *= (rmd * noisefunc(x, y, z) * pwr + 1.0f);
+       }
 
        return value;
 
@@ -1796,7 +1810,9 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
        z *= lacunarity;
 
        for (i = 1; (weight > 0.001f) && (i < (int)octaves); i++) {
-               if (weight > 1.0f) weight = 1.0f;
+               if (weight > 1.0f) {
+                       weight = 1.0f;
+               }
                signal = (noisefunc(x, y, z) + offset) * pwr;
                pwr *= pwHL;
                result += weight * signal;
@@ -1807,7 +1823,9 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
        }
 
        rmd = octaves - floorf(octaves);
-       if (rmd != 0.f) result += rmd * ((noisefunc(x, y, z) + offset) * pwr);
+       if (rmd != 0.f) {
+               result += rmd * ((noisefunc(x, y, z) + offset) * pwr);
+       }
 
        return result;
 
@@ -1876,8 +1894,8 @@ float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity
                y *= lacunarity;
                z *= lacunarity;
                weight = signal * gain;
-               if      (weight > 1.0f) weight = 1.0f;
-               else if (weight < 0.0f) weight = 0.0f;
+               if      (weight > 1.0f) { weight = 1.0f; }
+               else if (weight < 0.0f) { weight = 0.0f; }
                signal = offset - fabsf(noisefunc(x, y, z));
                signal *= signal;
                signal *= weight;
index 5f66a1b..6a8be3f 100644 (file)
@@ -104,7 +104,9 @@ int BLI_stringdec(const char *string, char *head, char *tail, ushort *r_num_len)
                        }
                }
                else {
-                       if (found_digit) break;
+                       if (found_digit) {
+                               break;
+                       }
                }
        }
 
@@ -192,7 +194,9 @@ void BLI_cleanup_path(const char *relabase, char *path)
                eind = start + strlen("\\..\\") - 1;
                a = start - path - 1;
                while (a > 0) {
-                       if (path[a] == '\\') break;
+                       if (path[a] == '\\') {
+                               break;
+                       }
                        a--;
                }
                if (a < 0) {
@@ -308,7 +312,9 @@ bool BLI_filename_make_safe(char *fname)
        }
 
        /* Forbid only dots. */
-       for (fn = fname; *fn == '.'; fn++);
+       for (fn = fname; *fn == '.'; fn++) {
+               /* pass */
+       }
        if (*fn == '\0') {
                *fname = '_';
                changed = true;
@@ -442,7 +448,9 @@ static bool BLI_path_is_abs(const char *name)
 static wchar_t *next_slash(wchar_t *path)
 {
        wchar_t *slash = path;
-       while (*slash && *slash != L'\\') slash++;
+       while (*slash && *slash != L'\\') {
+               slash++;
+       }
        return slash;
 }
 
@@ -555,11 +563,13 @@ void BLI_path_rel(char *file, const char *relfile)
                        int off;
                        int slash = 0;
                        for (off = 0; temp[off] && slash < 4; off++) {
-                               if (temp[off] != file[off])
+                               if (temp[off] != file[off]) {
                                        return;
+                               }
 
-                               if (temp[off] == '\\')
+                               if (temp[off] == '\\') {
                                        slash++;
+                               }
                        }
                }
                else if (temp[1] == ':' && file[1] == ':' && temp[0] != file[0]) {
@@ -620,7 +630,9 @@ void BLI_path_rel(char *file, const char *relfile)
                 * We count the number of directories we need to go up in the
                 * hierarchy to arrive at the common 'prefix' of the path
                 */
-               if (p < temp) p = temp;
+               if (p < temp) {
+                       p = temp;
+               }
                while (p && p < lslash) {
                        if (*p == '/') {
                                r += BLI_strcpy_rlen(r, "../");
@@ -662,8 +674,9 @@ bool BLI_path_suffix(char *string, size_t maxlen, const char *suffix, const char
        char extension[FILE_MAX];
        bool has_extension = false;
 
-       if (string_len + sep_len + suffix_len >= maxlen)
+       if (string_len + sep_len + suffix_len >= maxlen) {
                return false;
+       }
 
        for (a = string_len - 1; a >= 0; a--) {
                if (string[a] == '.') {
@@ -675,8 +688,9 @@ bool BLI_path_suffix(char *string, size_t maxlen, const char *suffix, const char
                }
        }
 
-       if (!has_extension)
+       if (!has_extension) {
                a = string_len;
+       }
 
        BLI_strncpy(extension, string + a, sizeof(extension));
        sprintf(string + a, "%s%s%s", sep, suffix, extension);
@@ -750,8 +764,9 @@ static void ensure_digits(char *path, int digits)
 {
        char *file = (char *)BLI_last_slash(path);
 
-       if (file == NULL)
+       if (file == NULL) {
                file = path;
+       }
 
        if (strrchr(file, '#') == NULL) {
                int len = strlen(file);
@@ -771,8 +786,9 @@ bool BLI_path_frame(char *path, int frame, int digits)
 {
        int ch_sta, ch_end;
 
-       if (digits)
+       if (digits) {
                ensure_digits(path, digits);
+       }
 
        if (stringframe_chars(path, &ch_sta, &ch_end)) { /* warning, ch_end is the last # +1 */
                char tmp[FILE_MAX];
@@ -794,8 +810,9 @@ bool BLI_path_frame_range(char *path, int sta, int end, int digits)
 {
        int ch_sta, ch_end;
 
-       if (digits)
+       if (digits) {
                ensure_digits(path, digits);
+       }
 
        if (stringframe_chars(path, &ch_sta, &ch_end)) { /* warning, ch_end is the last # +1 */
                char tmp[FILE_MAX];
@@ -820,8 +837,9 @@ bool BLI_path_frame_get(char *path, int *r_frame, int *r_numdigits)
 
                numdigits = *r_numdigits = 0;
 
-               if (file == NULL)
+               if (file == NULL) {
                        file = path;
+               }
 
                /* first get the extension part */
                len = strlen(file);
@@ -873,8 +891,9 @@ void BLI_path_frame_strip(char *path, char *r_ext)
        int len;
        int numdigits = 0;
 
-       if (file == NULL)
+       if (file == NULL) {
                file = path;
+       }
 
        /* first get the extension part */
        len = strlen(file);
@@ -1092,11 +1111,13 @@ bool BLI_path_cwd(char *path, const size_t maxlen)
        const int filelen = strlen(path);
 
 #ifdef WIN32
-       if ((filelen >= 3 && BLI_path_is_abs(path)) || BLI_path_is_unc(path))
+       if ((filelen >= 3 && BLI_path_is_abs(path)) || BLI_path_is_unc(path)) {
                wasrelative = false;
+       }
 #else
-       if (filelen >= 2 && path[0] == '/')
+       if (filelen >= 2 && path[0] == '/') {
                wasrelative = false;
+       }
 #endif
 
        if (wasrelative) {
@@ -1239,10 +1260,12 @@ void BLI_setenv(const char *env, const char *val)
 
 #else
        /* linux/osx/bsd */
-       if (val)
+       if (val) {
                setenv(env, val, 1);
-       else
+       }
+       else {
                unsetenv(env);
+       }
 #endif
 }
 
@@ -1255,8 +1278,9 @@ void BLI_setenv(const char *env, const char *val)
  */
 void BLI_setenv_if_new(const char *env, const char *val)
 {
-       if (BLI_getenv(env) == NULL)
+       if (BLI_getenv(env) == NULL) {
                BLI_setenv(env, val);
+       }
 }
 
 /**
@@ -1266,10 +1290,12 @@ const char *BLI_getenv(const char *env)
 {
 #ifdef _MSC_VER
        static char buffer[32767]; /* 32767 is the total size of the environment block on windows*/
-       if (GetEnvironmentVariableA(env, buffer, sizeof(buffer)))
+       if (GetEnvironmentVariableA(env, buffer, sizeof(buffer))) {
                return buffer;
-       else
+       }
+       else {
                return NULL;
+       }
 #else
        return getenv(env);
 #endif
@@ -1285,7 +1311,9 @@ void BLI_make_exist(char *dir)
        bool valid_path = true;
 
        /* Loop as long as cur path is not a dir, and we can get a parent path. */
-       while ((BLI_access(dir, R_OK) != 0) && (valid_path = BLI_parent_dir(dir)));
+       while ((BLI_access(dir, R_OK) != 0) && (valid_path = BLI_parent_dir(dir))) {
+               /* pass */
+       }
 
        /* If we could not find an existing dir, use default root... */
        if (!valid_path || !dir[0]) {
@@ -1344,7 +1372,9 @@ void BLI_make_file_string(const char *relabase, char *string, const char *dir, c
                strcpy(string, relabase);
 
                lslash = (char *)BLI_last_slash(string);
-               if (lslash) *(lslash + 1) = 0;
+               if (lslash) {
+                       *(lslash + 1) = 0;
+               }
 
                dir += 2; /* Skip over the relative reference */
        }
@@ -1369,7 +1399,9 @@ void BLI_make_file_string(const char *relabase, char *string, const char *dir, c
                        }
 
                        /* ignore leading slashes */
-                       while (*dir == '/' || *dir == '\\') dir++;
+                       while (*dir == '/' || *dir == '\\') {
+                               dir++;
+                       }
                }
        }
 #endif
@@ -1386,8 +1418,10 @@ void BLI_make_file_string(const char *relabase, char *string, const char *dir, c
        /* since we've now removed all slashes, put back one slash at the end. */
        strcat(string, "/");
 
-       while (*file && (*file == '/' || *file == '\\')) /* Trim slashes from the front of file */
+       while (*file && (*file == '/' || *file == '\\')) {
+               /* Trim slashes from the front of file */
                file++;
+       }
 
        strcat(string, file);
 
@@ -1537,8 +1571,9 @@ bool BLI_path_extension_replace(char *path, size_t maxlen, const char *ext)
                a = path_len;
        }
 
-       if (a + ext_len >= maxlen)
+       if (a + ext_len >= maxlen) {
                return false;
+       }
 
        memcpy(path + a, ext, ext_len + 1);
        return true;
@@ -1571,8 +1606,9 @@ bool BLI_path_extension_ensure(char *path, size_t maxlen, const char *ext)
        }
        a++;
 
-       if (a + ext_len >= maxlen)
+       if (a + ext_len >= maxlen) {
                return false;
+       }
 
        memcpy(path + a, ext, ext_len + 1);
        return true;
@@ -1869,8 +1905,12 @@ const char *BLI_first_slash(const char *string)
        const char * const ffslash = strchr(string, '/');
        const char * const fbslash = strchr(string, '\\');
 
-       if (!ffslash) return fbslash;
-       else if (!fbslash) return ffslash;
+       if (!ffslash) {
+               return fbslash;
+       }
+       else if (!fbslash) {
+               return ffslash;
+       }
 
        return (ffslash < fbslash) ? ffslash : fbslash;
 }
@@ -1883,8 +1923,12 @@ const char *BLI_last_slash(const char *string)
        const char * const lfslash = strrchr(string, '/');
        const char * const lbslash = strrchr(string, '\\');
 
-       if (!lfslash) return lbslash;
-       else if (!lbslash) return lfslash;
+       if (!lfslash) {
+               return lbslash;
+       }
+       else if (!lbslash) {
+               return lfslash;
+       }
 
        return (lfslash > lbslash) ? lfslash : lbslash;
 }
index 5867cde..4044eba 100644 (file)
@@ -177,12 +177,15 @@ static void       pf_ear_tip_cut(PolyFill *pf, PolyIndex *pi_ear_tip);
 
 BLI_INLINE eSign signum_enum(float a)
 {
-       if (UNLIKELY(a == 0.0f))
+       if (UNLIKELY(a == 0.0f)) {
                return  0;
-       else if (a > 0.0f)
+       }
+       else if (a > 0.0f) {
                return  1;
-       else
+       }
+       else {
                return -1;
+       }
 }
 
 /**
@@ -273,8 +276,8 @@ static uint kdtree2d_balance_recursive(
                j = pos;
 
                while (1) {
-                       while (coords[nodes[++i].index][axis] < co) ;
-                       while (coords[nodes[--j].index][axis] > co && j > neg) ;
+                       while (coords[nodes[++i].index][axis] < co) { /* pass */ }
+                       while (coords[nodes[--j].index][axis] > co && j > neg) { /* pass */ }
 
                        if (i >= j) {
                                break;
index 1c76361..352bfe5 100644 (file)
@@ -297,8 +297,9 @@ static RNG rng_tab[BLENDER_MAX_THREADS];
 
 void BLI_thread_srandom(int thread, unsigned int seed)
 {
-       if (thread >= BLENDER_MAX_THREADS)
+       if (thread >= BLENDER_MAX_THREADS) {
                thread = 0;
+       }
 
        BLI_rng_seed(&rng_tab[thread], seed + hash[seed & 255]);
        seed = BLI_rng_get_uint(&rng_tab[thread]);
index 9b26ad2..9437380 100644 (file)
@@ -57,65 +57,65 @@ bool BLI_rctf_is_empty(const rctf *rect)
 
 bool BLI_rcti_isect_x(const rcti *rect, const int x)
 {
-       if (x < rect->xmin) return false;
-       if (x > rect->xmax) return false;
+       if (x < rect->xmin) { return false; }
+       if (x > rect->xmax) { return false; }
        return true;
 }
 
 bool BLI_rcti_isect_y(const rcti *rect, const int y)
 {
-       if (y < rect->ymin) return false;
-       if (y > rect->ymax) return false;
+       if (y < rect->ymin) { return false; }
+       if (y > rect->ymax) { return false; }
        return true;
 }
 
 bool BLI_rcti_isect_pt(const rcti *rect, const int x, const int y)
 {
-       if (x < rect->xmin) return false;
-       if (x > rect->xmax) return false;
-       if (y < rect->ymin) return false;
-       if (y > rect->ymax) return false;
+       if (x < rect->xmin) { return false; }
+       if (x > rect->xmax) { return false; }
+       if (y < rect->ymin) { return false; }
+       if (y > rect->ymax) { return false; }
        return true;
 }
 
 bool BLI_rcti_isect_pt_v(const rcti *rect, const int xy[2])
 {
-       if (xy[0] < rect->xmin) return false;
-       if (xy[0] > rect->xmax) return false;
-       if (xy[1] < rect->ymin) return false;
-       if (xy[1] > rect->ymax) return false;
+       if (xy[0] < rect->xmin) { return false; }
+       if (xy[0] > rect->xmax) { return false; }
+       if (xy[1] < rect->ymin) { return false; }
+       if (xy[1] > rect->ymax) { return false; }
        return true;
 }
 
 bool BLI_rctf_isect_x(const rctf *rect, const float x)
 {
-       if (x < rect->xmin) return false;
-       if (x > rect->xmax) return false;
+       if (x < rect->xmin) { return false; }
+       if (x > rect->xmax) { return false; }
        return true;
 }
 
 bool BLI_rctf_isect_y(const rctf *rect, const float y)
 {
-       if (y < rect->ymin) return false;
-       if (y > rect->ymax) return false;
+       if (y < rect->ymin) { return false; }
+       if (y > rect->ymax) { return false; }
        return true;
 }
 
 bool BLI_rctf_isect_pt(const rctf *rect, const float x, const float y)
 {
-       if (x < rect->xmin) return false;
-       if (x > rect->xmax) return false;
-       if (y < rect->ymin) return false;
-       if (y > rect->ymax) return false;
+       if (x < rect->xmin) { return false; }
+       if (x > rect->xmax) { return false; }
+       if (y < rect->ymin) { return false; }
+       if (y > rect->ymax) { return false; }
        return true;
 }
 
 bool BLI_rctf_isect_pt_v(const rctf *rect, const float xy[2])
 {
-       if (xy[0] < rect->xmin) return false;
-       if (xy[0] > rect->xmax) return false;
-       if (xy[1] < rect->ymin) return false;
-       if (xy[1] > rect->ymax) return false;
+       if (xy[0] < rect->xmin) { return false; }
+       if (xy[0] > rect->xmax) { return false; }
+       if (xy[1] < rect->ymin) { return false; }
+       if (xy[1] > rect->ymax) { return false; }
        return true;
 }
 
@@ -125,29 +125,29 @@ bool BLI_rctf_isect_pt_v(const rctf *rect, const float xy[2])
 
 int BLI_rcti_length_x(const rcti *rect, const int x)
 {
-       if (x < rect->xmin) return rect->xmin - x;
-       if (x > rect->xmax) return x - rect->xmax;
+       if (x < rect->xmin) { return rect->xmin - x; }
+       if (x > rect->xmax) { return x - rect->xmax; }
        return 0;
 }
 
 int BLI_rcti_length_y(const rcti *rect, const int y)
 {
-       if (y < rect->ymin) return rect->ymin - y;
-       if (y > rect->ymax) return y - rect->ymax;
+       if (y < rect->ymin) { return rect->ymin - y; }
+       if (y > rect->ymax) { return y - rect->ymax; }
        return 0;
 }
 
 float BLI_rctf_length_x(const rctf *rect, const float x)
 {
-       if (x < rect->xmin) return rect->xmin - x;
-       if (x > rect->xmax) return x - rect->xmax;
+       if (x < rect->xmin) { return rect->xmin - x; }
+       if (x > rect->xmax) { return x - rect->xmax; }
        return 0.0f;
 }
 
 float BLI_rctf_length_y(const rctf *rect, const float y)
 {
-       if (y < rect->ymin) return rect->ymin - y;
-       if (y > rect->ymax) return y - rect->ymax;
+       if (y < rect->ymin) { return rect->ymin - y; }
+       if (y > rect->ymax) { return y - rect->ymax; }
        return 0.0f;
 }
 
@@ -200,10 +200,10 @@ static int isect_segments_fl(const float v1[2], const float v2[2], const float v
 bool BLI_rcti_isect_segment(const rcti *rect, const int s1[2], const int s2[2])
 {
        /* first do outside-bounds check for both points of the segment */
-       if (s1[0] < rect->xmin && s2[0] < rect->xmin) return false;
-       if (s1[0] > rect->xmax && s2[0] > rect->xmax) return false;
-       if (s1[1] < rect->ymin && s2[1] < rect->ymin) return false;
-       if (s1[1] > rect->ymax && s2[1] > rect->ymax) return false;
+       if (s1[0] < rect->xmin && s2[0] < rect->xmin) { return false; }
+       if (s1[0] > rect->xmax && s2[0] > rect->xmax) { return false; }
+       if (s1[1] < rect->ymin && s2[1] < rect->ymin) { return false; }
+       if (s1[1] > rect->ymax && s2[1] > rect->ymax) { return false; }
 
        /* if either points intersect then we definetly intersect */
        if (BLI_rcti_isect_pt_v(rect, s1) || BLI_rcti_isect_pt_v(rect, s2)) {
@@ -235,10 +235,10 @@ bool BLI_rcti_isect_segment(const rcti *rect, const int s1[2], const int s2[2])
 bool BLI_rctf_isect_segment(const rctf *rect, const float s1[2], const float s2[2])
 {
        /* first do outside-bounds check for both points of the segment */
-       if (s1[0] < rect->xmin && s2[0] < rect->xmin) return false;
-       if (s1[0] > rect->xmax && s2[0] > rect->xmax) return false;
-       if (s1[1] < rect->ymin && s2[1] < rect->ymin) return false;
-       if (s1[1] > rect->ymax && s2[1] > rect->ymax) return false;
+       if (s1[0] < rect->xmin && s2[0] < rect->xmin) { return false; }
+       if (s1[0] > rect->xmax && s2[0] > rect->xmax) { return false; }
+       if (s1[1] < rect->ymin && s2[1] < rect->ymin) { return false; }
+       if (s1[1] > rect->ymax && s2[1] > rect->ymax) { return false; }
 
        /* if either points intersect then we definetly intersect */
        if (BLI_rctf_isect_pt_v(rect, s1) || BLI_rctf_isect_pt_v(rect, s2)) {
@@ -271,11 +271,19 @@ bool BLI_rcti_isect_circle(const rcti *rect, const float xy[2], const float radi
 {
        float dx, dy;
 
-       if (xy[0] >= rect->xmin && xy[0] <= rect->xmax) dx = 0;
-       else dx = (xy[0] < rect->xmin) ? (rect->xmin - xy[0]) : (xy[0] - rect->xmax);
+       if (xy[0] >= rect->xmin && xy[0] <= rect->xmax) {
+               dx = 0;
+       }
+       else {
+               dx = (xy[0] < rect->xmin) ? (rect->xmin - xy[0]) : (xy[0] - rect->xmax);
+       }
 
-       if (xy[1] >= rect->ymin && xy[1] <= rect->ymax) dy = 0;
-       else dy = (xy[1] < rect->ymin) ? (rect->ymin - xy[1]) : (xy[1] - rect->ymax);
+       if (xy[1] >= rect->ymin && xy[1] <= rect->ymax) {
+               dy = 0;
+       }
+       else {
+               dy = (xy[1] < rect->ymin) ? (rect->ymin - xy[1]) : (xy[1] - rect->ymax);
+       }
 
        return dx * dx + dy * dy <= radius * radius;
 }
@@ -284,29 +292,37 @@ bool BLI_rctf_isect_circle(const rctf *rect, const float xy[2], const float radi
 {
        float dx, dy;
 
-       if (xy[0] >= rect->xmin && xy[0] <= rect->xmax) dx = 0;
-       else dx = (xy[0] < rect->xmin) ? (rect->xmin - xy[0]) : (xy[0] - rect->xmax);
+       if (xy[0] >= rect->xmin && xy[0] <= rect->xmax) {
+               dx = 0;
+       }
+       else {
+               dx = (xy[0] < rect->xmin) ? (rect->xmin - xy[0]) : (xy[0] - rect->xmax);
+       }
 
-       if (xy[1] >= rect->ymin && xy[1] <= rect->ymax) dy = 0;
-       else dy = (xy[1] < rect->ymin) ? (rect->ymin - xy[1]) : (xy[1] - rect->ymax);
+       if (xy[1] >= rect->ymin && xy[1] <= rect->ymax) {
+               dy = 0;
+       }
+       else {
+               dy = (xy[1] < rect->ymin) ? (rect->ymin - xy[1]) : (xy[1] - rect->ymax);
+       }
 
        return dx * dx + dy * dy <= radius * radius;
 }
 
 void BLI_rctf_union(rctf *rct1, const rctf *rct2)
 {
-       if (rct1->xmin > rct2->xmin) rct1->xmin = rct2->xmin;
-       if (rct1->xmax < rct2->xmax) rct1->xmax = rct2->xmax;
-       if (rct1->ymin > rct2->ymin) rct1->ymin = rct2->ymin;
-       if (rct1->ymax < rct2->ymax) rct1->ymax = rct2->ymax;
+       if (rct1->xmin > rct2->xmin) { rct1->xmin = rct2->xmin; }
+       if (rct1->xmax < rct2->xmax) { rct1->xmax = rct2->xmax; }
+       if (rct1->ymin > rct2->ymin) { rct1->ymin = rct2->ymin; }
+       if (rct1->ymax < rct2->ymax) { rct1->ymax = rct2->ymax; }
 }
 
 void BLI_rcti_union(rcti *rct1, const rcti *rct2)
 {
-       if (rct1->xmin > rct2->xmin) rct1->xmin = rct2->xmin;
-       if (rct1->xmax < rct2->xmax) rct1->xmax = rct2->xmax;
-       if (rct1->ymin > rct2->ymin) rct1->ymin = rct2->ymin;
-       if (rct1->ymax < rct2->ymax) rct1->ymax = rct2->ymax;
+       if (rct1->xmin > rct2->xmin) { rct1->xmin = rct2->xmin; }
+       if (rct1->xmax < rct2->xmax) { rct1->xmax = rct2->xmax; }
+       if (rct1->ymin > rct2->ymin) { rct1->ymin = rct2->ymin; }
+       if (rct1->ymax < rct2->ymax) { rct1->ymax = rct2->ymax; }
 }
 
 void BLI_rctf_init(rctf *rect, float xmin, float xmax, float ymin, float ymax)
@@ -379,18 +395,18 @@ void BLI_rctf_init_minmax(rctf *rect)
 
 void BLI_rcti_do_minmax_v(rcti *rect, const int xy[2])
 {
-       if (xy[0] < rect->xmin) rect->xmin = xy[0];
-       if (xy[0] > rect->xmax) rect->xmax = xy[0];
-       if (xy[1] < rect->ymin) rect->ymin = xy[1];
-       if (xy[1] > rect->ymax) rect->ymax = xy[1];
+       if (xy[0] < rect->xmin) { rect->xmin = xy[0]; }
+       if (xy[0] > rect->xmax) { rect->xmax = xy[0]; }
+       if (xy[1] < rect->ymin) { rect->ymin = xy[1]; }
+       if (xy[1] > rect->ymax) { rect->ymax = xy[1]; }
 }
 
 void BLI_rctf_do_minmax_v(rctf *rect, const float xy[2])
 {
-       if (xy[0] < rect->xmin) rect->xmin = xy[0];
-       if (xy[0] > rect->xmax) rect->xmax = xy[0];
-       if (xy[1] < rect->ymin) rect->ymin = xy[1];
-       if (xy[1] > rect->ymax) rect->ymax = xy[1];
+       if (xy[0] < rect->xmin) { rect->xmin = xy[0]; }
+       if (xy[0] > rect->xmax) { rect->xmax = xy[0]; }
+       if (xy[1] < rect->ymin) { rect->ymin = xy[1]; }
+       if (xy[1] > rect->ymax) { rect->ymax = xy[1]; }
 }
 
 /* given 2 rectangles - transform a point from one to another */
@@ -620,22 +636,30 @@ bool BLI_rcti_clamp(rcti *rect, const rcti *rect_bounds, int r_xy[2])
 
 bool BLI_rctf_compare(const rctf *rect_a, const rctf *rect_b, const float limit)
 {
-       if (fabsf(rect_a->xmin - rect_b->xmin) < limit)
-               if (fabsf(rect_a->xmax - rect_b->xmax) < limit)
-                       if (fabsf(rect_a->ymin - rect_b->ymin) < limit)
-                               if (fabsf(rect_a->ymax - rect_b->ymax) < limit)
+       if (fabsf(rect_a->xmin - rect_b->xmin) < limit) {
+               if (fabsf(rect_a->xmax - rect_b->xmax) < limit) {
+                       if (fabsf(rect_a->ymin - rect_b->ymin) < limit) {
+                               if (fabsf(rect_a->ymax - rect_b->ymax) < limit) {
                                        return true;
+                               }
+                       }
+               }
+       }
 
        return false;
 }
 
 bool BLI_rcti_compare(const rcti *rect_a, const rcti *rect_b)
 {
-       if (rect_a->xmin == rect_b->xmin)
-               if (rect_a->xmax == rect_b->xmax)
-                       if (rect_a->ymin == rect_b->ymin)
-                               if (rect_a->ymax == rect_b->ymax)
+       if (rect_a->xmin == rect_b->xmin) {
+               if (rect_a->xmax == rect_b->xmax) {
+                       if (rect_a->ymin == rect_b->ymin) {
+                               if (rect_a->ymax == rect_b->ymax) {
                                        return true;
+                               }
+                       }
+               }
+       }
 
        return false;
 }
index 12e1425..80b4acc 100644 (file)
@@ -93,10 +93,10 @@ static int vergscdata(const void *a1, const void *a2)
 {
        const ScanFillVertLink *x1 = a1, *x2 = a2;
 
-       if      (x1->vert->xy[1] < x2->vert->xy[1]) return  1;
-       else if (x1->vert->xy[1] > x2->vert->xy[1]) return -1;
-       else if (x1->vert->xy[0] > x2->vert->xy[0]) return  1;
-       else if (x1->vert->xy[0] < x2->vert->xy[0]) return -1;
+       if      (x1->vert->xy[1] < x2->vert->xy[1]) { return  1; }
+       else if (x1->vert->xy[1] > x2->vert->xy[1]) { return -1; }
+       else if (x1->vert->xy[0] > x2->vert->xy[0]) { return  1; }
+       else if (x1->vert->xy[0] < x2->vert->xy[0]) { return -1; }
 
        return 0;
 }
@@ -105,10 +105,10 @@ static int vergpoly(const void *a1, const void *a2)
 {
        const PolyFill *x1 = a1, *x2 = a2;
 
-       if      (x1->min_xy[0] > x2->min_xy[0]) return  1;
-       else if (x1->min_xy[0] < x2->min_xy[0]) return -1;
-       else if (x1->min_xy[1] > x2->min_xy[1]) return  1;
-       else if (x1->min_xy[1] < x2->min_xy[1]) return -1;
+       if      (x1->min_xy[0] > x2->min_xy[0]) { return  1; }
+       else if (x1->min_xy[0] < x2->min_xy[0]) { return -1; }
+       else if (x1->min_xy[1] > x2->min_xy[1]) { return  1; }
+       else if (x1->min_xy[1] < x2->min_xy[1]) { return -1; }
 
        return 0;
 }
@@ -174,20 +174,20 @@ static bool boundisect(PolyFill *pf2, PolyFill *pf1)
        /* has pf2 been touched (intersected) by pf1 ? with bounding box */
        /* test first if polys exist */
 
-       if (pf1->edges == 0 || pf2->edges == 0) return false;
+       if (pf1->edges == 0 || pf2->edges == 0) { return false; }
 
-       if (pf2->max_xy[0] < pf1->min_xy[0]) return false;
-       if (pf2->max_xy[1] < pf1->min_xy[1]) return false;
+       if (pf2->max_xy[0] < pf1->min_xy[0]) { return false; }
+       if (pf2->max_xy[1] < pf1->min_xy[1]) { return false; }
 
-       if (pf2->min_xy[0] > pf1->max_xy[0]) return false;
-       if (pf2->min_xy[1] > pf1->max_xy[1]) return false;
+       if (pf2->min_xy[0] > pf1->max_xy[0]) { return false; }
+       if (pf2->min_xy[1] > pf1->max_xy[1]) { return false; }
 
        /* join */
-       if (pf2->max_xy[0] < pf1->max_xy[0]) pf2->max_xy[0] = pf1->max_xy[0];
-       if (pf2->max_xy[1] < pf1->max_xy[1]) pf2->max_xy[1] = pf1->max_xy[1];
+       if (pf2->max_xy[0] < pf1->max_xy[0]) { pf2->max_xy[0] = pf1->max_xy[0]; }
+       if (pf2->max_xy[1] < pf1->max_xy[1]) { pf2->max_xy[1] = pf1->max_xy[1]; }
 
-       if (pf2->min_xy[0] > pf1->min_xy[0]) pf2->min_xy[0] = pf1->min_xy[0];
-       if (pf2->min_xy[1] > pf1->min_xy[1]) pf2->min_xy[1] = pf1->min_xy[1];
+       if (pf2->min_xy[0] > pf1->min_xy[0]) { pf2->min_xy[0] = pf1->min_xy[0]; }
+       if (pf2->min_xy[1] > pf1->min_xy[1]) { pf2->min_xy[1] = pf1->min_xy[1]; }
 
        return true;
 }
@@ -230,8 +230,12 @@ static bool testedgeside(const float v1[2], const float v2[2], const float v3[2]
                return false;
        }
        else if (inp == 0.0f) {
-               if (v1[0] == v3[0] && v1[1] == v3[1]) return false;
-               if (v2[0] == v3[0] && v2[1] == v3[1]) return false;
+               if (v1[0] == v3[0] && v1[1] == v3[1]) {
+                       return false;
+               }
+               if (v2[0] == v3[0] && v2[1] == v3[1]) {
+                       return false;
+               }
        }
        return true;
 }
@@ -278,8 +282,12 @@ static bool addedgetoscanvert(ScanFillVertLink *sc, ScanFillEdge *eed)
                        break;
                }
        }
-       if (ed) BLI_insertlinkbefore((ListBase *)&(sc->edge_first), ed, eed);
-       else BLI_addtail((ListBase *)&(sc->edge_first), eed);
+       if (ed) {
+               BLI_insertlinkbefore((ListBase *)&(sc->edge_first), ed, eed);
+       }
+       else {
+               BLI_addtail((ListBase *)&(sc->edge_first), eed);
+       }
 
        return true;
 }
@@ -519,13 +527,15 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
                         */
                        if (eed->v1->f == SF_VERT_ZERO_LEN) {
                                v1 = eed->v1;
-                               while ((eed->v1->f == SF_VERT_ZERO_LEN) && (eed->v1->tmp.v != v1) && (eed->v1 != eed->v1->tmp.v))
+                               while ((eed->v1->f == SF_VERT_ZERO_LEN) && (eed->v1->tmp.v != v1) && (eed->v1 != eed->v1->tmp.v)) {
                                        eed->v1 = eed->v1->tmp.v;
+                               }
                        }
                        if (eed->v2->f == SF_VERT_ZERO_LEN) {
                                v2 = eed->v2;
-                               while ((eed->v2->f == SF_VERT_ZERO_LEN) && (eed->v2->tmp.v != v2) && (eed->v2 != eed->v2->tmp.v))
+                               while ((eed->v2->f == SF_VERT_ZERO_LEN) && (eed->v2->tmp.v != v2) && (eed->v2 != eed->v2->tmp.v)) {
                                        eed->v2 = eed->v2->tmp.v;
+                               }
                        }
                        if (eed->v1 != eed->v2) {
                                addedgetoscanlist(scdata, eed, verts);
@@ -555,8 +565,9 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
 
        /* STEP 2: FILL LOOP */
 
-       if (pf->f == SF_POLY_NEW)
+       if (pf->f == SF_POLY_NEW) {
                twoconnected = true;
+       }
 
        /* (temporal) security: never much more faces than vertices */
        totface = 0;
@@ -577,8 +588,12 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
                        if (ed1->v1->edge_tot == 1 || ed1->v2->edge_tot == 1) {
                                BLI_remlink((ListBase *)&(sc->edge_first), ed1);
                                BLI_addtail(&sf_ctx->filledgebase, ed1);
-                               if (ed1->v1->edge_tot > 1) ed1->v1->edge_tot--;
-                               if (ed1->v2->edge_tot > 1) ed1->v2->edge_tot--;
+                               if (ed1->v1->edge_tot > 1) {
+                                       ed1->v1->edge_tot--;
+                               }
+                               if (ed1->v2->edge_tot > 1) {
+                                       ed1->v2->edge_tot--;
+                               }
                        }
                        else {
                                ed1->v2->f = SF_VERT_AVAILABLE;
@@ -616,7 +631,9 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
                                v3 = ed2->v2;
 
                                /* this happens with a serial of overlapping edges */
-                               if (v1 == v2 || v2 == v3) break;
+                               if (v1 == v2 || v2 == v3) {
+                                       break;
+                               }
 
                                /* printf("test verts %d %d %d\n", v1->tmp.u, v2->tmp.u, v3->tmp.u); */
                                miny = min_ff(v1->xy[1], v3->xy[1]);
@@ -624,7 +641,9 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
 
                                for (b = a + 1; b < verts; b++, sc1++) {
                                        if (sc1->vert->f == SF_VERT_NEW) {
-                                               if (sc1->vert->xy[1] <= miny) break;
+                                               if (sc1->vert->xy[1] <= miny) {
+                                                       break;
+                                               }
                                                if (testedgeside(v1->xy, v2->xy, sc1->vert->xy)) {
                                                        if (testedgeside(v2->xy, v3->xy, sc1->vert->xy)) {
                                                                if (testedgeside(v3->xy, v1->xy, sc1->vert->xy)) {
@@ -724,8 +743,12 @@ static unsigned int scanfill(ScanFillContext *sf_ctx, PolyFill *pf, const int fl
                                if (ed1->v1->edge_tot < 2 || ed1->v2->edge_tot < 2) {
                                        BLI_remlink((ListBase *)&(sc->edge_first), ed1);
                                        BLI_addtail(&sf_ctx->filledgebase, ed1);
-                                       if (ed1->v1->edge_tot > 1) ed1->v1->edge_tot--;
-                                       if (ed1->v2->edge_tot > 1) ed1->v2->edge_tot--;
+                                       if (ed1->v1->edge_tot > 1) {
+                                               ed1->v1->edge_tot--;
+                                       }
+                                       if (ed1->v2->edge_tot > 1) {
+                                               ed1->v2->edge_tot--;
+                                       }
                                }
                        }
                        /* done with loose edges */
@@ -934,8 +957,12 @@ unsigned int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const int flag, const
        if (flag & BLI_SCANFILL_CALC_LOOSE) {
                unsigned int toggle = 0;
                for (eed = sf_ctx->filledgebase.first; eed; eed = eed->next) {
-                       if (eed->v1->edge_tot++ > 250) break;
-                       if (eed->v2->edge_tot++ > 250) break;
+                       if (eed->v1->edge_tot++ > 250) {
+                               break;
+                       }
+                       if (eed->v2->edge_tot++ > 250) {
+                               break;
+                       }
                }
                if (eed) {
                        /* otherwise it's impossible to be sure you can clear vertices */
index b012ff3..7da5ff1 100644 (file)
@@ -405,8 +405,9 @@ double BLI_smallhash_calc_quality(SmallHash *sh)
        uint64_t sum = 0;
        uint i;
 
-       if (sh->nentries == 0)
+       if (sh->nentries == 0) {
                return -1.0;
+       }
 
        for (i = 0; i < sh->nbuckets; i++) {
                if (sh->buckets[i].key != SMHASH_KEY_UNUSED) {
index af20697..921eec5 100644 (file)
@@ -141,8 +141,9 @@ loop:
                        }
                        pc -= es;
                }
-               if (pb > pc)
+               if (pb > pc) {
                        break;
+               }
                swap(pb, pc);
                swap_cnt = 1;
                pb += es;
@@ -165,8 +166,9 @@ loop:
        vecswap((char *)a, pb - r, r);
        r = min(pd - pc, pn - pd - es);
        vecswap(pb, pn - r, r);
-       if ((r = pb - pa) > es)
+       if ((r = pb - pa) > es) {
                BLI_qsort_r(a, r / es, es, cmp, thunk);
+       }
        if ((r = pd - pc) > es) {
                /* Iterate rather than recurse to save stack space */
                a = pn - r;
index 7166b77..3220f75 100644 (file)
@@ -41,52 +41,52 @@ int BLI_sortutil_cmp_float(const void *a_, const void *b_)
 {
        const struct SortAnyByFloat *a = a_;
        const struct SortAnyByFloat *b = b_;
-       if      (a->sort_value > b->sort_value) return  1;
-       else if (a->sort_value < b->sort_value) return -1;
-       else                                    return  0;
+       if      (a->sort_value > b->sort_value) { return  1; }
+       else if (a->sort_value < b->sort_value) { return -1; }
+       else                                    { return  0; }
 }
 
 int BLI_sortutil_cmp_float_reverse(const void *a_, const void *b_)
 {
        const struct SortAnyByFloat *a = a_;
        const struct SortAnyByFloat *b = b_;
-       if      (a->sort_value < b->sort_value) return  1;
-       else if (a->sort_value > b->sort_value) return -1;
-       else                                    return  0;
+       if      (a->sort_value < b->sort_value) { return  1; }
+       else if (a->sort_value > b->sort_value) { return -1; }
+       else                                    { return  0; }
 }
 
 int BLI_sortutil_cmp_int(const void *a_, const void *b_)
 {
        const struct SortAnyByInt *a = a_;
        const struct SortAnyByInt *b = b_;
-       if      (a->sort_value > b->sort_value) return  1;
-       else if (a->sort_value < b->sort_value) return -1;
-       else                                    return  0;
+       if      (a->sort_value > b->sort_value) { return  1; }
+       else if (a->sort_value < b->sort_value) { return -1; }
+       else                                    { return  0; }
 }
 
 int BLI_sortutil_cmp_int_reverse(const void *a_, const void *b_)
 {
        const struct SortAnyByInt *a = a_;
        const struct SortAnyByInt *b = b_;
-       if      (a->sort_value < b->sort_value) return  1;
-       else if (a->sort_value > b->sort_value) return -1;
-       else                                    return  0;
+       if      (a->sort_value < b->sort_value) { return  1; }
+       else if (a->sort_value > b->sort_value) { return -1; }
+       else                                    { return  0; }
 }
 
 int BLI_sortutil_cmp_ptr(const void *a_, const void *b_)
 {
        const struct SortAnyByPtr *a = a_;
        const struct SortAnyByPtr *b = b_;
-       if      (a->sort_value > b->sort_value) return  1;
-       else if (a->sort_value < b->sort_value) return -1;
-       else                                    return  0;
+       if      (a->sort_value > b->sort_value) { return  1; }
+       else if (a->sort_value < b->sort_value) { return -1; }
+       else                                    { return  0; }
 }
 
 int BLI_sortutil_cmp_ptr_reverse(const void *a_, const void *b_)
 {
        const struct SortAnyByPtr *a = a_;
        const struct SortAnyByPtr *b = b_;
-       if      (a->sort_value < b->sort_value) return  1;
-       else if (a->sort_value > b->sort_value) return -1;
-       else                                    return  0;
+       if      (a->sort_value < b->sort_value) { return  1; }
+       else if (a->sort_value > b->sort_value) { return -1; }
+       else                                    { return  0; }
 }
index 4fb519e..7b460c7 100644 (file)
@@ -127,25 +127,35 @@ double BLI_dir_free_space(const char *dir)
        char name[FILE_MAXDIR], *slash;
        int len = strlen(dir);
 
-       if (len >= FILE_MAXDIR) /* path too long */
+       if (len >= FILE_MAXDIR) {
+               /* path too long */
                return -1;
+       }
 
        strcpy(name, dir);
 
        if (len) {
                slash = strrchr(name, '/');
-               if (slash) slash[1] = 0;
+               if (slash) {
+                       slash[1] = 0;
+               }
        }
        else {
                strcpy(name, "/");
        }
 
 #if  defined(USE_STATFS_STATVFS)
-       if (statvfs(name, &disk)) return -1;
+       if (statvfs(name, &disk)) {
+               return -1;
+       }
 #elif defined(USE_STATFS_4ARGS)
-       if (statfs(name, &disk, sizeof(struct statfs), 0)) return -1;
+       if (statfs(name, &disk, sizeof(struct statfs), 0)) {
+               return -1;
+       }
 #else
-       if (statfs(name, &disk)) return -1;
+       if (statfs(name, &disk)) {
+               return -1;
+       }
 #endif
 
        return ( ((double) disk.f_bsize) * ((double) disk.f_bfree));
@@ -159,8 +169,9 @@ double BLI_dir_free_space(const char *dir)
 size_t BLI_file_descriptor_size(int file)
 {
        struct stat st;
-       if ((file < 0) || (fstat(file, &st) == -1))
+       if ((file < 0) || (fstat(file, &st) == -1)) {
                return -1;
+       }
        return st.st_size;
 }
 
@@ -170,8 +181,9 @@ size_t BLI_file_descriptor_size(int file)
 size_t BLI_file_size(const char *path)
 {
        BLI_stat_t stats;
-       if (BLI_stat(path, &stats) == -1)
+       if (BLI_stat(path, &stats) == -1) {
                return -1;
+       }
        return stats.st_size;
 }
 
@@ -216,11 +228,15 @@ int BLI_exists(const char *name)
        SetErrorMode(old_error_mode);
 
        free(tmp_16);
-       if (res == -1) return(0);
+       if (res == -1) {
+               return(0);
+       }
 #else
        struct stat st;
        BLI_assert(!BLI_path_is_rel(name));
-       if (stat(name, &st)) return(0);
+       if (stat(name, &st)) {
+               return(0);
+       }
 #endif
        return(st.st_mode);
 }
@@ -356,7 +372,9 @@ LinkNode *BLI_file_read_as_lines(const char *name)
        char *buf;
        size_t size;
 
-       if (!fp) return NULL;
+       if (!fp) {
+               return NULL;
+       }
 
        fseek(fp, 0, SEEK_END);
        size = (size_t)ftell(fp);
@@ -410,16 +428,24 @@ bool BLI_file_older(const char *file1, const char *file2)
        UTF16_ENCODE(file1);
        UTF16_ENCODE(file2);
 
-       if (_wstat(file1_16, &st1)) return false;
-       if (_wstat(file2_16, &st2)) return false;
+       if (_wstat(file1_16, &st1)) {
+               return false;
+       }
+       if (_wstat(file2_16, &st2)) {
+               return false;
+       }
 
        UTF16_UN_ENCODE(file2);
        UTF16_UN_ENCODE(file1);
 #else
        struct stat st1, st2;
 
-       if (stat(file1, &st1)) return false;
-       if (stat(file2, &st2)) return false;
+       if (stat(file1, &st1)) {
+               return false;
+       }
+       if (stat(file2, &st2)) {
+               return false;
+       }
 #endif
        return (st1.st_mtime < st2.st_mtime);
 }
index a122804..dfb32e5 100644 (file)
@@ -423,8 +423,9 @@ char *BLI_str_replaceN(const char *__restrict str, const char *__restrict substr
         */
        while ((match = strstr(str, substr_old))) {
                /* the assembly buffer only gets created when we actually need to rebuild the string */
-               if (ds == NULL)
+               if (ds == NULL) {
                        ds = BLI_dynstr_new();
+               }
 
                /* if the match position does not match the current position in the string,
                 * copy the text up to this position and advance the current position in the string
@@ -508,8 +509,9 @@ char *BLI_strcasestr(const char *s, const char *find)
                len = strlen(find);
                do {
                        do {
-                               if ((sc = *s++) == 0)
+                               if ((sc = *s++) == 0) {
                                        return (NULL);
+                               }
                                sc = tolower(sc);
                        } while (sc != c);
                } while (BLI_strncasecmp(s, find, len) != 0);
@@ -530,8 +532,9 @@ char *BLI_strncasestr(const char *s, const char *find, size_t len)
                if (len > 1) {
                        do {
                                do {
-                                       if ((sc = *s++) == 0)
+                                       if ((sc = *s++) == 0) {
                                                return NULL;
+                                       }
                                        sc = tolower(sc);
                                } while (sc != c);
                        } while (BLI_strncasecmp(s, find, len - 1) != 0);
@@ -539,8 +542,9 @@ char *BLI_strncasestr(const char *s, const char *find, size_t len)
                else {
                        {
                                do {
-                                       if ((sc = *s++) == 0)
+                                       if ((sc = *s++) == 0) {
                                                return NULL;
+                                       }
                                        sc = tolower(sc);
                                } while (sc != c);
                        }
@@ -612,30 +616,37 @@ static int left_number_strcmp(const char *s1, const char *s2, int *tiebreaker)
 
        /* find number of consecutive digits */
        for (numdigit = 0; ; numdigit++) {
-               if (isdigit(*(p1 + numdigit)) && isdigit(*(p2 + numdigit)))
+               if (isdigit(*(p1 + numdigit)) && isdigit(*(p2 + numdigit))) {
                        continue;
-               else if (isdigit(*(p1 + numdigit)))
+               }
+               else if (isdigit(*(p1 + numdigit))) {
                        return 1; /* s2 is bigger */
-               else if (isdigit(*(p2 + numdigit)))
+               }
+               else if (isdigit(*(p2 + numdigit))) {
                        return -1; /* s1 is bigger */
-               else
+               }
+               else {
                        break;
+               }
        }
 
        /* same number of digits, compare size of number */
        if (numdigit > 0) {
                int compare = (int)strncmp(p1, p2, (size_t)numdigit);
 
-               if (compare != 0)
+               if (compare != 0) {
                        return compare;
+               }
        }
 
        /* use number of leading zeros as tie breaker if still equal */
        if (*tiebreaker == 0) {
-               if (numzero1 > numzero2)
+               if (numzero1 > numzero2) {
                        *tiebreaker = 1;
-               else if (numzero1 < numzero2)
+               }
+               else if (numzero1 < numzero2) {
                        *tiebreaker = -1;
+               }
        }
 
        return 0;
@@ -659,25 +670,30 @@ int BLI_natstrcmp(const char *s1, const char *s2)
                if (isdigit(c1) && isdigit(c2)) {
                        int numcompare = left_number_strcmp(s1 + d1, s2 + d2, &tiebreaker);
 
-                       if (numcompare != 0)
+                       if (numcompare != 0) {
                                return numcompare;
+                       }
 
                        d1++;
-                       while (isdigit(s1[d1]))
+                       while (isdigit(s1[d1])) {
                                d1++;
+                       }
                        d2++;
-                       while (isdigit(s2[d2]))
+                       while (isdigit(s2[d2])) {
                                d2++;
+                       }
 
                        c1 = tolower(s1[d1]);
                        c2 = tolower(s2[d2]);
                }
 
                /* first check for '.' so "foo.bar" comes before "foo 1.bar" */
-               if (c1 == '.' && c2 != '.')
+               if (c1 == '.' && c2 != '.') {
                        return -1;
-               if (c1 != '.' && c2 == '.')
+               }
+               if (c1 != '.' && c2 == '.') {
                        return 1;
+               }
                else if (c1 < c2) {
                        return -1;
                }
@@ -691,8 +707,9 @@ int BLI_natstrcmp(const char *s1, const char *s2)
                d2++;
        }
 
-       if (tiebreaker)
+       if (tiebreaker) {
                return tiebreaker;
+       }
 
        /* we might still have a different string because of lower/upper case, in
         * that case fall back to regular string comparison */
@@ -749,8 +766,9 @@ size_t BLI_strnlen(const char *s, const size_t maxlen)
        size_t len;
 
        for (len = 0; len < maxlen; len++, s++) {
-               if (!*s)
+               if (!*s) {
                        break;
+               }
        }
        return len;
 }
@@ -759,18 +777,22 @@ void BLI_str_tolower_ascii(char *str, const size_t len)
 {
        size_t i;
 
-       for (i = 0; (i < len) && str[i]; i++)
-               if (str[i] >= 'A' && str[i] <= 'Z')
+       for (i = 0; (i < len) && str[i]; i++) {
+               if (str[i] >= 'A' && str[i] <= 'Z') {
                        str[i] += 'a' - 'A';
+               }
+       }
 }
 
 void BLI_str_toupper_ascii(char *str, const size_t len)
 {
        size_t i;
 
-       for (i = 0; (i < len) && str[i]; i++)
-               if (str[i] >= 'a' && str[i] <= 'z')
+       for (i = 0; (i < len) && str[i]; i++) {
+               if (str[i] >= 'a' && str[i] <= 'z') {
                        str[i] -= 'a' - 'A';
+               }
+       }
 }
 
 /**
@@ -941,7 +963,9 @@ size_t BLI_str_partition_ex(
 
                if (end) {
                        if (from_right) {
-                               for (tmp = end - 1; (tmp >= str) && (*tmp != *d); tmp--);
+                               for (tmp = end - 1; (tmp >= str) && (*tmp != *d); tmp--) {
+                                       /* pass */
+                               }
                                if (tmp < str) {
                                        tmp = NULL;
                                }
index 12ada9b..0c07d1c 100644 (file)
@@ -77,12 +77,16 @@ ptrdiff_t BLI_utf8_invalid_byte(const char *str, size_t length)
        for (p = (const unsigned char *)str; p < pend; p++, length--) {
                c = *p;
                perr = p;  /* Erroneous char is always the first of an invalid utf8 sequence... */
-               if (ELEM(c, 0xfe, 0xff, 0x00))  /* Those three values are not allowed in utf8 string. */
+               if (ELEM(c, 0xfe, 0xff, 0x00)) {
+                       /* Those three values are not allowed in utf8 string. */
                        goto utf8_error;
-               if (c < 128)
+               }
+               if (c < 128) {
                        continue;
-               if ((c & 0xc0) != 0xc0)
+               }
+               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
@@ -95,51 +99,52 @@ ptrdiff_t BLI_utf8_invalid_byte(const char *str, size_t length)
                /* Check top bits in the second byte */
                p++;
                length--;
-               if ((*p & 0xc0) != 0x80)
+               if ((*p & 0xc0) != 0x80) {
                        goto utf8_error;
+               }
 
                /* Check for overlong sequences for each different length */
                switch (ab) {
                        case 1:
                                /* Check for xx00 000x */
-                               if ((c & 0x3e) == 0) goto utf8_error;
+                               if ((c & 0x3e) == 0) { goto utf8_error; }
                                continue;   /* We know there aren't any more bytes to check */
 
                        case 2:
                                /* Check for 1110 0000, xx0x xxxx */
-                               if (c == 0xe0 && (*p & 0x20) == 0) goto utf8_error;
+                               if (c == 0xe0 && (*p & 0x20) == 0) { goto utf8_error; }
                                /* Some special cases, see section 5 of utf-8 decoder stress-test by Markus Kuhn
                                 * (https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt). */
                                /* From section 5.1 (and 5.2) */
                                if (c == 0xed) {
-                                       if (*p == 0xa0 && *(p + 1) == 0x80) goto utf8_error;
-                                       if (*p == 0xad && *(p + 1) == 0xbf) goto utf8_error;
-                                       if (*p == 0xae && *(p + 1) == 0x80) goto utf8_error;
-                                       if (*p == 0xaf && *(p + 1) == 0xbf) goto utf8_error;
-                                       if (*p == 0xb0 && *(p + 1) == 0x80) goto utf8_error;
-                                       if (*p == 0xbe && *(p + 1) == 0x80) goto utf8_error;
-                                       if (*p == 0xbf && *(p + 1) == 0xbf) goto utf8_error;
+                                       if (*p == 0xa0 && *(p + 1) == 0x80) { goto utf8_error; }
+                                       if (*p == 0xad && *(p + 1) == 0xbf) { goto utf8_error; }
+                                       if (*p == 0xae && *(p + 1) == 0x80) { goto utf8_error; }
+                                       if (*p == 0xaf && *(p + 1) == 0xbf) { goto utf8_error; }
+                                       if (*p == 0xb0 && *(p + 1) == 0x80) { goto utf8_error; }
+                                       if (*p == 0xbe && *(p + 1) == 0x80) { goto utf8_error; }
+                                       if (*p == 0xbf && *(p + 1) == 0xbf) { goto utf8_error; }
                                }
                                /* From section 5.3 */
                                if (c == 0xef) {
-                                       if (*p == 0xbf && *(p + 1) == 0xbe) goto utf8_error;
-                                       if (*p == 0xbf && *(p + 1) == 0xbf) goto utf8_error;
+                                       if (*p == 0xbf && *(p + 1) == 0xbe) { goto utf8_error; }
+                                       if (*p == 0xbf && *(p + 1) == 0xbf) { goto utf8_error; }
                                }
                                break;
 
                        case 3:
                                /* Check for 1111 0000, xx00 xxxx */
-                               if (c == 0xf0 && (*p & 0x30) == 0) goto utf8_error;
+                               if (c == 0xf0 && (*p & 0x30) == 0) { goto utf8_error; }
                                break;
 
                        case 4:
                                /* Check for 1111 1000, xx00 0xxx */
-                               if (c == 0xf8 && (*p & 0x38) == 0) goto utf8_error;
+                               if (c == 0xf8 && (*p & 0x38) == 0) { goto utf8_error; }
                                break;
 
                        case 5:
                                /* Check for 1111 1100, xx00 00xx */
-                               if (c == 0xfc && (*p & 0x3c) == 0) goto utf8_error;
+                               if (c == 0xfc && (*p & 0x3c) == 0) { goto utf8_error; }
                                break;
                }
 
@@ -147,7 +152,7 @@ ptrdiff_t BLI_utf8_invalid_byte(const char *str, size_t length)
                while (--ab > 0) {
                        p++;
                        length--;
-                       if ((*p & 0xc0) != 0x80) goto utf8_error;
+                       if ((*p & 0xc0) != 0x80) { goto utf8_error; }
                }
        }
 
@@ -315,8 +320,9 @@ size_t BLI_strlen_utf8_ex(const char *strc, size_t *r_len_bytes)
        size_t len;
        const char *strc_orig = strc;
 
-       for (len = 0; *strc; len++)
+       for (len = 0; *strc; len++) {
                strc += BLI_str_utf8_size_safe(strc);
+       }
 
        *r_len_bytes = (size_t)(strc - strc_orig);
        return len;
@@ -326,8 +332,9 @@ size_t BLI_strlen_utf8(const char *strc)
 {
        size_t len;
 
-       for (len = 0; *strc; len++)
+       for (len = 0; *strc; len++) {
                strc += BLI_str_utf8_size_safe(strc);
+       }
 
        return len;
 }
@@ -412,8 +419,9 @@ int BLI_wcswidth(const wchar_t *pwcs, size_t n)
 int BLI_str_utf8_char_width(const char *p)
 {
        uint unicode = BLI_str_utf8_as_unicode(p);
-       if (unicode == BLI_UTF8_ERR)
+       if (unicode == BLI_UTF8_ERR) {
                return -1;
+       }
 
        return BLI_wcwidth((wchar_t)unicode);
 }
@@ -423,8 +431,9 @@ int BLI_str_utf8_char_width_safe(const char *p)
        int columns;
 
        uint unicode = BLI_str_utf8_as_unicode(p);
-       if (unicode == BLI_UTF8_ERR)
+       if (unicode == BLI_UTF8_ERR) {
                return 1;
+       }
 
        columns = BLI_wcwidth((wchar_t)unicode);
 
@@ -528,8 +537,9 @@ uint BLI_str_utf8_as_unicode(const char *p)
        const unsigned char c = (unsigned char) *p;
 
        UTF8_COMPUTE(c, mask, len, -1);
-       if (UNLIKELY(len == -1))
+       if (UNLIKELY(len == -1)) {
                return BLI_UTF8_ERR;
+       }
        UTF8_GET(result, p, i, mask, len, BLI_UTF8_ERR);
 
        return result;
@@ -544,8 +554,9 @@ uint BLI_str_utf8_as_unicode_and_size(const char *__restrict p, size_t *__restri
        const unsigned char c = (unsigned char) *p;
 
        UTF8_COMPUTE(c, mask, len, -1);
-       if (UNLIKELY(len == -1))
+       if (UNLIKELY(len == -1)) {
                return BLI_UTF8_ERR;
+       }
        UTF8_GET(result, p, i, mask, len, BLI_UTF8_ERR);
        *index += (size_t)len;
        return result;
@@ -788,8 +799,9 @@ size_t BLI_str_partition_ex_utf8(
                for (d = delim; *d != '\0'; ++d) {
                        if (*d == c) {
                                /* *suf is already correct in case from_right is true. */
-                               if (!from_right)
+                               if (!from_right) {
                                        *suf = (char *)(str + index);
+                               }
                                return (size_t)(*sep - str);
                        }
                }
index 3e13b0d..46472d8 100644 (file)
@@ -68,8 +68,9 @@ size_t BLI_split_name_num(char *left, int *nr, const char *name, const char deli
                                left[a] = '\0';  /* truncate left part here */
                                *nr = atol(name + a + 1);
                                /* casting down to an int, can overflow for large numbers */
-                               if (*nr < 0)
+                               if (*nr < 0) {
                                        *nr = 0;
+                               }
                                return a;
                        }
                        else if (isdigit(name[a]) == 0) {
@@ -368,8 +369,9 @@ bool BLI_uniquename(ListBase *list, void *vlink, const char *defname, char delim
        BLI_assert(name_len > 1);
 
        /* See if we are given an empty string */
-       if (ELEM(NULL, vlink, defname))
+       if (ELEM(NULL, vlink, defname)) {
                return false;
+       }
 
        return BLI_uniquename_cb(uniquename_unique_check, &data, defname, delim, GIVE_STRADDR(vlink, name_offs), name_len);
 }
index e2feef1..3a6613b 100644 (file)
@@ -333,8 +333,9 @@ static void task_pool_num_decrease(TaskPool *pool, size_t done)
 
        pool->num -= done;
 
-       if (pool->num == 0)
+       if (pool->num == 0) {
                BLI_condition_notify_all(&pool->num_cond);
+       }
 
        BLI_mutex_unlock(&pool->num_mutex);
 }
@@ -354,8 +355,9 @@ static bool task_scheduler_thread_wait_pop(TaskScheduler *scheduler, Task **task
        bool found_task = false;
        BLI_mutex_lock(&scheduler->queue_mutex);
 
-       while (!scheduler->queue.first && !scheduler->do_exit)
+       while (!scheduler->queue.first && !scheduler->do_exit) {
                BLI_condition_wait(&scheduler->queue_cond, &scheduler->queue_mutex);
+       }
 
        do {
                Task *current_task;
@@ -391,8 +393,9 @@ static bool task_scheduler_thread_wait_pop(TaskScheduler *scheduler, Task **task
                        BLI_remlink(&scheduler->queue, *task);
                        break;
                }
-               if (!found_task)
+               if (!found_task) {
                        BLI_condition_wait(&scheduler->queue_cond, &scheduler->queue_mutex);
+               }
        } while (!found_task);
 
        BLI_mutex_unlock(&scheduler->queue_mutex);
@@ -525,8 +528,9 @@ void BLI_task_scheduler_free(TaskScheduler *scheduler)
                int i;
 
                for (i = 0; i < scheduler->num_threads; i++) {
-                       if (pthread_join(scheduler->threads[i], NULL) != 0)
+                       if (pthread_join(scheduler->threads[i], NULL) != 0) {
                                fprintf(stderr, "TaskScheduler failed to join thread %d/%d\n", i, scheduler->num_threads);
+                       }
                }
 
                MEM_freeN(scheduler->threads);
@@ -567,10 +571,12 @@ static void task_scheduler_push(TaskScheduler *scheduler, Task *task, TaskPriori
        /* add task to queue */
        BLI_mutex_lock(&scheduler->queue_mutex);
 
-       if (priority == TASK_PRIORITY_HIGH)
+       if (priority == TASK_PRIORITY_HIGH) {
                BLI_addhead(&scheduler->queue, task);
-       else
+       }
+       else {
                BLI_addtail(&scheduler->queue, task);
+       }
 
        BLI_condition_notify_one(&scheduler->queue_cond);
        BLI_mutex_unlock(&scheduler->queue_mutex);
@@ -908,11 +914,13 @@ void BLI_task_pool_work_and_wait(TaskPool *pool)
                }
 
                BLI_mutex_lock(&pool->num_mutex);
-               if (pool->num == 0)
+               if (pool->num == 0) {
                        break;
+               }
 
-               if (!found_task)
+               if (!found_task) {
                        BLI_condition_wait(&pool->num_cond, &pool->num_mutex);
+               }
        }
 
        BLI_mutex_unlock(&pool->num_mutex);
@@ -936,8 +944,9 @@ void BLI_task_pool_cancel(TaskPool *pool)
 
        /* wait until all entries&