style cleanup: whitespace, bli & makesdna
authorCampbell Barton <ideasman42@gmail.com>
Sat, 12 May 2012 15:02:10 +0000 (15:02 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 12 May 2012 15:02:10 +0000 (15:02 +0000)
24 files changed:
source/blender/blenlib/intern/BLI_args.c
source/blender/blenlib/intern/BLI_dynstr.c
source/blender/blenlib/intern/BLI_ghash.c
source/blender/blenlib/intern/BLI_heap.c
source/blender/blenlib/intern/BLI_kdopbvh.c
source/blender/blenlib/intern/BLI_kdtree.c
source/blender/blenlib/intern/BLI_linklist.c
source/blender/blenlib/intern/BLI_memarena.c
source/blender/blenlib/intern/DLRB_tree.c
source/blender/blenlib/intern/bpath.c
source/blender/blenlib/intern/edgehash.c
source/blender/blenlib/intern/fileops.c
source/blender/blenlib/intern/jitter.c
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/math_rotation.c
source/blender/blenlib/intern/noise.c
source/blender/blenlib/intern/rand.c
source/blender/blenlib/intern/smallhash.c
source/blender/blenlib/intern/storage.c
source/blender/blenlib/intern/threads.c
source/blender/blenloader/intern/readblenentry.c
source/blender/blenloader/intern/undofile.c
source/blender/makesdna/intern/dna_genfile.c
source/blender/makesdna/intern/makesdna.c

index ed3c6fa..4e194b2 100644 (file)
@@ -49,7 +49,7 @@ typedef struct bArgDoc {
        const char *short_arg;
        const char *long_arg;
        const char *documentation;
-       int  done;
+       int done;
 } bArgDoc;
 
 typedef struct bAKey {
@@ -68,24 +68,24 @@ typedef struct bArgument {
 struct bArgs {
        ListBase docs;
        GHash  *items;
-       int     argc;
+       int argc;
        const char  **argv;
-       int       *passes;
+       int *passes;
 };
 
 static unsigned int case_strhash(const void *ptr)
 {
-       const char *s= ptr;
-       unsigned int i= 0;
+       const char *s = ptr;
+       unsigned int i = 0;
        unsigned char c;
 
-       while ( (c= tolower(*s++)) )
-               i= i*37 + c;
+       while ( (c = tolower(*s++)) )
+               i = i * 37 + c;
 
        return i;
 }
 
-static unsigned int    keyhash(const void *ptr)
+static unsigned int keyhash(const void *ptr)
 {
        const bAKey *k = ptr;
        return case_strhash(k->arg); // ^ BLI_ghashutil_inthash((void*)k->pass);
@@ -102,7 +102,7 @@ static int keycmp(const void *a, const void *b)
                        return strcmp(ka->arg, kb->arg);
        }
        else {
-               return BLI_ghashutil_intcmp((const void*)ka->pass, (const void*)kb->pass);
+               return BLI_ghashutil_intcmp((const void *)ka->pass, (const void *)kb->pass);
        }
 }
 
@@ -182,8 +182,8 @@ static void internalAdd(struct bArgs *ba, const char *arg, int pass, int case_st
 
        if (a) {
                printf("WARNING: conflicting argument\n");
-               printf("\ttrying to add '%s' on pass %i, %scase sensitive\n", arg, pass, case_str == 1? "not ": "");
-               printf("\tconflict with '%s' on pass %i, %scase sensitive\n\n", a->key->arg, (int)a->key->pass, a->key->case_str == 1? "not ": "");
+               printf("\ttrying to add '%s' on pass %i, %scase sensitive\n", arg, pass, case_str == 1 ? "not " : "");
+               printf("\tconflict with '%s' on pass %i, %scase sensitive\n\n", a->key->arg, (int)a->key->pass, a->key->case_str == 1 ? "not " : "");
        }
 
        a = MEM_callocN(sizeof(bArgument), "bArgument");
@@ -259,9 +259,9 @@ void BLI_argsParse(struct bArgs *ba, int pass, BA_ArgCallback default_cb, void *
 {
        int i = 0;
 
-       for ( i = 1; i < ba->argc; i++) { /* skip argv[0] */
+       for (i = 1; i < ba->argc; i++) {  /* skip argv[0] */
                if (ba->passes[i] == 0) {
-                        /* -1 signal what side of the comparison it is */
+                       /* -1 signal what side of the comparison it is */
                        bArgument *a = lookUp(ba, ba->argv[i], pass, -1);
                        BA_ArgCallback func = NULL;
                        void *data = NULL;
index 54d9bc5..d1c3050 100644 (file)
@@ -46,9 +46,9 @@
 
 #ifndef va_copy
 # ifdef __va_copy
-#  define va_copy(a,b) __va_copy(a,b)
+#  define va_copy(a, b) __va_copy(a, b)
 # else /* !__va_copy */
-#  define va_copy(a,b) ((a)=(b))
+#  define va_copy(a, b) ((a) = (b))
 # endif /* __va_copy */
 #endif /* va_copy */
 
@@ -70,65 +70,65 @@ struct DynStr {
 
 DynStr *BLI_dynstr_new(void)
 {
-       DynStr *ds= MEM_mallocN(sizeof(*ds), "DynStr");
-       ds->elems= ds->last= NULL;
-       ds->curlen= 0;
+       DynStr *ds = MEM_mallocN(sizeof(*ds), "DynStr");
+       ds->elems = ds->last = NULL;
+       ds->curlen = 0;
        
        return ds;
 }
 
 void BLI_dynstr_append(DynStr *ds, const char *cstr)
 {
-       DynStrElem *dse= malloc(sizeof(*dse));
-       int cstrlen= strlen(cstr);
+       DynStrElem *dse = malloc(sizeof(*dse));
+       int cstrlen = strlen(cstr);
        
-       dse->str= malloc(cstrlen+1);
-       memcpy(dse->str, cstr, cstrlen+1);
-       dse->next= NULL;
+       dse->str = malloc(cstrlen + 1);
+       memcpy(dse->str, cstr, cstrlen + 1);
+       dse->next = NULL;
        
        if (!ds->last)
-               ds->last= ds->elems= dse;
+               ds->last = ds->elems = dse;
        else
-               ds->last= ds->last->next= dse;
+               ds->last = ds->last->next = dse;
 
-       ds->curlen+= cstrlen;
+       ds->curlen += cstrlen;
 }
 
 void BLI_dynstr_nappend(DynStr *ds, const char *cstr, int len)
 {
-       DynStrElem *dse= malloc(sizeof(*dse));
-       int cstrlen= BLI_strnlen(cstr, len);
+       DynStrElem *dse = malloc(sizeof(*dse));
+       int cstrlen = BLI_strnlen(cstr, len);
 
-       dse->str= malloc(cstrlen+1);
+       dse->str = malloc(cstrlen + 1);
        memcpy(dse->str, cstr, cstrlen);
        dse->str[cstrlen] = '\0';
-       dse->next= NULL;
+       dse->next = NULL;
 
        if (!ds->last)
-               ds->last= ds->elems= dse;
+               ds->last = ds->elems = dse;
        else
-               ds->last= ds->last->next= dse;
+               ds->last = ds->last->next = dse;
 
-       ds->curlen+= cstrlen;
+       ds->curlen += cstrlen;
 }
 
 void BLI_dynstr_vappendf(DynStr *ds, const char *format, va_list args)
 {
        char *message, fixedmessage[256];
-       int len= sizeof(fixedmessage);
-       const int maxlen= 65536;
+       int len = sizeof(fixedmessage);
+       const int maxlen = 65536;
        int retval;
 
        while (1) {
                va_list args_cpy;
                if (len == sizeof(fixedmessage))
-                       message= fixedmessage;
+                       message = fixedmessage;
                else
-                       message= MEM_callocN(sizeof(char) * len, "BLI_dynstr_appendf");
+                       message = MEM_callocN(sizeof(char) * len, "BLI_dynstr_appendf");
 
                /* cant reuse the same args, so work on a copy */
                va_copy(args_cpy, args);
-               retval= vsnprintf(message, len, format, args_cpy);
+               retval = vsnprintf(message, len, format, args_cpy);
                va_end(args_cpy);
 
                if (retval == -1) {
@@ -136,7 +136,7 @@ void BLI_dynstr_vappendf(DynStr *ds, const char *format, va_list args)
                         * there is a formatting error, so we impose a maximum length */
                        if (message != fixedmessage)
                                MEM_freeN(message);
-                       message= NULL;
+                       message = NULL;
 
                        len *= 2;
                        if (len > maxlen) {
@@ -148,10 +148,10 @@ void BLI_dynstr_vappendf(DynStr *ds, const char *format, va_list args)
                        /* in C99 the actual length required is returned */
                        if (message != fixedmessage)
                                MEM_freeN(message);
-                       message= NULL;
+                       message = NULL;
 
                        /* retval doesn't include \0 terminator */
-                       len= retval + 1;
+                       len = retval + 1;
                }
                else
                        break;
@@ -169,8 +169,8 @@ void BLI_dynstr_appendf(DynStr *ds, const char *format, ...)
 {
        va_list args;
        char *message, fixedmessage[256];
-       int len= sizeof(fixedmessage);
-       const int maxlen= 65536;
+       int len = sizeof(fixedmessage);
+       const int maxlen = 65536;
        int retval;
 
        /* note that it's tempting to just call BLI_dynstr_vappendf here
@@ -179,12 +179,12 @@ void BLI_dynstr_appendf(DynStr *ds, const char *format, ...)
 
        while (1) {
                if (len == sizeof(fixedmessage))
-                       message= fixedmessage;
+                       message = fixedmessage;
                else
-                       message= MEM_callocN(sizeof(char)*(len), "BLI_dynstr_appendf");
+                       message = MEM_callocN(sizeof(char) * (len), "BLI_dynstr_appendf");
 
                va_start(args, format);
-               retval= vsnprintf(message, len, format, args);
+               retval = vsnprintf(message, len, format, args);
                va_end(args);
 
                if (retval == -1) {
@@ -192,7 +192,7 @@ void BLI_dynstr_appendf(DynStr *ds, const char *format, ...)
                         * there is a formatting error, so we impose a maximum length */
                        if (message != fixedmessage)
                                MEM_freeN(message);
-                       message= NULL;
+                       message = NULL;
 
                        len *= 2;
                        if (len > maxlen) {
@@ -204,10 +204,10 @@ void BLI_dynstr_appendf(DynStr *ds, const char *format, ...)
                        /* in C99 the actual length required is returned */
                        if (message != fixedmessage)
                                MEM_freeN(message);
-                       message= NULL;
+                       message = NULL;
 
                        /* retval doesn't include \0 terminator */
-                       len= retval + 1;
+                       len = retval + 1;
                }
                else
                        break;
@@ -231,19 +231,19 @@ void BLI_dynstr_get_cstring_ex(DynStr *ds, char *rets)
        char *s;
        DynStrElem *dse;
 
-       for (s= rets, dse= ds->elems; dse; dse= dse->next) {
-               int slen= strlen(dse->str);
+       for (s = rets, dse = ds->elems; dse; dse = dse->next) {
+               int slen = strlen(dse->str);
 
                memcpy(s, dse->str, slen);
 
-               s+= slen;
+               s += slen;
        }
-       rets[ds->curlen]= '\0';
+       rets[ds->curlen] = '\0';
 }
 
 char *BLI_dynstr_get_cstring(DynStr *ds)
 {
-       char *rets= MEM_mallocN(ds->curlen+1, "dynstr_cstring");
+       char *rets = MEM_mallocN(ds->curlen + 1, "dynstr_cstring");
        BLI_dynstr_get_cstring_ex(ds, rets);
        return rets;
 }
@@ -252,13 +252,13 @@ void BLI_dynstr_free(DynStr *ds)
 {
        DynStrElem *dse;
        
-       for (dse= ds->elems; dse; ) {
-               DynStrElem *n= dse->next;
+       for (dse = ds->elems; dse; ) {
+               DynStrElem *n = dse->next;
                
                free(dse->str);
                free(dse);
                
-               dse= n;
+               dse = n;
        }
        
        MEM_freeN(ds);
index 65461b7..6ec3d03 100644 (file)
@@ -78,7 +78,7 @@ int BLI_ghash_size(GHash *gh)
 void BLI_ghash_insert(GHash *gh, void *key, void *val)
 {
        unsigned int hash = gh->hashfp(key) % gh->nbuckets;
-       Entry *e = (Entry*)BLI_mempool_alloc(gh->entrypool);
+       Entry *e = (Entry *)BLI_mempool_alloc(gh->entrypool);
 
        e->key = key;
        e->val = val;
@@ -90,11 +90,11 @@ void BLI_ghash_insert(GHash *gh, void *key, void *val)
                int i, nold = gh->nbuckets;
 
                gh->nbuckets = hashsizes[++gh->cursize];
-               gh->buckets = (Entry**)MEM_mallocN(gh->nbuckets * sizeof(*gh->buckets), "buckets");
+               gh->buckets = (Entry **)MEM_mallocN(gh->nbuckets * sizeof(*gh->buckets), "buckets");
                memset(gh->buckets, 0, gh->nbuckets * sizeof(*gh->buckets));
 
                for (i = 0; i < nold; i++) {
-                       for (e = old[i]; e;) {
+                       for (e = old[i]; e; ) {
                                Entry *n = e->next;
 
                                hash = gh->hashfp(e->key) % gh->nbuckets;
@@ -174,7 +174,7 @@ void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreef
                for (i = 0; i < gh->nbuckets; i++) {
                        Entry *e;
 
-                       for (e = gh->buckets[i]; e;) {
+                       for (e = gh->buckets[i]; e; ) {
                                Entry *n = e->next;
 
                                if (keyfreefp) keyfreefp(e->key);
@@ -333,6 +333,6 @@ int BLI_ghashutil_paircmp(const void *a, const void *b)
 
 void BLI_ghashutil_pairfree(void *ptr)
 {
-       MEM_freeN((void*)ptr);
+       MEM_freeN((void *)ptr);
 }
 
index fa7b91b..4e13580 100644 (file)
@@ -184,7 +184,7 @@ void *BLI_heap_popmin(Heap *heap)
        if (heap->size == 1)
                heap->size--;
        else {
-               HEAP_SWAP(heap, 0, heap->size-1);
+               HEAP_SWAP(heap, 0, heap->size - 1);
                heap->size--;
 
                BLI_heap_down(heap, 0);
index 8662406..2b21758 100644 (file)
 #define MAX_TREETYPE 32
 #define DEFAULT_FIND_NEAREST_HEAP_SIZE 1024
 
-typedef struct BVHNode
-{
+typedef struct BVHNode {
        struct BVHNode **children;
        struct BVHNode *parent; // some user defined traversed need that
        struct BVHNode *skip[2];
-       float *bv;              // Bounding volume of all nodes, max 13 axis
-       int index;              // face, edge, vertex index
-       char totnode;   // how many nodes are used, used for speedup
-       char main_axis; // Axis used to split this node
+       float *bv;      /* Bounding volume of all nodes, max 13 axis */
+       int index;      /* face, edge, vertex index */
+       char totnode;   /* how many nodes are used, used for speedup */
+       char main_axis; /* Axis used to split this node */
 } BVHNode;
 
-struct BVHTree
-{
+struct BVHTree {
        BVHNode **nodes;
-       BVHNode *nodearray; /* pre-alloc branch nodes */
-       BVHNode **nodechild;    // pre-alloc childs for nodes
-       float   *nodebv;                // pre-alloc bounding-volumes for nodes
-       float   epsilon; /* epslion is used for inflation of the k-dop     */
-       int     totleaf; // leafs
-       int     totbranch;
-       char    tree_type; // type of tree (4 => quadtree)
-       char    axis; // kdop type (6 => OBB, 7 => AABB, ...)
-       char    start_axis, stop_axis; // KDOP_AXES array indices according to axis
+       BVHNode *nodearray;     /* pre-alloc branch nodes */
+       BVHNode **nodechild;    /* pre-alloc childs for nodes */
+       float   *nodebv;        /* pre-alloc bounding-volumes for nodes */
+       float epsilon;          /* epslion is used for inflation of the k-dop      */
+       int totleaf;            /* leafs */
+       int totbranch;
+       char tree_type;         /* type of tree (4 => quadtree) */
+       char axis;              /* kdop type (6 => OBB, 7 => AABB, ...) */
+       char start_axis, stop_axis;  /* KDOP_AXES array indices according to axis */
 };
 
-typedef struct BVHOverlapData 
-{  
+typedef struct BVHOverlapData {
        BVHTree *tree1, *tree2; 
        BVHTreeOverlap *overlap; 
        int i, max_overlap; /* i is number of overlaps */
        int start_axis, stop_axis;
 } BVHOverlapData;
 
-typedef struct BVHNearestData
-{
+typedef struct BVHNearestData {
        BVHTree *tree;
-       const float     *co;
+       const float *co;
        BVHTree_NearestPointCallback callback;
-       void    *userdata;
-       float proj[13];                 //coordinates projection over axis
+       void    *userdata;
+       float proj[13];         /* coordinates projection over axis */
        BVHTreeNearest nearest;
 
 } BVHNearestData;
 
-typedef struct BVHRayCastData
-{
+typedef struct BVHRayCastData {
        BVHTree *tree;
 
        BVHTree_RayCastCallback callback;
-       void    *userdata;
+       void    *userdata;
 
 
-       BVHTreeRay    ray;
+       BVHTreeRay ray;
        float ray_dot_axis[13];
        float idot_axis[13];
        int index[6];
@@ -120,55 +115,55 @@ typedef struct BVHRayCastData
 // Notes: You can choose the tree type --> binary, quad, octree, choose below
 ////////////////////////////////////////////////////////////////////////
 
-static float KDOP_AXES[13][3] =
-{ {1.0, 0, 0}, {0, 1.0, 0}, {0, 0, 1.0}, {1.0, 1.0, 1.0}, {1.0, -1.0, 1.0}, {1.0, 1.0, -1.0},
-{1.0, -1.0, -1.0}, {1.0, 1.0, 0}, {1.0, 0, 1.0}, {0, 1.0, 1.0}, {1.0, -1.0, 0}, {1.0, 0, -1.0},
-{0, 1.0, -1.0}
+static float KDOP_AXES[13][3] = {
+       {1.0, 0, 0}, {0, 1.0, 0}, {0, 0, 1.0}, {1.0, 1.0, 1.0}, {1.0, -1.0, 1.0}, {1.0, 1.0, -1.0},
+       {1.0, -1.0, -1.0}, {1.0, 1.0, 0}, {1.0, 0, 1.0}, {0, 1.0, 1.0}, {1.0, -1.0, 0}, {1.0, 0, -1.0},
+       {0, 1.0, -1.0}
 };
 
 /*
  * Generic push and pop heap
  */
-#define PUSH_HEAP_BODY(HEAP_TYPE, PRIORITY, heap, heap_size)   \
-{                                                                                                      \
-       HEAP_TYPE element = heap[heap_size-1];                  \
-       int child = heap_size-1;                                                \
-       while (child != 0)                                                              \
-       {                                                                                               \
-               int parent = (child-1) / 2;                                     \
-               if (PRIORITY(element, heap[parent]))                    \
-               {                                                                                       \
-                       heap[child] = heap[parent];                             \
-                       child = parent;                                                 \
-               }                                                                                       \
-               else break;                                                                     \
-       }                                                                                               \
-       heap[child] = element;                                                  \
-}
+#define PUSH_HEAP_BODY(HEAP_TYPE, PRIORITY, heap, heap_size)                  \
+       {                                                                         \
+               HEAP_TYPE element = heap[heap_size - 1];                              \
+               int child = heap_size - 1;                                            \
+               while (child != 0)                                                    \
+               {                                                                     \
+                       int parent = (child - 1) / 2;                                     \
+                       if (PRIORITY(element, heap[parent]))                              \
+                       {                                                                 \
+                               heap[child] = heap[parent];                                   \
+                               child = parent;                                               \
+                       }                                                                 \
+                       else break;                                                       \
+               }                                                                     \
+               heap[child] = element;                                                \
+       }
 
-#define POP_HEAP_BODY(HEAP_TYPE, PRIORITY, heap, heap_size)    \
-{                                                                                                      \
-       HEAP_TYPE element = heap[heap_size-1];                  \
-       int parent = 0;                                                                 \
-       while (parent < (heap_size-1)/2 )                               \
-       {                                                                                               \
-               int child2 = (parent+1)*2;                                      \
-               if (PRIORITY(heap[child2-1], heap[child2]))     \
-                       --child2;                                                               \
-                                                                                                       \
-               if (PRIORITY(element, heap[child2]))                    \
-                       break;                                                                  \
-                                                                                                       \
-               heap[parent] = heap[child2];                            \
-               parent = child2;                                                        \
-       }                                                                                               \
-       heap[parent] = element;                                                 \
-}
+#define POP_HEAP_BODY(HEAP_TYPE, PRIORITY, heap, heap_size)                   \
+       {                                                                         \
+               HEAP_TYPE element = heap[heap_size - 1];                              \
+               int parent = 0;                                                       \
+               while (parent < (heap_size - 1) / 2)                                  \
+               {                                                                     \
+                       int child2 = (parent + 1) * 2;                                    \
+                       if (PRIORITY(heap[child2 - 1], heap[child2])) {                   \
+                               child2--;                                                     \
+                       }                                                                 \
+                       if (PRIORITY(element, heap[child2])) {                            \
+                               break;                                                        \
+                       }                                                                 \
+                       heap[parent] = heap[child2];                                      \
+                       parent = child2;                                                  \
+               }                                                                     \
+               heap[parent] = element;                                               \
+       }
 
 #if 0
 static int ADJUST_MEMORY(void *local_memblock, void **memblock, int new_size, int *max_size, int size_per_item)
 {
-       int   new_max_size = *max_size * 2;
+       int new_max_size = *max_size * 2;
        void *new_memblock = NULL;
 
        if (new_size <= *max_size)
@@ -176,11 +171,11 @@ static int ADJUST_MEMORY(void *local_memblock, void **memblock, int new_size, in
 
        if (*memblock == local_memblock)
        {
-               new_memblock = malloc( size_per_item * new_max_size );
+               new_memblock = malloc(size_per_item * new_max_size);
                memcpy(new_memblock, *memblock, size_per_item * *max_size);
        }
        else
-               new_memblock = realloc(*memblock, size_per_item * new_max_size );
+               new_memblock = realloc(*memblock, size_per_item * new_max_size);
 
        if (new_memblock)
        {
@@ -206,7 +201,7 @@ static int ADJUST_MEMORY(void *local_memblock, void **memblock, int new_size, in
 #if 0
 static int floor_lg(int a)
 {
-       return (int)(floor(log(a)/log(2)));
+       return (int)(floor(log(a) / log(2)));
 }
 #endif
 
@@ -217,20 +212,20 @@ static void bvh_insertionsort(BVHNode **a, int lo, int hi, int axis)
 {
        int i, j;
        BVHNode *t;
-       for (i=lo; i < hi; i++) {
-               j=i;
+       for (i = lo; i < hi; i++) {
+               j = i;
                t = a[i];
-               while ((j!=lo) && (t->bv[axis] < (a[j-1])->bv[axis])) {
-                       a[j] = a[j-1];
+               while ((j != lo) && (t->bv[axis] < (a[j - 1])->bv[axis])) {
+                       a[j] = a[j - 1];
                        j--;
                }
                a[j] = t;
        }
 }
 
-static int bvh_partition(BVHNode **a, int lo, int hi, BVHNode * x, int axis)
+static int bvh_partition(BVHNode **a, int lo, int hi, BVHNode *x, int axis)
 {
-       int i=lo, j=hi;
+       int i = lo, j = hi;
        while (1) {
                while ((a[i])->bv[axis] < x->bv[axis]) i++;
                j--;
@@ -248,33 +243,33 @@ static int bvh_partition(BVHNode **a, int lo, int hi, BVHNode * x, int axis)
 #if 0
 static void bvh_downheap(BVHNode **a, int i, int n, int lo, int axis)
 {
-       BVHNode * d = a[lo+i-1];
+       BVHNode *d = a[lo + i - 1];
        int child;
-       while (i<=n/2)
+       while (i <= n / 2)
        {
-               child = 2*i;
-               if ((child < n) && ((a[lo+child-1])->bv[axis] < (a[lo+child])->bv[axis]))
+               child = 2 * i;
+               if ((child < n) && ((a[lo + child - 1])->bv[axis] < (a[lo + child])->bv[axis]))
                {
                        child++;
                }
-               if (!(d->bv[axis] < (a[lo+child-1])->bv[axis])) break;
-               a[lo+i-1] = a[lo+child-1];
+               if (!(d->bv[axis] < (a[lo + child - 1])->bv[axis])) break;
+               a[lo + i - 1] = a[lo + child - 1];
                i = child;
        }
-       a[lo+i-1] = d;
+       a[lo + i - 1] = d;
 }
 
 static void bvh_heapsort(BVHNode **a, int lo, int hi, int axis)
 {
-       int n = hi-lo, i;
-       for (i=n/2; i>=1; i=i-1)
+       int n = hi - lo, i;
+       for (i = n / 2; i >= 1; i = i - 1)
        {
                bvh_downheap(a, i, n, lo, axis);
        }
-       for (i=n; i>1; i=i-1)
+       for (i = n; i > 1; i = i - 1)
        {
-               SWAP(BVHNode*, a[lo], a[lo+i-1]);
-               bvh_downheap(a, 1, i-1, lo, axis);
+               SWAP(BVHNode *, a[lo], a[lo + i - 1]);
+               bvh_downheap(a, 1, i - 1, lo, axis);
        }
 }
 #endif
@@ -307,21 +302,21 @@ static BVHNode *bvh_medianof3(BVHNode **a, int lo, int mid, int hi, int axis) //
 /*
  * Quicksort algorithm modified for Introsort
  */
-static void bvh_introsort_loop (BVHNode **a, int lo, int hi, int depth_limit, int axis)
+static void bvh_introsort_loop(BVHNode **a, int lo, int hi, int depth_limit, int axis)
 {
        int p;
 
-       while (hi-lo > size_threshold)
+       while (hi - lo > size_threshold)
        {
                if (depth_limit == 0)
                {
                        bvh_heapsort(a, lo, hi, axis);
                        return;
                }
-               depth_limit=depth_limit-1;
-               p=bvh_partition(a, lo, hi, bvh_medianof3(a, lo, lo+((hi-lo)/2)+1, hi-1, axis), axis);
+               depth_limit = depth_limit - 1;
+               p = bvh_partition(a, lo, hi, bvh_medianof3(a, lo, lo + ((hi - lo) / 2) + 1, hi - 1, axis), axis);
                bvh_introsort_loop(a, p, hi, depth_limit, axis);
-               hi=p;
+               hi = p;
        }
 }
 
@@ -329,8 +324,8 @@ static void sort(BVHNode **a0, int begin, int end, int axis)
 {
        if (begin < end)
        {
-               BVHNode **a=a0;
-               bvh_introsort_loop(a, begin, end, 2*floor_lg(end-begin), axis);
+               BVHNode **a = a0;
+               bvh_introsort_loop(a, begin, end, 2 * floor_lg(end - begin), axis);
                bvh_insertionsort(a, begin, end, axis);
        }
 }
@@ -347,8 +342,8 @@ static void sort_along_axis(BVHTree *tree, int start, int end, int axis)
 static int partition_nth_element(BVHNode **a, int _begin, int _end, int n, int axis)
 {
        int begin = _begin, end = _end, cut;
-       while (end-begin > 3) {
-               cut = bvh_partition(a, begin, end, bvh_medianof3(a, begin, (begin+end)/2, end-1, axis), axis );
+       while (end - begin > 3) {
+               cut = bvh_partition(a, begin, end, bvh_medianof3(a, begin, (begin + end) / 2, end - 1, axis), axis);
                if (cut <= n)
                        begin = cut;
                else
@@ -368,7 +363,7 @@ 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
                        build_skip_links(tree, node->children[i], left, right);
@@ -415,8 +410,8 @@ static void refit_kdop_hull(BVHTree *tree, BVHNode *node, int start, int end)
 
        
        for (i = tree->start_axis; i < tree->stop_axis; i++) {
-               bv[2*i] = FLT_MAX;
-               bv[2*i + 1] = -FLT_MAX;
+               bv[2 * i] = FLT_MAX;
+               bv[2 * i + 1] = -FLT_MAX;
        }
 
        for (j = start; j < end; j++) {
@@ -445,15 +440,15 @@ static char get_largest_axis(float *bv)
        middle_point[2] = (bv[5]) - (bv[4]); // z axis
        if (middle_point[0] > middle_point[1])  {
                if (middle_point[0] > middle_point[2])
-                       return 1; // max x axis
+                       return 1;  // max x axis
                else
-                       return 5; // max z axis
+                       return 5;  // max z axis
        }
        else {
                if (middle_point[1] > middle_point[2])
-                       return 3; // max y axis
+                       return 3;  // max y axis
                else
-                       return 5; // max z axis
+                       return 5;  // max z axis
        }
 }
 
@@ -464,8 +459,8 @@ static void node_join(BVHTree *tree, BVHNode *node)
        int i, j;
        
        for (i = tree->start_axis; i < tree->stop_axis; i++) {
-               node->bv[2*i] = FLT_MAX;
-               node->bv[2*i + 1] = -FLT_MAX;
+               node->bv[2 * i] = FLT_MAX;
+               node->bv[2 * i + 1] = -FLT_MAX;
        }
        
        for (i = 0; i < tree->tree_type; i++) {
@@ -492,15 +487,15 @@ static void node_join(BVHTree *tree, BVHNode *node)
 static void bvhtree_print_tree(BVHTree *tree, BVHNode *node, int depth)
 {
        int i;
-       for (i=0; i<depth; i++) printf(" ");
+       for (i = 0; i < depth; i++) printf(" ");
        printf(" - %d (%ld): ", node->index, node - tree->nodearray);
-       for (i=2*tree->start_axis; i<2*tree->stop_axis; i++)
+       for (i = 2 * tree->start_axis; i < 2 * tree->stop_axis; i++)
                printf("%.3f ", node->bv[i]);
        printf("\n");
 
-       for (i=0; i<tree->tree_type; i++)
+       for (i = 0; i < tree->tree_type; i++)
                if (node->children[i])
-                       bvhtree_print_tree(tree, node->children[i], depth+1);
+                       bvhtree_print_tree(tree, node->children[i], depth + 1);
 }
 
 static void bvhtree_info(BVHTree *tree)
@@ -508,15 +503,14 @@ static void bvhtree_info(BVHTree *tree)
        printf("BVHTree info\n");
        printf("tree_type = %d, axis = %d, epsilon = %f\n", tree->tree_type, tree->axis, tree->epsilon);
        printf("nodes = %d, branches = %d, leafs = %d\n", tree->totbranch + tree->totleaf,  tree->totbranch, tree->totleaf);
-       printf("Memory per node = %ldbytes\n", sizeof(BVHNode) + sizeof(BVHNode*)*tree->tree_type + sizeof(float)*tree->axis);
+       printf("Memory per node = %ldbytes\n", sizeof(BVHNode) + sizeof(BVHNode *) * tree->tree_type + sizeof(float) * tree->axis);
        printf("BV memory = %dbytes\n", MEM_allocN_len(tree->nodebv));
 
-       printf("Total memory = %ldbytes\n", sizeof(BVHTree)
-               + MEM_allocN_len(tree->nodes)
-               + MEM_allocN_len(tree->nodearray)
-               + MEM_allocN_len(tree->nodechild)
-               + MEM_allocN_len(tree->nodebv)
-               );
+       printf("Total memory = %ldbytes\n", sizeof(BVHTree) +
+              MEM_allocN_len(tree->nodes) +
+              MEM_allocN_len(tree->nodearray) +
+              MEM_allocN_len(tree->nodechild) +
+              MEM_allocN_len(tree->nodebv));
 
 //     bvhtree_print_tree(tree, tree->nodes[tree->totleaf], 0);
 }
@@ -532,10 +526,10 @@ static void verify_tree(BVHTree *tree)
        // check the pointer list
        for (i = 0; i < tree->totleaf; i++)
        {
-               if (tree->nodes[i]->parent == NULL)
+               if (tree->nodes[i]->parent == NULL) {
                        printf("Leaf has no parent: %d\n", i);
-               else
-               {
+               }
+               else {
                        for (j = 0; j < tree->tree_type; j++)
                        {
                                if (tree->nodes[i]->parent->children[j] == tree->nodes[i])
@@ -552,10 +546,10 @@ static void verify_tree(BVHTree *tree)
        // check the leaf list
        for (i = 0; i < tree->totleaf; i++)
        {
-               if (tree->nodearray[i].parent == NULL)
+               if (tree->nodearray[i].parent == NULL) {
                        printf("Leaf has no parent: %d\n", i);
-               else
-               {
+               }
+               else {
                        for (j = 0; j < tree->tree_type; j++)
                        {
                                if (tree->nodearray[i].parent->children[j] == &tree->nodearray[i])
@@ -575,15 +569,14 @@ static void verify_tree(BVHTree *tree)
 
 //Helper data and structures to build a min-leaf generalized implicit tree
 //This code can be easily reduced (basicly this is only method to calculate pow(k, n) in O(1).. and stuff like that)
-typedef struct BVHBuildHelper
-{
-       int tree_type;                          /* */
-       int totleafs;                           /* */
+typedef struct BVHBuildHelper {
+       int tree_type;              /* */
+       int totleafs;               /* */
 
-       int leafs_per_child[32];        /* Min number of leafs that are archievable from a node at depth N */
-       int branches_on_level[32];      /* Number of nodes at depth N (tree_type^N) */
+       int leafs_per_child[32];    /* Min number of leafs that are archievable from a node at depth N */
+       int branches_on_level[32];  /* Number of nodes at depth N (tree_type^N) */
 
-       int remain_leafs;                       /* Number of leafs that are placed on the level that is not 100% filled */
+       int remain_leafs;           /* Number of leafs that are placed on the level that is not 100% filled */
 
 } BVHBuildHelper;
 
@@ -594,7 +587,7 @@ static void build_implicit_tree_helper(BVHTree *tree, BVHBuildHelper *data)
        int nnodes;
 
        data->totleafs = tree->totleaf;
-       data->tree_type= tree->tree_type;
+       data->tree_type = tree->tree_type;
 
        //Calculate the smallest tree_type^n such that tree_type^n >= num_leafs
        for (data->leafs_per_child[0] = 1;
@@ -608,8 +601,8 @@ static void build_implicit_tree_helper(BVHTree *tree, BVHBuildHelper *data)
 
        //We could stop the loop first (but I am lazy to find out when)
        for (depth = 1; depth < 32; depth++) {
-               data->branches_on_level[depth] = data->branches_on_level[depth-1] * data->tree_type;
-               data->leafs_per_child  [depth] = data->leafs_per_child  [depth-1] / data->tree_type;
+               data->branches_on_level[depth] = data->branches_on_level[depth - 1] * data->tree_type;
+               data->leafs_per_child[depth] = data->leafs_per_child[depth - 1] / data->tree_type;
        }
 
        remain = data->totleafs - data->leafs_per_child[1];
@@ -620,11 +613,11 @@ static void build_implicit_tree_helper(BVHTree *tree, BVHBuildHelper *data)
 // return the min index of all the leafs archivable with the given branch
 static int implicit_leafs_index(BVHBuildHelper *data, int depth, int child_index)
 {
-       int min_leaf_index = child_index * data->leafs_per_child[depth-1];
+       int min_leaf_index = child_index * data->leafs_per_child[depth - 1];
        if (min_leaf_index <= data->remain_leafs)
                return min_leaf_index;
        else if (data->leafs_per_child[depth])
-               return data->totleafs - (data->branches_on_level[depth-1] - child_index) * data->leafs_per_child[depth];
+               return data->totleafs - (data->branches_on_level[depth - 1] - child_index) * data->leafs_per_child[depth];
        else
                return data->remain_leafs;
 }
@@ -660,7 +653,7 @@ static int implicit_leafs_index(BVHBuildHelper *data, int depth, int child_index
 // This functions returns the number of branches needed to have the requested number of leafs.
 static int implicit_needed_branches(int tree_type, int leafs)
 {
-       return MAX2(1, (leafs + tree_type - 3) / (tree_type-1) );
+       return MAX2(1, (leafs + tree_type - 3) / (tree_type - 1) );
 }
 
 /*
@@ -678,11 +671,11 @@ static int implicit_needed_branches(int tree_type, int leafs)
 static void split_leafs(BVHNode **leafs_array, int *nth, int partitions, int split_axis)
 {
        int i;
-       for (i=0; i < partitions-1; i++) {
+       for (i = 0; i < partitions - 1; i++) {
                if (nth[i] >= nth[partitions])
                        break;
 
-               partition_nth_element(leafs_array, nth[i], nth[partitions], nth[i+1], split_axis);
+               partition_nth_element(leafs_array, nth[i], nth[partitions], nth[i + 1], split_axis);
        }
 }
 
@@ -708,19 +701,19 @@ static void non_recursive_bvh_div_nodes(BVHTree *tree, BVHNode *branches_array,
 
        const int tree_type   = tree->tree_type;
        const int tree_offset = 2 - tree->tree_type; //this value is 0 (on binary trees) and negative on the others
-       const int num_branches= implicit_needed_branches(tree_type, num_leafs);
+       const int num_branches = implicit_needed_branches(tree_type, num_leafs);
 
        BVHBuildHelper data;
        int depth;
        
        // set parent from root node to NULL
-       BVHNode *tmp = branches_array+0;
+       BVHNode *tmp = branches_array + 0;
        tmp->parent = NULL;
 
        //Most of bvhtree code relies on 1-leaf trees having at least one branch
        //We handle that special case here
        if (num_leafs == 1) {
-               BVHNode *root = branches_array+0;
+               BVHNode *root = branches_array + 0;
                refit_kdop_hull(tree, root, 0, num_leafs);
                root->main_axis = get_largest_axis(root->bv) / 2;
                root->totnode = 1;
@@ -729,27 +722,27 @@ static void non_recursive_bvh_div_nodes(BVHTree *tree, BVHNode *branches_array,
                return;
        }
 
-       branches_array--;       //Implicit trees use 1-based indexs
+       branches_array--;   //Implicit trees use 1-based indexs
        
        build_implicit_tree_helper(tree, &data);
 
        //Loop tree levels (log N) loops
-       for (i=1, depth = 1; i <= num_branches; i = i*tree_type + tree_offset, depth++) {
-               const int first_of_next_level = i*tree_type + tree_offset;
-               const int  end_j = MIN2(first_of_next_level, num_branches + 1); //index of last branch on this level
+       for (i = 1, depth = 1; i <= num_branches; i = i * tree_type + tree_offset, depth++) {
+               const int first_of_next_level = i * tree_type + tree_offset;
+               const int end_j = MIN2(first_of_next_level, num_branches + 1);  //index of last branch on this level
                int j;
 
                //Loop all branches on this level
 #pragma omp parallel for private(j) schedule(static)
                for (j = i; j < end_j; j++) {
                        int k;
-                       const int parent_level_index= j-i;
-                       BVHNodeparent = branches_array + j;
-                       int nth_positions[ MAX_TREETYPE + 1];
+                       const int parent_level_index = j - i;
+                       BVHNode *parent = branches_array + j;
+                       int nth_positions[MAX_TREETYPE + 1];
                        char split_axis;
 
                        int parent_leafs_begin = implicit_leafs_index(&data, depth, parent_level_index);
-                       int parent_leafs_end   = implicit_leafs_index(&data, depth, parent_level_index+1);
+                       int parent_leafs_end   = implicit_leafs_index(&data, depth, parent_level_index + 1);
 
                        //This calculates the bounding box of this branch
                        //and chooses the largest axis as the axis to divide leafs
@@ -763,12 +756,12 @@ static void non_recursive_bvh_div_nodes(BVHTree *tree, BVHNode *branches_array,
                        //Only to assure that the elements are partioned on a way that each child takes the elements
                        //it would take in case the whole array was sorted.
                        //Split_leafs takes care of that "sort" problem.
-                       nth_positions[        0] = parent_leafs_begin;
+                       nth_positions[0] = parent_leafs_begin;
                        nth_positions[tree_type] = parent_leafs_end;
                        for (k = 1; k < tree_type; k++) {
                                int child_index = j * tree_type + tree_offset + k;
                                int child_level_index = child_index - first_of_next_level; //child level index
-                               nth_positions[k] = implicit_leafs_index(&data, depth+1, child_level_index);
+                               nth_positions[k] = implicit_leafs_index(&data, depth + 1, child_level_index);
                        }
 
                        split_leafs(leafs_array, nth_positions, tree_type, split_axis);
@@ -780,22 +773,22 @@ static void non_recursive_bvh_div_nodes(BVHTree *tree, BVHNode *branches_array,
                                int child_index = j * tree_type + tree_offset + k;
                                int child_level_index = child_index - first_of_next_level; //child level index
 
-                               int child_leafs_begin = implicit_leafs_index(&data, depth+1, child_level_index);
-                               int child_leafs_end   = implicit_leafs_index(&data, depth+1, child_level_index+1);
+                               int child_leafs_begin = implicit_leafs_index(&data, depth + 1, child_level_index);
+                               int child_leafs_end   = implicit_leafs_index(&data, depth + 1, child_level_index + 1);
 
                                if (child_leafs_end - child_leafs_begin > 1) {
                                        parent->children[k] = branches_array + child_index;
                                        parent->children[k]->parent = parent;
                                }
                                else if (child_leafs_end - child_leafs_begin == 1) {
-                                       parent->children[k] = leafs_array[ child_leafs_begin ];
+                                       parent->children[k] = leafs_array[child_leafs_begin];
                                        parent->children[k]->parent = parent;
                                }
                                else {
                                        break;
                                }
 
-                               parent->totnode = k+1;
+                               parent->totnode = k + 1;
                        }
                }
        }
@@ -858,27 +851,27 @@ BVHTree *BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis)
                //Allocate arrays
                numnodes = maxsize + implicit_needed_branches(tree_type, maxsize) + tree_type;
 
-               tree->nodes = (BVHNode **)MEM_callocN(sizeof(BVHNode *)*numnodes, "BVHNodes");
+               tree->nodes = (BVHNode **)MEM_callocN(sizeof(BVHNode *) * numnodes, "BVHNodes");
                
                if (!tree->nodes) {
                        MEM_freeN(tree);
                        return NULL;
                }
                
-               tree->nodebv = (float*)MEM_callocN(sizeof(float)* axis * numnodes, "BVHNodeBV");
+               tree->nodebv = (float *)MEM_callocN(sizeof(float) * axis * numnodes, "BVHNodeBV");
                if (!tree->nodebv) {
                        MEM_freeN(tree->nodes);
                        MEM_freeN(tree);
                }
 
-               tree->nodechild = (BVHNode**)MEM_callocN(sizeof(BVHNode*) * tree_type * numnodes, "BVHNodeBV");
+               tree->nodechild = (BVHNode **)MEM_callocN(sizeof(BVHNode *) * tree_type * numnodes, "BVHNodeBV");
                if (!tree->nodechild) {
                        MEM_freeN(tree->nodebv);
                        MEM_freeN(tree->nodes);
                        MEM_freeN(tree);
                }
 
-               tree->nodearray = (BVHNode *)MEM_callocN(sizeof(BVHNode)* numnodes, "BVHNodeArray");
+               tree->nodearray = (BVHNode *)MEM_callocN(sizeof(BVHNode) * numnodes, "BVHNodeArray");
                
                if (!tree->nodearray) {
                        MEM_freeN(tree->nodechild);
@@ -889,7 +882,7 @@ BVHTree *BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis)
                }
 
                //link the dynamic bv and child links
-               for (i=0; i< numnodes; i++) {
+               for (i = 0; i < numnodes; i++) {
                        tree->nodearray[i].bv = tree->nodebv + i * axis;
                        tree->nodearray[i].children = tree->nodechild + i * tree_type;
                }
@@ -914,8 +907,8 @@ void BLI_bvhtree_balance(BVHTree *tree)
 {
        int i;
 
-       BVHNode*  branches_array = tree->nodearray + tree->totleaf;
-       BVHNode** leafs_array    = tree->nodes;
+       BVHNode *branches_array = tree->nodearray + tree->totleaf;
+       BVHNode **leafs_array    = tree->nodes;
 
        //This function should only be called once (some big bug goes here if its being called more than once per tree)
        assert(tree->totbranch == 0);
@@ -942,7 +935,7 @@ int BLI_bvhtree_insert(BVHTree *tree, int index, const float *co, int numpoints)
        if (tree->totbranch > 0)
                return 0;
        
-       if (tree->totleaf+1 >= MEM_allocN_len(tree->nodes)/sizeof(*(tree->nodes)))
+       if (tree->totleaf + 1 >= MEM_allocN_len(tree->nodes) / sizeof(*(tree->nodes)))
                return 0;
        
        // TODO check if have enough nodes in array
@@ -951,7 +944,7 @@ int BLI_bvhtree_insert(BVHTree *tree, int index, const float *co, int numpoints)
        tree->totleaf++;
        
        create_kdop_hull(tree, node, co, numpoints, 0);
-       node->index= index;
+       node->index = index;
        
        // inflate the bv with some epsilon
        for (i = tree->start_axis; i < tree->stop_axis; i++) {
@@ -967,7 +960,7 @@ int BLI_bvhtree_insert(BVHTree *tree, int index, const float *co, int numpoints)
 int BLI_bvhtree_update_node(BVHTree *tree, int index, const float *co, const float *co_moving, int numpoints)
 {
        int i;
-       BVHNode *node= NULL;
+       BVHNode *node = NULL;
        
        // check if index exists
        if (index > tree->totleaf)
@@ -996,8 +989,8 @@ void BLI_bvhtree_update_tree(BVHTree *tree)
        //TRICKY: the way we build the tree all the childs have an index greater than the parent
        //This allows us todo a bottom up update by starting on the biger numbered branch
 
-       BVHNode** root  = tree->nodes + tree->totleaf;
-       BVHNode** index = tree->nodes + tree->totleaf + tree->totbranch-1;
+       BVHNode **root  = tree->nodes + tree->totleaf;
+       BVHNode **index = tree->nodes + tree->totleaf + tree->totbranch - 1;
 
        for (; index >= root; index--)
                node_join(tree, *index);
@@ -1018,13 +1011,13 @@ static int tree_overlap(BVHNode *node1, BVHNode *node2, int start_axis, int stop
        float *bv1 = node1->bv;
        float *bv2 = node2->bv;
 
-       float *bv1_end = bv1 + (stop_axis<<1);
+       float *bv1_end = bv1 + (stop_axis << 1);
                
-       bv1 += start_axis<<1;
-       bv2 += start_axis<<1;
+       bv1 += start_axis << 1;
+       bv2 += start_axis << 1;
        
        // test all axis if min + max overlap
-       for (; bv1 != bv1_end; bv1+=2, bv2+=2) {
+       for (; bv1 != bv1_end; bv1 += 2, bv2 += 2) {
                if ((*(bv1) > *(bv2 + 1)) || (*(bv2) > *(bv1 + 1))) 
                        return 0;
        }
@@ -1048,7 +1041,7 @@ static void traverse(BVHOverlapData *data, BVHNode *node1, BVHNode *node2)
                                        
                                if (data->i >= data->max_overlap) {
                                        // try to make alloc'ed memory bigger
-                                       data->overlap = realloc(data->overlap, sizeof(BVHTreeOverlap)*data->max_overlap*2);
+                                       data->overlap = realloc(data->overlap, sizeof(BVHTreeOverlap) * data->max_overlap * 2);
                                        
                                        if (!data->overlap) {
                                                printf("Out of Memory in traverse\n");
@@ -1095,19 +1088,19 @@ BVHTreeOverlap *BLI_bvhtree_overlap(BVHTree *tree1, BVHTree *tree2, unsigned int
        if (!tree_overlap(tree1->nodes[tree1->totleaf], tree2->nodes[tree2->totleaf], MIN2(tree1->start_axis, tree2->start_axis), MIN2(tree1->stop_axis, tree2->stop_axis)))
                return NULL;
 
-       data = MEM_callocN(sizeof(BVHOverlapData *)* tree1->tree_type, "BVHOverlapData_star");
+       data = MEM_callocN(sizeof(BVHOverlapData *) * tree1->tree_type, "BVHOverlapData_star");
        
        for (j = 0; j < tree1->tree_type; j++) {
                data[j] = (BVHOverlapData *)MEM_callocN(sizeof(BVHOverlapData), "BVHOverlapData");
                
                // init BVHOverlapData
-               data[j]->overlap = (BVHTreeOverlap *)malloc(sizeof(BVHTreeOverlap)*MAX2(tree1->totleaf, tree2->totleaf));
+               data[j]->overlap = (BVHTreeOverlap *)malloc(sizeof(BVHTreeOverlap) * MAX2(tree1->totleaf, tree2->totleaf));
                data[j]->tree1 = tree1;
                data[j]->tree2 = tree2;
                data[j]->max_overlap = MAX2(tree1->totleaf, tree2->totleaf);
                data[j]->i = 0;
                data[j]->start_axis = MIN2(tree1->start_axis, tree2->start_axis);
-               data[j]->stop_axis  = MIN2(tree1->stop_axis,  tree2->stop_axis );
+               data[j]->stop_axis  = MIN2(tree1->stop_axis,  tree2->stop_axis);
        }
 
 #pragma omp parallel for private(j) schedule(static)
@@ -1118,11 +1111,11 @@ BVHTreeOverlap *BLI_bvhtree_overlap(BVHTree *tree1, BVHTree *tree2, unsigned int
        for (j = 0; j < tree1->tree_type; j++)
                total += data[j]->i;
        
-       to = overlap = (BVHTreeOverlap *)MEM_callocN(sizeof(BVHTreeOverlap)*total, "BVHTreeOverlap");
+       to = overlap = (BVHTreeOverlap *)MEM_callocN(sizeof(BVHTreeOverlap) * total, "BVHTreeOverlap");
        
        for (j = 0; j < tree1->tree_type; j++) {
-               memcpy(to, data[j]->overlap, data[j]->i*sizeof(BVHTreeOverlap));
-               to+=data[j]->i;
+               memcpy(to, data[j]->overlap, data[j]->i * sizeof(BVHTreeOverlap));
+               to += data[j]->i;
        }
        
        for (j = 0; j < tree1->tree_type; j++) {
@@ -1142,7 +1135,7 @@ static float calc_nearest_point(const float proj[3], BVHNode *node, float *neare
        const float *bv = node->bv;
 
        //nearest on AABB hull
-       for (i=0; i != 3; i++, bv += 2) {
+       for (i = 0; i != 3; i++, bv += 2) {
                if (bv[0] > proj[i])
                        nearest[i] = bv[0];
                else if (bv[1] < proj[i])
@@ -1154,9 +1147,9 @@ static float calc_nearest_point(const float proj[3], BVHNode *node, float *neare
 #if 0
        //nearest on a general hull
        copy_v3_v3(nearest, data->co);
-       for (i = data->tree->start_axis; i != data->tree->stop_axis; i++, bv+=2)
+       for (i = data->tree->start_axis; i != data->tree->stop_axis; i++, bv += 2)
        {
-               float proj = dot_v3v3( nearest, KDOP_AXES[i]);
+               float proj = dot_v3v3(nearest, KDOP_AXES[i]);
                float dl = bv[0] - proj;
                float du = bv[1] - proj;
 
@@ -1173,14 +1166,13 @@ static float calc_nearest_point(const float proj[3], BVHNode *node, float *neare
 }
 
 
-typedef struct NodeDistance
-{
+typedef struct NodeDistance {
        BVHNode *node;
        float dist;
 
 } NodeDistance;
 
-#define NodeDistance_priority(a, b)    ( (a).dist < (b).dist )
+#define NodeDistance_priority(a, b) ( (a).dist < (b).dist)
 
 // TODO: use a priority queue to reduce the number of nodes looked on
 static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
@@ -1189,8 +1181,8 @@ static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
                if (data->callback)
                        data->callback(data->userdata, node->index, data->co, &data->nearest);
                else {
-                       data->nearest.index     = node->index;
-                       data->nearest.dist      = calc_nearest_point(data->proj, node, data->nearest.co);
+                       data->nearest.index = node->index;
+                       data->nearest.dist  = calc_nearest_point(data->proj, node, data->nearest.co);
                }
        }
        else {
@@ -1198,16 +1190,16 @@ static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
                int i;
                float nearest[3];
 
-               if (data->proj[ node->main_axis ] <= node->children[0]->bv[node->main_axis*2+1]) {
+               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(data->proj, node->children[i], nearest) >= data->nearest.dist) continue;
+                       for (i = 0; i != node->totnode; i++) {
+                               if (calc_nearest_point(data->proj, node->children[i], nearest) >= data->nearest.dist) continue;
                                dfs_find_nearest_dfs(data, node->children[i]);
                        }
                }
                else {
-                       for (i=node->totnode-1; i >= 0 ; i--) {
-                               if ( calc_nearest_point(data->proj, node->children[i], nearest) >= data->nearest.dist) continue;
+                       for (i = node->totnode - 1; i >= 0; i--) {
+                               if (calc_nearest_point(data->proj, node->children[i], nearest) >= data->nearest.dist) continue;
                                dfs_find_nearest_dfs(data, node->children[i]);
                        }
                }
@@ -1242,8 +1234,8 @@ static void bfs_find_nearest(BVHNearestData *data, BVHNode *node)
 {
        int i;
        NodeDistance default_heap[DEFAULT_FIND_NEAREST_HEAP_SIZE];
-       NodeDistance *heap=default_heap, current;
-       int heap_size = 0, max_heap_size = sizeof(default_heap)/sizeof(default_heap[0]);
+       NodeDistance *heap = default_heap, current;
+       int heap_size = 0, max_heap_size = sizeof(default_heap) / sizeof(default_heap[0]);
        float nearest[3];
 
        int callbacks = 0, push_heaps = 0;
@@ -1260,7 +1252,7 @@ static void bfs_find_nearest(BVHNearestData *data, BVHNode *node)
        while (current.dist < data->nearest.dist)
        {
 //             printf("%f : %f\n", current.dist, data->nearest.dist);
-               for (i=0; i< current.node->totnode; i++)
+               for (i = 0; i < current.node->totnode; i++)
                {
                        BVHNode *child = current.node->children[i];
                        if (child->totnode == 0)
@@ -1268,11 +1260,10 @@ static void bfs_find_nearest(BVHNearestData *data, BVHNode *node)
                                callbacks++;
                                dfs_find_nearest_dfs(data, child);
                        }
-                       else
-                       {
+                       else {
                                //adjust heap size
                                if ((heap_size >= max_heap_size) &&
-                                   ADJUST_MEMORY(default_heap, (void**)&heap, heap_size+1, &max_heap_size, sizeof(heap[0])) == FALSE)
+                                   ADJUST_MEMORY(default_heap, (void **)&heap, heap_size + 1, &max_heap_size, sizeof(heap[0])) == FALSE)
                                {
                                        printf("WARNING: bvh_find_nearest got out of memory\n");
 
@@ -1289,7 +1280,7 @@ static void bfs_find_nearest(BVHNearestData *data, BVHNode *node)
                                heap_size++;
 
                                NodeDistance_push_heap(heap, heap_size);
-       //                      PUSH_HEAP_BODY(NodeDistance, NodeDistance_priority, heap, heap_size);
+                               //                      PUSH_HEAP_BODY(NodeDistance, NodeDistance_priority, heap, heap_size);
                                push_heaps++;
                        }
                }
@@ -1315,7 +1306,7 @@ int BLI_bvhtree_find_nearest(BVHTree *tree, const float co[3], BVHTreeNearest *n
        int i;
 
        BVHNearestData data;
-       BVHNoderoot = tree->nodes[tree->totleaf];
+       BVHNode *root = tree->nodes[tree->totleaf];
 
        //init data to search
        data.tree = tree;
@@ -1363,7 +1354,7 @@ static float ray_nearest_hit(BVHRayCastData *data, float *bv)
 
        float low = 0, upper = data->hit.dist;
 
-       for (i=0; i != 3; i++, bv += 2) {
+       for (i = 0; i != 3; i++, bv += 2) {
                if (data->ray_dot_axis[i] == 0.0f) {
                        //axis aligned ray
                        if (data->ray.origin[i] < bv[0] - data->ray.radius ||
@@ -1377,11 +1368,11 @@ static float ray_nearest_hit(BVHRayCastData *data, float *bv)
                        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 (ll > low) low = ll;
                                if (lu < upper) upper = lu;
                        }
                        else {
-                               if (lu > low)   low = lu;
+                               if (lu > low) low = lu;
                                if (ll < upper) upper = ll;
                        }
        
@@ -1433,20 +1424,20 @@ static void dfs_raycast(BVHRayCastData *data, BVHNode *node)
                        data->callback(data->userdata, node->index, &data->ray, &data->hit);
                }
                else {
-                       data->hit.index = node->index;
+                       data->hit.index = node->index;
                        data->hit.dist  = dist;
                        madd_v3_v3v3fl(data->hit.co, data->ray.origin, data->ray.direction, dist);
                }
        }
        else {
                //pick loop direction to dive into the tree (based on ray direction and split axis)
-               if (data->ray_dot_axis[ (int)node->main_axis ] > 0.0f) {
-                       for (i=0; i != node->totnode; i++) {
+               if (data->ray_dot_axis[(int)node->main_axis] > 0.0f) {
+                       for (i = 0; i != node->totnode; i++) {
                                dfs_raycast(data, node->children[i]);
                        }
                }
                else {
-                       for (i=node->totnode-1; i >= 0; i--) {
+                       for (i = node->totnode - 1; i >= 0; i--) {
                                dfs_raycast(data, node->children[i]);
                        }
                }
@@ -1467,19 +1458,18 @@ static void iterative_raycast(BVHRayCastData *data, BVHNode *node)
 
                if (node->totnode == 0)
                {
-                       if (data->callback)
+                       if (data->callback) {
                                data->callback(data->userdata, node->index, &data->ray, &data->hit);
-                       else
-                       {
-                               data->hit.index = node->index;
+                       }
+                       else {
+                               data->hit.index = node->index;
                                data->hit.dist  = dist;
                                madd_v3_v3v3fl(data->hit.co, data->ray.origin, data->ray.direction, dist);
                        }
                        
                        node = node->skip[1];
                }
-               else
-               {
+               else {
                        node = node->children[0];
                }       
        }
@@ -1490,7 +1480,7 @@ int BLI_bvhtree_ray_cast(BVHTree *tree, const float co[3], const float dir[3], f
 {
        int i;
        BVHRayCastData data;
-       BVHNode * root = tree->nodes[tree->totleaf];
+       BVHNode *root = tree->nodes[tree->totleaf];
 
        data.tree = tree;
 
@@ -1503,17 +1493,17 @@ int BLI_bvhtree_ray_cast(BVHTree *tree, const float co[3], const float dir[3], f
 
        normalize_v3(data.ray.direction);
 
-       for (i=0; i<3; i++) {
+       for (i = 0; i < 3; i++) {
                data.ray_dot_axis[i] = dot_v3v3(data.ray.direction, KDOP_AXES[i]);
                data.idot_axis[i] = 1.0f / data.ray_dot_axis[i];
 
                if (fabsf(data.ray_dot_axis[i]) < FLT_EPSILON) {
                        data.ray_dot_axis[i] = 0.0;
                }
-               data.index[2*i] = data.idot_axis[i] < 0.0f ? 1 : 0;
-               data.index[2*i+1] = 1 - data.index[2*i];
-               data.index[2*i]   += 2*i;
-               data.index[2*i+1] += 2*i;
+               data.index[2 * i] = data.idot_axis[i] < 0.0f ? 1 : 0;
+               data.index[2 * i + 1] = 1 - data.index[2 * i];
+               data.index[2 * i]   += 2 * i;
+               data.index[2 * i + 1] += 2 * i;
        }
 
 
@@ -1527,7 +1517,7 @@ int BLI_bvhtree_ray_cast(BVHTree *tree, const float co[3], const float dir[3], f
        if (root) {
                dfs_raycast(&data, root);
 //             iterative_raycast(&data, root);
-        }
+       }
 
 
        if (hit)
@@ -1572,11 +1562,10 @@ float BLI_bvhtree_bb_raycast(float *bv, const float light_start[3], const float
  * Allocs and fills an array with the indexs of node that are on the given spherical range (center, radius) 
  * Returns the size of the array.
  */
-typedef struct RangeQueryData
-{
+typedef struct RangeQueryData {
        BVHTree *tree;
        const float *center;
-       float radius;                   //squared radius
+       float radius;           //squared radius
 
        int hits;
 
@@ -1590,7 +1579,7 @@ typedef struct RangeQueryData
 static void dfs_range_query(RangeQueryData *data, BVHNode *node)
 {
        if (node->totnode == 0) {
-#if 0  /*UNUSED*/
+#if 0   /*UNUSED*/
                //Calculate the node min-coords (if the node was a point then this is the point coordinates)
                float co[3];
                co[0] = node->bv[0];
@@ -1600,7 +1589,7 @@ static void dfs_range_query(RangeQueryData *data, BVHNode *node)
        }
        else {
                int i;
-               for (i=0; i != node->totnode; i++) {
+               for (i = 0; i != node->totnode; i++) {
                        float nearest[3];
                        float dist = calc_nearest_point(data->center, node->children[i], nearest);
                        if (dist < data->radius) {
@@ -1618,12 +1607,12 @@ static void dfs_range_query(RangeQueryData *data, BVHNode *node)
 
 int BLI_bvhtree_range_query(BVHTree *tree, const float co[3], float radius, BVHTree_RangeQuery callback, void *userdata)
 {
-       BVHNode * root = tree->nodes[tree->totleaf];
+       BVHNode *root = tree->nodes[tree->totleaf];
 
        RangeQueryData data;
        data.tree = tree;
        data.center = co;
-       data.radius = radius*radius;
+       data.radius = radius * radius;
        data.hits = 0;
 
        data.callback = callback;
index a518d14..4878c0f 100644 (file)
@@ -38,7 +38,7 @@
 #include "BLI_kdtree.h"
 
 #ifndef SWAP
-#define SWAP(type, a, b) { type sw_ap; sw_ap=(a); (a)=(b); (b)=sw_ap; }
+#  define SWAP(type, a, b) { type sw_ap; sw_ap = (a); (a) = (b); (b) = sw_ap; }
 #endif
 
 typedef struct KDTreeNode {
@@ -58,9 +58,9 @@ KDTree *BLI_kdtree_new(int maxsize)
 {
        KDTree *tree;
 
-       tree= MEM_callocN(sizeof(KDTree), "KDTree");
-       tree->nodes= MEM_callocN(sizeof(KDTreeNode)*maxsize, "KDTreeNode");
-       tree->totnode= 0;
+       tree = MEM_callocN(sizeof(KDTree), "KDTree");
+       tree->nodes = MEM_callocN(sizeof(KDTreeNode) * maxsize, "KDTreeNode");
+       tree->totnode = 0;
 
        return tree;
 }
@@ -75,9 +75,9 @@ void BLI_kdtree_free(KDTree *tree)
 
 void BLI_kdtree_insert(KDTree *tree, int index, float *co, float *nor)
 {
-       KDTreeNode *node= &tree->nodes[tree->totnode++];
+       KDTreeNode *node = &tree->nodes[tree->totnode++];
 
-       node->index= index;
+       node->index = index;
        copy_v3_v3(node->co, co);
        if (nor) copy_v3_v3(node->nor, nor);
 }
@@ -94,18 +94,18 @@ static KDTreeNode *kdtree_balance(KDTreeNode *nodes, int totnode, int axis)
                return nodes;
        
        /* quicksort style sorting around median */
-       left= 0;
-       right= totnode-1;
-       median= totnode/2;
+       left = 0;
+       right = totnode - 1;
+       median = totnode / 2;
 
        while (right > left) {
-               co= nodes[right].co[axis];
-               i= left-1;
-               j= right;
+               co = nodes[right].co[axis];
+               i = left - 1;
+               j = right;
 
                while (1) {
-                       while (nodes[++i].co[axis] < co);
-                       while (nodes[--j].co[axis] > co && j>left);
+                       while (nodes[++i].co[axis] < co) ;
+                       while (nodes[--j].co[axis] > co && j > left) ;
 
                        if (i >= j) break;
                        SWAP(KDTreeNode, nodes[i], nodes[j]);
@@ -113,32 +113,32 @@ static KDTreeNode *kdtree_balance(KDTreeNode *nodes, int totnode, int axis)
 
                SWAP(KDTreeNode, nodes[i], nodes[right]);
                if (i >= median)
-                       right= i-1;
+                       right = i - 1;
                if (i <= median)
-                       left= i+1;
+                       left = i + 1;
        }
 
        /* set node and sort subnodes */
-       node= &nodes[median];
-       node->d= axis;
-       node->left= kdtree_balance(nodes, median, (axis+1)%3);
-       node->right= kdtree_balance(nodes+median+1, (totnode-(median+1)), (axis+1)%3);
+       node = &nodes[median];
+       node->d = axis;
+       node->left = kdtree_balance(nodes, median, (axis + 1) % 3);
+       node->right = kdtree_balance(nodes + median + 1, (totnode - (median + 1)), (axis + 1) % 3);
 
        return node;
 }
 
 void BLI_kdtree_balance(KDTree *tree)
 {
-       tree->root= kdtree_balance(tree->nodes, tree->totnode, 0);
+       tree->root = kdtree_balance(tree->nodes, tree->totnode, 0);
 }
 
 static float squared_distance(const float v2[3], const float v1[3], float *UNUSED(n1), float *n2)
 {
        float d[3], dist;
 
-       d[0]= v2[0]-v1[0];
-       d[1]= v2[1]-v1[1];
-       d[2]= v2[2]-v1[2];
+       d[0] = v2[0] - v1[0];
+       d[1] = v2[1] - v1[1];
+       d[2] = v2[2] - v1[2];
 
        dist = dot_v3v3(d, d);
 
@@ -152,84 +152,84 @@ static float squared_distance(const float v2[3], const float v1[3], float *UNUSE
        return dist;
 }
 
-int    BLI_kdtree_find_nearest(KDTree *tree, float *co, float *nor, KDTreeNearest *nearest)
+int BLI_kdtree_find_nearest(KDTree *tree, float *co, float *nor, KDTreeNearest *nearest)
 {
        KDTreeNode *root, *node, *min_node;
        KDTreeNode **stack, *defaultstack[100];
        float min_dist, cur_dist;
-       int totstack, cur=0;
+       int totstack, cur = 0;
 
        if (!tree->root)
                return -1;
 
-       stack= defaultstack;
-       totstack= 100;
+       stack = defaultstack;
+       totstack = 100;
 
-       root= tree->root;
-       min_node= root;
-       min_dist= squared_distance(root->co, co, root->nor, nor);
+       root = tree->root;
+       min_node = root;
+       min_dist = squared_distance(root->co, co, root->nor, nor);
 
        if (co[root->d] < root->co[root->d]) {
                if (root->right)
-                       stack[cur++]=root->right;
+                       stack[cur++] = root->right;
                if (root->left)
-                       stack[cur++]=root->left;
+                       stack[cur++] = root->left;
        }
        else {
                if (root->left)
-                       stack[cur++]=root->left;
+                       stack[cur++] = root->left;
                if (root->right)
-                       stack[cur++]=root->right;
+                       stack[cur++] = root->right;
        }
        
        while (cur--) {
-               node=stack[cur];
+               node = stack[cur];
 
                cur_dist = node->co[node->d] - co[node->d];
 
-               if (cur_dist<0.0f) {
-                       cur_dist= -cur_dist*cur_dist;
+               if (cur_dist < 0.0f) {
+                       cur_dist = -cur_dist * cur_dist;
 
-                       if (-cur_dist<min_dist) {
-                               cur_dist=squared_distance(node->co, co, node->nor, nor);
-                               if (cur_dist<min_dist) {
-                                       min_dist=cur_dist;
-                                       min_node=node;
+                       if (-cur_dist < min_dist) {
+                               cur_dist = squared_distance(node->co, co, node->nor, nor);
+                               if (cur_dist < min_dist) {
+                                       min_dist = cur_dist;
+                                       min_node = node;
                                }
                                if (node->left)
-                                       stack[cur++]=node->left;
+                                       stack[cur++] = node->left;
                        }
                        if (node->right)
-                               stack[cur++]=node->right;
+                               stack[cur++] = node->right;
                }
                else {
-                       cur_dist= cur_dist*cur_dist;
+                       cur_dist = cur_dist * cur_dist;
 
-                       if (cur_dist<min_dist) {
-                               cur_dist=squared_distance(node->co, co, node->nor, nor);
-                               if (cur_dist<min_dist) {
-                                       min_dist=cur_dist;
-                                       min_node=node;
+                       if (cur_dist < min_dist) {
+                               cur_dist = squared_distance(node->co, co, node->nor, nor);
+                               if (cur_dist < min_dist) {
+                                       min_dist = cur_dist;
+                                       min_node = node;
                                }
                                if (node->right)
-                                       stack[cur++]=node->right;
+                                       stack[cur++] = node->right;
                        }
                        if (node->left)
-                               stack[cur++]=node->left;
+                               stack[cur++] = node->left;
                }
-               if (cur+3 > totstack) {
-                       KDTreeNode **temp=MEM_callocN((totstack+100)*sizeof(KDTreeNode*), "psys_treestack");
-                       memcpy(temp, stack, totstack*sizeof(KDTreeNode*));
+               if (cur + 3 > totstack) {
+                       KDTreeNode **temp = MEM_callocN((totstack + 100) * sizeof(KDTreeNode *), "psys_treestack");
+                       memcpy(temp, stack, totstack * sizeof(KDTreeNode *));
                        if (stack != defaultstack)
                                MEM_freeN(stack);
-                       stack=temp;
-                       totstack+=100;
+                       stack = temp;
+                       totstack += 100;
                }
        }
 
        if (nearest) {
-               nearest->index= min_node->index;
-               nearest->dist= sqrt(min_dist);
+               nearest->index = min_node->index;
+               nearest->dist = sqrt(min_dist);
                copy_v3_v3(nearest->co, min_node->co);
        }
 
@@ -243,98 +243,98 @@ static void add_nearest(KDTreeNearest *ptn, int *found, int n, int index, float
 {
        int i;
 
-       if (*found<n) (*found)++;
+       if (*found < n) (*found)++;
 
-       for (i=*found-1; i>0; i--) {
-               if (dist >= ptn[i-1].dist)
+       for (i = *found - 1; i > 0; i--) {
+               if (dist >= ptn[i - 1].dist)
                        break;
                else
-                       ptn[i]= ptn[i-1];
+                       ptn[i] = ptn[i - 1];
        }
 
-       ptn[i].index= index;
-       ptn[i].dist= dist;
+       ptn[i].index = index;
+       ptn[i].dist = dist;
        copy_v3_v3(ptn[i].co, co);
 }
 
 /* finds the nearest n entries in tree to specified coordinates */
-int    BLI_kdtree_find_n_nearest(KDTree *tree, int n, float *co, float *nor, KDTreeNearest *nearest)
+int BLI_kdtree_find_n_nearest(KDTree *tree, int n, float *co, float *nor, KDTreeNearest *nearest)
 {
-       KDTreeNode *root, *node= NULL;
+       KDTreeNode *root, *node = NULL;
        KDTreeNode **stack, *defaultstack[100];
        float cur_dist;
-       int i, totstack, cur=0, found=0;
+       int i, totstack, cur = 0, found = 0;
 
        if (!tree->root)
                return 0;
 
-       stack= defaultstack;
-       totstack= 100;
+       stack = defaultstack;
+       totstack = 100;
 
-       root= tree->root;
+       root = tree->root;
 
-       cur_dist= squared_distance(root->co, co, root->nor, nor);
+       cur_dist = squared_distance(root->co, co, root->nor, nor);
        add_nearest(nearest, &found, n, root->index, cur_dist, root->co);
        
        if (co[root->d] < root->co[root->d]) {
                if (root->right)
-                       stack[cur++]=root->right;
+                       stack[cur++] = root->right;
                if (root->left)
-                       stack[cur++]=root->left;
+                       stack[cur++] = root->left;
        }
        else {
                if (root->left)
-                       stack[cur++]=root->left;
+                       stack[cur++] = root->left;
                if (root->right)
-                       stack[cur++]=root->right;
+                       stack[cur++] = root->right;
        }
 
        while (cur--) {
-               node=stack[cur];
+               node = stack[cur];
 
                cur_dist = node->co[node->d] - co[node->d];
 
-               if (cur_dist<0.0f) {
-                       cur_dist= -cur_dist*cur_dist;
+               if (cur_dist < 0.0f) {
+                       cur_dist = -cur_dist * cur_dist;
 
-                       if (found<n || -cur_dist<nearest[found-1].dist) {
-                               cur_dist=squared_distance(node->co, co, node->nor, nor);
+                       if (found < n || -cur_dist < nearest[found - 1].dist) {
+                               cur_dist = squared_distance(node->co, co, node->nor, nor);
 
-                               if (found<n || cur_dist<nearest[found-1].dist)
+                               if (found < n || cur_dist < nearest[found - 1].dist)
                                        add_nearest(nearest, &found, n, node->index, cur_dist, node->co);
 
                                if (node->left)
-                                       stack[cur++]=node->left;
+                                       stack[cur++] = node->left;
                        }
                        if (node->right)
-                               stack[cur++]=node->right;
+                               stack[cur++] = node->right;
                }
                else {
-                       cur_dist= cur_dist*cur_dist;
+                       cur_dist = cur_dist * cur_dist;
 
-                       if (found<n || cur_dist<nearest[found-1].dist) {
-                               cur_dist=squared_distance(node->co, co, node->nor, nor);
-                               if (found<n || cur_dist<nearest[found-1].dist)
+                       if (found < n || cur_dist < nearest[found - 1].dist) {
+                               cur_dist = squared_distance(node->co, co, node->nor, nor);
+                               if (found < n || cur_dist < nearest[found - 1].dist)
                                        add_nearest(nearest, &found, n, node->index, cur_dist, node->co);
 
                                if (node->right)
-                                       stack[cur++]=node->right;
+                                       stack[cur++] = node->right;
                        }
                        if (node->left)
-                               stack[cur++]=node->left;
+                               stack[cur++] = node->left;
                }
-               if (cur+3 > totstack) {
-                       KDTreeNode **temp=MEM_callocN((totstack+100)*sizeof(KDTreeNode*), "psys_treestack");
-                       memcpy(temp, stack, totstack * sizeof(KDTreeNode*));
+               if (cur + 3 > totstack) {
+                       KDTreeNode **temp = MEM_callocN((totstack + 100) * sizeof(KDTreeNode *), "psys_treestack");
+                       memcpy(temp, stack, totstack * sizeof(KDTreeNode *));
                        if (stack != defaultstack)
                                MEM_freeN(stack);
-                       stack=temp;
-                       totstack+=100;
+                       stack = temp;
+                       totstack += 100;
                }
        }
 
-       for (i=0; i<found; i++)
-               nearest[i].dist= sqrt(nearest[i].dist);
+       for (i = 0; i < found; i++)
+               nearest[i].dist = sqrt(nearest[i].dist);
 
        if (stack != defaultstack)
                MEM_freeN(stack);
@@ -342,7 +342,7 @@ int BLI_kdtree_find_n_nearest(KDTree *tree, int n, float *co, float *nor, KDTree
        return found;
 }
 
-static int range_compare(const void * a, const void * b)
+static int range_compare(const void *a, const void *b)
 {
        const KDTreeNearest *kda = a;
        const KDTreeNearest *kdb = b;
@@ -358,13 +358,13 @@ static void add_in_range(KDTreeNearest **ptn, int found, int *totfoundstack, int
 {
        KDTreeNearest *to;
 
-       if (found+1 > *totfoundstack) {
-               KDTreeNearest *temp=MEM_callocN((*totfoundstack+50)*sizeof(KDTreeNode), "psys_treefoundstack");
+       if (found + 1 > *totfoundstack) {
+               KDTreeNearest *temp = MEM_callocN((*totfoundstack + 50) * sizeof(KDTreeNode), "psys_treefoundstack");
                memcpy(temp, *ptn, *totfoundstack * sizeof(KDTreeNearest));
                if (*ptn)
                        MEM_freeN(*ptn);
                *ptn = temp;
-               *totfoundstack+=50;
+               *totfoundstack += 50;
        }
 
        to = (*ptn) + found;
@@ -375,27 +375,27 @@ static void add_in_range(KDTreeNearest **ptn, int found, int *totfoundstack, int
 }
 int BLI_kdtree_range_search(KDTree *tree, float range, float *co, float *nor, KDTreeNearest **nearest)
 {
-       KDTreeNode *root, *node= NULL;
+       KDTreeNode *root, *node = NULL;
        KDTreeNode **stack, *defaultstack[100];
-       KDTreeNearest *foundstack=NULL;
-       float range2 = range*range, dist2;
-       int totstack, cur=0, found=0, totfoundstack=0;
+       KDTreeNearest *foundstack = NULL;
+       float range2 = range * range, dist2;
+       int totstack, cur = 0, found = 0, totfoundstack = 0;
 
        if (!tree || !tree->root)
                return 0;
 
-       stack= defaultstack;
-       totstack= 100;
+       stack = defaultstack;
+       totstack = 100;
 
-       root= tree->root;
+       root = tree->root;
 
        if (co[root->d] + range < root->co[root->d]) {
                if (root->left)
-                       stack[cur++]=root->left;
+                       stack[cur++] = root->left;
        }
        else if (co[root->d] - range > root->co[root->d]) {
                if (root->right)
-                       stack[cur++]=root->right;
+                       stack[cur++] = root->right;
        }
        else {
                dist2 = squared_distance(root->co, co, root->nor, nor);
@@ -403,21 +403,21 @@ int BLI_kdtree_range_search(KDTree *tree, float range, float *co, float *nor, KD
                        add_in_range(&foundstack, found++, &totfoundstack, root->index, dist2, root->co);
 
                if (root->left)
-                       stack[cur++]=root->left;
+                       stack[cur++] = root->left;
                if (root->right)
-                       stack[cur++]=root->right;
+                       stack[cur++] = root->right;
        }
 
        while (cur--) {
-               node=stack[cur];
+               node = stack[cur];
 
                if (co[node->d] + range < node->co[node->d]) {
                        if (node->left)
-                               stack[cur++]=node->left;
+                               stack[cur++] = node->left;
                }
                else if (co[node->d] - range > node->co[node->d]) {
                        if (node->right)
-                               stack[cur++]=node->right;
+                               stack[cur++] = node->right;
                }
                else {
                        dist2 = squared_distance(node->co, co, node->nor, nor);
@@ -425,18 +425,18 @@ int BLI_kdtree_range_search(KDTree *tree, float range, float *co, float *nor, KD
                                add_in_range(&foundstack, found++, &totfoundstack, node->index, dist2, node->co);
 
                        if (node->left)
-                               stack[cur++]=node->left;
+                               stack[cur++] = node->left;
                        if (node->right)
-                               stack[cur++]=node->right;
+                               stack[cur++] = node->right;
                }
 
-               if (cur+3 > totstack) {
-                       KDTreeNode **temp=MEM_callocN((totstack+100)*sizeof(KDTreeNode*), "psys_treestack");
-                       memcpy(temp, stack, totstack*sizeof(KDTreeNode*));
+               if (cur + 3 > totstack) {
+                       KDTreeNode **temp = MEM_callocN((totstack + 100) * sizeof(KDTreeNode *), "psys_treestack");
+                       memcpy(temp, stack, totstack * sizeof(KDTreeNode *));
                        if (stack != defaultstack)
                                MEM_freeN(stack);
-                       stack=temp;
-                       totstack+=100;
+                       stack = temp;
+                       totstack += 100;
                }
        }
 
index 5c7d708..0e630ef 100644 (file)
 int BLI_linklist_length(LinkNode *list)
 {
        if (0) {
-               return list?(1+BLI_linklist_length(list->next)):0;
+               return list ? (1 + BLI_linklist_length(list->next)) : 0;
        }
        else {
                int len;
 
-               for (len=0; list; list= list->next)
+               for (len = 0; list; list = list->next)
                        len++;
        
                return len;
@@ -54,7 +54,7 @@ int BLI_linklist_index(LinkNode *list, void *ptr)
 {
        int index;
        
-       for (index = 0; list; list= list->next, index++)
+       for (index = 0; list; list = list->next, index++)
                if (list->link == ptr)
                        return index;
        
@@ -65,7 +65,7 @@ LinkNode *BLI_linklist_find(LinkNode *list, int index)
 {
        int i;
        
-       for (i = 0; list; list= list->next, i++)
+       for (i = 0; list; list = list->next, i++)
                if (i == index)
                        return list;
 
@@ -74,32 +74,32 @@ LinkNode *BLI_linklist_find(LinkNode *list, int index)
 
 void BLI_linklist_reverse(LinkNode **listp)
 {
-       LinkNode *rhead= NULL, *cur= *listp;
+       LinkNode *rhead = NULL, *cur = *listp;
        
        while (cur) {
-               LinkNode *next= cur->next;
+               LinkNode *next = cur->next;
                
-               cur->next= rhead;
-               rhead= cur;
+               cur->next = rhead;
+               rhead = cur;
                
-               cur= next;
+               cur = next;
        }
        
-       *listp= rhead;
+       *listp = rhead;
 }
 
 void BLI_linklist_prepend(LinkNode **listp, void *ptr)
 {
-       LinkNode *nlink= MEM_mallocN(sizeof(*nlink), "nlink");
-       nlink->link= ptr;
+       LinkNode *nlink = MEM_mallocN(sizeof(*nlink), "nlink");
+       nlink->link = ptr;
        
-       nlink->next= *listp;
-       *listp= nlink;
+       nlink->next = *listp;
+       *listp = nlink;
 }
 
 void BLI_linklist_append(LinkNode **listp, void *ptr)
 {
-       LinkNode *nlink= MEM_mallocN(sizeof(*nlink), "nlink");
+       LinkNode *nlink = MEM_mallocN(sizeof(*nlink), "nlink");
        LinkNode *node = *listp;
        
        nlink->link = ptr;
@@ -118,16 +118,16 @@ void BLI_linklist_append(LinkNode **listp, void *ptr)
 
 void BLI_linklist_prepend_arena(LinkNode **listp, void *ptr, MemArena *ma)
 {
-       LinkNode *nlink= BLI_memarena_alloc(ma, sizeof(*nlink));
-       nlink->link= ptr;
+       LinkNode *nlink = BLI_memarena_alloc(ma, sizeof(*nlink));
+       nlink->link = ptr;
        
-       nlink->next= *listp;
-       *listp= nlink;
+       nlink->next = *listp;
+       *listp = nlink;
 }
 
 void BLI_linklist_insert_after(LinkNode **listp, void *ptr)
 {
-       LinkNode *nlink= MEM_mallocN(sizeof(*nlink), "nlink");
+       LinkNode *nlink = MEM_mallocN(sizeof(*nlink), "nlink");
        LinkNode *node = *listp;
 
        nlink->link = ptr;
@@ -145,18 +145,18 @@ void BLI_linklist_insert_after(LinkNode **listp, void *ptr)
 void BLI_linklist_free(LinkNode *list, LinkNodeFreeFP freefunc)
 {
        while (list) {
-               LinkNode *next= list->next;
+               LinkNode *next = list->next;
                
                if (freefunc)
                        freefunc(list->link);
                MEM_freeN(list);
                
-               list= next;
+               list = next;
        }
 }
 
 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 95a007d..8c9993a 100644 (file)
@@ -74,12 +74,12 @@ void BLI_memarena_use_align(struct MemArena *ma, int align)
 
 void BLI_memarena_free(MemArena *ma)
 {
-       BLI_linklist_free(ma->bufs, (void(*)(void *))MEM_freeN);
+       BLI_linklist_free(ma->bufs, (void (*)(void *))MEM_freeN);
        MEM_freeN(ma);
 }
 
 /* amt must be power of two */
-#define PADUP(num, amt)        ((num + (amt - 1)) &~ (amt-1))
+#define PADUP(num, amt) ((num + (amt - 1)) & ~(amt - 1))
 
 void *BLI_memarena_alloc(MemArena *ma, int size)
 {
@@ -93,7 +93,7 @@ void *BLI_memarena_alloc(MemArena *ma, int size)
                unsigned char *tmp;
 
                if (size > ma->bufsize - (ma->align - 1)) {
-                       ma->cursize = PADUP(size+1, ma->align);
+                       ma->cursize = PADUP(size + 1, ma->align);
                }
                else
                        ma->cursize = ma->bufsize;
@@ -106,7 +106,7 @@ void *BLI_memarena_alloc(MemArena *ma, int size)
                BLI_linklist_prepend(&ma->bufs, ma->curbuf);
 
                /* align alloc'ed memory (needed if align > 8) */
-               tmp = (unsigned char*)PADUP( (intptr_t) ma->curbuf, ma->align);
+               tmp = (unsigned char *)PADUP( (intptr_t) ma->curbuf, ma->align);
                ma->cursize -= (tmp - ma->curbuf);
                ma->curbuf = tmp;
        }
index 6398bd8..bed5750 100644 (file)
@@ -37,7 +37,7 @@
 /* Tree API */
 
 /* Create a new tree, and initialize as necessary */
-DLRBT_Tree *BLI_dlrbTree_new (void)
+DLRBT_Tree *BLI_dlrbTree_new(void)
 {
        /* just allocate for now */
        return MEM_callocN(sizeof(DLRBT_Tree), "DLRBT_Tree");
@@ -49,11 +49,11 @@ void BLI_dlrbTree_init(DLRBT_Tree *tree)
        if (tree == NULL)
                return;
                
-       tree->first= tree->last= tree->root= NULL;
+       tree->first = tree->last = tree->root = NULL;
 }
 
 /* Helper for traversing tree and freeing sub-nodes */
-static void recursive_tree_free_nodes (DLRBT_Node *node)
+static void recursive_tree_free_nodes(DLRBT_Node *node)
 {
        /* sanity check */
        if (node == NULL)
@@ -86,13 +86,13 @@ void BLI_dlrbTree_free(DLRBT_Tree *tree)
        }
        
        /* clear pointers */
-       tree->first= tree->last= tree->root= NULL;
+       tree->first = tree->last = tree->root = NULL;
 }
 
 /* ------- */
 
 /* Helper function - used for traversing down the tree from the root to add nodes in order */
-static void linkedlist_sync_add_node (DLRBT_Tree *tree, DLRBT_Node *node)
+static void linkedlist_sync_add_node(DLRBT_Tree *tree, DLRBT_Node *node)
 {
        /* sanity checks */
        if ((tree == NULL) || (node == NULL))
@@ -105,7 +105,7 @@ static void linkedlist_sync_add_node (DLRBT_Tree *tree, DLRBT_Node *node)
         *      - must remove detach from other links first
         *        (for now, only clear own pointers)
         */
-       node->prev= node->next= NULL;
+       node->prev = node->next = NULL;
        BLI_addtail((ListBase *)tree, (Link *)node);
        
        /* finally, add right node (and its subtree) */
@@ -120,7 +120,7 @@ void BLI_dlrbTree_linkedlist_sync(DLRBT_Tree *tree)
                return;
                
        /* clear list-base pointers so that the new list can be added properly */
-       tree->first= tree->last= NULL;
+       tree->first = tree->last = NULL;
        
        /* start adding items from the root */
        linkedlist_sync_add_node(tree, tree->root);
@@ -130,10 +130,10 @@ void BLI_dlrbTree_linkedlist_sync(DLRBT_Tree *tree)
 /* Tree Search Utilities */
 
 /* Find the node which matches or is the closest to the requested node */
-DLRBT_Node *BLI_dlrbTree_search (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
+DLRBT_Node *BLI_dlrbTree_search(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
 {
        DLRBT_Node *node = (tree) ? tree->root : NULL;
-       short found= 0;
+       short found = 0;
        
        /* check that there is a comparator to use */
        // TODO: if no comparator is supplied, try using the one supplied with the tree...
@@ -146,22 +146,22 @@ DLRBT_Node *BLI_dlrbTree_search (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, v
                 * NOTE: it is assumed that the values will be unit values only
                 */
                switch (cmp_cb(node, search_data)) {
-                       case -1:        /* data less than node */
+                       case -1:    /* data less than node */
                                if (node->left)
-                                       node= node->left;
+                                       node = node->left;
                                else
-                                       found= 1;
+                                       found = 1;
                                break;
                        
-                       case 1:         /* data greater than node */
+                       case 1:  /* data greater than node */
                                if (node->right)
-                                       node= node->right;
+                                       node = node->right;
                                else
-                                       found= 1;
+                                       found = 1;
                                break;
                        
-                       default:        /* data equals node */
-                               found= 1;
+                       default:  /* data equals node */
+                               found = 1;
                                break;
                }
        }
@@ -171,10 +171,10 @@ DLRBT_Node *BLI_dlrbTree_search (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, v
 } 
 
 /* Find the node which exactly matches the required data */
-DLRBT_Node *BLI_dlrbTree_search_exact (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
+DLRBT_Node *BLI_dlrbTree_search_exact(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
 {
        DLRBT_Node *node = (tree) ? tree->root : NULL;
-       short found= 0;
+       short found = 0;
        
        /* check that there is a comparator to use */
        // TODO: if no comparator is supplied, try using the one supplied with the tree...
@@ -182,27 +182,27 @@ DLRBT_Node *BLI_dlrbTree_search_exact (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp
                return NULL;
        
        /* iteratively perform this search */
-       while (node && found==0) {
+       while (node && found == 0) {
                /* check if traverse further or not 
                 * NOTE: it is assumed that the values will be unit values only
                 */
                switch (cmp_cb(node, search_data)) {
-                       case -1:        /* data less than node */
+                       case -1:  /* data less than node */
                                if (node->left)
-                                       node= node->left;
+                                       node = node->left;
                                else
-                                       found= -1;
+                                       found = -1;
                                break;
                        
-                       case 1:         /* data greater than node */
+                       case 1:  /* data greater than node */
                                if (node->right)
-                                       node= node->right;
+                                       node = node->right;
                                else
-                                       found= -1;
+                                       found = -1;
                                break;
                        
-                       default:        /* data equals node */
-                               found= 1;
+                       default:  /* data equals node */
+                               found = 1;
                                break;
                }
        }
@@ -212,7 +212,7 @@ DLRBT_Node *BLI_dlrbTree_search_exact (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp
 }
 
 /* Find the node which occurs immediately before the best matching node */
-DLRBT_Node *BLI_dlrbTree_search_prev (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
+DLRBT_Node *BLI_dlrbTree_search_prev(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
 {
        DLRBT_Node *node;
        
@@ -222,7 +222,7 @@ DLRBT_Node *BLI_dlrbTree_search_prev (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_
                return NULL;
        
        /* get the node which best matches this description */
-       node= BLI_dlrbTree_search(tree, cmp_cb, search_data);
+       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 */
@@ -239,7 +239,7 @@ DLRBT_Node *BLI_dlrbTree_search_prev (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_
 }
 
 /* Find the node which occurs immediately after the best matching node */
-DLRBT_Node *BLI_dlrbTree_search_next (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
+DLRBT_Node *BLI_dlrbTree_search_next(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
 {
        DLRBT_Node *node;
        
@@ -249,7 +249,7 @@ DLRBT_Node *BLI_dlrbTree_search_next (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_
                return NULL;
        
        /* get the node which best matches this description */
-       node= BLI_dlrbTree_search(tree, cmp_cb, search_data);
+       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 */
@@ -277,7 +277,7 @@ short BLI_dlrbTree_contains(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *
 /* Tree Relationships Utilities */
 
 /* get the 'grandparent' - the parent of the parent - of the given node */
-static DLRBT_Node *get_grandparent (DLRBT_Node *node)
+static DLRBT_Node *get_grandparent(DLRBT_Node *node)
 {
        if (node && node->parent)
                return node->parent->parent;
@@ -300,7 +300,7 @@ 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)
+static DLRBT_Node *get_uncle(DLRBT_Node *node)
 {
        if (node)
                /* return the child of the grandparent which isn't the node's parent */
@@ -314,71 +314,71 @@ static DLRBT_Node *get_uncle (DLRBT_Node *node)
 /* Tree Rotation Utilities */
 
 /* make right child of 'root' the new root */
-static void rotate_left (DLRBT_Tree *tree, DLRBT_Node *root)
+static void rotate_left(DLRBT_Tree *tree, DLRBT_Node *root)
 {
        DLRBT_Node **root_slot, *pivot;
        
        /* pivot is simply the root's right child, to become the root's parent */
-       pivot= root->right;
+       pivot = root->right;
        if (pivot == NULL)
                return;
        
        if (root->parent) {
                if (root == root->parent->left)
-                       root_slot= &root->parent->left;
+                       root_slot = &root->parent->left;
                else
-                       root_slot= &root->parent->right;
+                       root_slot = &root->parent->right;
        }
        else
-               root_slot= ((DLRBT_Node**)&tree->root);//&((DLRBT_Node*)tree->root);
+               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;
+       root->right = pivot->left;
+       if (pivot->left) pivot->left->parent = root;
        
-       pivot->left= root;
-       pivot->parent= root->parent;
-       root->parent= pivot;
+       pivot->left = root;
+       pivot->parent = root->parent;
+       root->parent = pivot;
        
        /* make the pivot the new root */
        if (root_slot)
-               *root_slot= pivot;
+               *root_slot = pivot;
 }
 
 /* make the left child of the 'root' the new root */
-static void rotate_right (DLRBT_Tree *tree, DLRBT_Node *root)
+static void rotate_right(DLRBT_Tree *tree, DLRBT_Node *root)
 {
        DLRBT_Node **root_slot, *pivot;
        
        /* pivot is simply the root's left child, to become the root's parent */
-       pivot= root->left;
+       pivot = root->left;
        if (pivot == NULL)
                return;
        
        if (root->parent) {
                if (root == root->parent->left)
-                       root_slot= &root->parent->left;
+                       root_slot = &root->parent->left;
                else
-                       root_slot= &root->parent->right;
+                       root_slot = &root->parent->right;
        }
        else
-               root_slot= ((DLRBT_Node**)&tree->root);//&((DLRBT_Node*)tree->root);
+               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;
+       root->left = pivot->right;
+       if (pivot->right) pivot->right->parent = root;
        
-       pivot->right= root;
-       pivot->parent= root->parent;
-       root->parent= pivot;
+       pivot->right = root;
+       pivot->parent = root->parent;
+       root->parent = pivot;
        
        /* make the pivot the new root */
        if (root_slot)
-               *root_slot= pivot;
+               *root_slot = pivot;
 }
 
 /* *********************************************** */
@@ -392,41 +392,41 @@ static void insert_check_3(DLRBT_Tree *tree, DLRBT_Node *node);
 /* ----- */
 
 /* W. 1) Root must be black (so that the 2nd-generation can have a black parent) */
-static void insert_check_1 (DLRBT_Tree *tree, DLRBT_Node *node)
+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)
-                       node->tree_col= DLRBT_BLACK;
+                       node->tree_col = DLRBT_BLACK;
                else
                        insert_check_2(tree, node);
        }
 }
 
 /* W. 2+3) Parent of node must be black, otherwise recolor and flush */
-static void insert_check_2 (DLRBT_Tree *tree, DLRBT_Node *node)
+static void insert_check_2(DLRBT_Tree *tree, DLRBT_Node *node)
 {
        /* if the parent is not black, we need to change that... */
        if (node && node->parent && node->parent->tree_col) {
-               DLRBT_Node *unc= get_uncle(node);
+               DLRBT_Node *unc = get_uncle(node);
                
                /* if uncle and parent are both red, need to change them to black and make 
                 * the parent black in order to satisfy the criteria of each node having the
                 * same number of black nodes to its leaves
                 */
                if (unc && unc->tree_col) {
-                       DLRBT_Node *gp= get_grandparent(node);
+                       DLRBT_Node *gp = get_grandparent(node);
                        
                        /* make the n-1 generation nodes black */
-                       node->parent->tree_col= unc->tree_col= DLRBT_BLACK;
+                       node->parent->tree_col = unc->tree_col = DLRBT_BLACK;
                        
                        /* - make the grandparent red, so that we maintain alternating red/black property 
                         *  (it must exist, so no need to check for NULL here),
                         * - as the grandparent may now cause inconsistencies with the rest of the tree, 
                         *   we must flush up the tree and perform checks/rebalancing/repainting, using the 
-                        *      grandparent as the node of interest
+                        *   grandparent as the node of interest
                         */
-                       gp->tree_col= DLRBT_RED;
+                       gp->tree_col = DLRBT_RED;
                        insert_check_1(tree, gp);
                }
                else {
@@ -439,9 +439,9 @@ static void insert_check_2 (DLRBT_Tree *tree, DLRBT_Node *node)
 }
 
 /* W. 4+5) Perform rotation on sub-tree containing the 'new' node, then do any  */
-static void insert_check_3 (DLRBT_Tree *tree, DLRBT_Node *node)
+static void insert_check_3(DLRBT_Tree *tree, DLRBT_Node *node)
 {
-       DLRBT_Node *gp= get_grandparent(node);
+       DLRBT_Node *gp = get_grandparent(node);
        
        /* check that grandparent and node->parent exist (jut in case... really shouldn't happen on a good tree) */
        if (node && node->parent && gp) {
@@ -451,11 +451,11 @@ static void insert_check_3 (DLRBT_Tree *tree, DLRBT_Node *node)
                 */
                if ((node == node->parent->right) && (node->parent == gp->left)) {
                        rotate_left(tree, node);
-                       node= node->left;
+                       node = node->left;
                }
                else if ((node == node->parent->left) && (node->parent == gp->right)) {
                        rotate_right(tree, node); 
-                       node= node->right;
+                       node = node->right;
                }
                
                /* fix old parent's color-tagging, and perform rotation on the old parent in the 
@@ -464,11 +464,11 @@ static void insert_check_3 (DLRBT_Tree *tree, DLRBT_Node *node)
                 */
                if (node) {
                        /* get 'new' grandparent (i.e. grandparent for old-parent (node)) */
-                       gp= get_grandparent(node);
+                       gp = get_grandparent(node);
                        
                        /* modify the coloring of the grandparent and parent so that they still satisfy the constraints */
-                       node->parent->tree_col= DLRBT_BLACK;
-                       gp->tree_col= DLRBT_RED;
+                       node->parent->tree_col = DLRBT_BLACK;
+                       gp->tree_col = DLRBT_RED;
                        
                        /* if there are several nodes that all form a left chain, do a right rotation to correct this
                         * (or a rotation in the opposite direction if they all form a right chain)
@@ -493,7 +493,7 @@ void BLI_dlrbTree_insert(DLRBT_Tree *tree, DLRBT_Node *node)
                return;
                
        /* firstly, the node we just added should be red by default */
-       node->tree_col= DLRBT_RED;
+       node->tree_col = DLRBT_RED;
                
        /* start from case 1, an trek through the tail-recursive insertion checks */
        insert_check_1(tree, node);
@@ -504,9 +504,9 @@ void BLI_dlrbTree_insert(DLRBT_Tree *tree, DLRBT_Node *node)
 /* Add the given data to the tree, and return the node added */
 // NOTE: for duplicates, the update_cb is called (if available), and the existing node is returned
 DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, 
-                       DLRBT_NAlloc_FP new_cb, DLRBT_NUpdate_FP update_cb, void *data)
+                             DLRBT_NAlloc_FP new_cb, DLRBT_NUpdate_FP update_cb, void *data)
 {
-       DLRBT_Node *parNode, *node=NULL;
+       DLRBT_Node *parNode, *node = NULL;
        short new_node = 0;
        
        /* sanity checks */
@@ -522,7 +522,7 @@ DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
        // TODO: if no updater is supplied, try using the one supplied with the tree...
                
        /* try to find the nearest node to this one */
-       parNode= BLI_dlrbTree_search(tree, cmp_cb, data);
+       parNode = BLI_dlrbTree_search(tree, cmp_cb, data);
        
        /* add new node to the BST in the 'standard way' as appropriate 
         * NOTE: we do not support duplicates in our tree...
@@ -532,49 +532,49 @@ DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
                 * NOTE: it is assumed that the values will be unit values only
                 */
                switch (cmp_cb(parNode, data)) {
-                       case -1:        /* add new node as left child */
+                       case -1:  /* add new node as left child */
                        {
-                               node= new_cb(data);
-                               new_node= 1;
+                               node = new_cb(data);
+                               new_node = 1;
                                
-                               parNode->left= node;
-                               node->parent= parNode;
+                               parNode->left = node;
+                               node->parent = parNode;
                        }
-                               break;
+                       break;
                        
-                       case 1:         /* add new node as right child */
+                       case 1:  /* add new node as right child */
                        {
-                               node= new_cb(data);
-                               new_node= 1;
+                               node = new_cb(data);
+                               new_node = 1;
                                
-                               parNode->right= node;
-                               node->parent= parNode;
+                               parNode->right = node;
+                               node->parent = parNode;
                        }
-                               break;
+                       break;
                        
-                       default:        /* update the duplicate node as appropriate */
+                       default:  /* update the duplicate node as appropriate */
                        {
                                if (update_cb)
                                        update_cb(parNode, data);
                        }
-                               break;
+                       break;
                }
        }
        else {
                /* no nodes in the tree yet... add a new node as the root */
-               node= new_cb(data);
-               new_node= 1;
+               node = new_cb(data);
+               new_node = 1;
                
-               tree->root= node;
+               tree->root = node;
        }
        
        /* if a new node was added, it should be tagged as red, and then balanced as appropriate */
        if (new_node) {
                /* tag this new node as being 'red' */
-               node->tree_col= DLRBT_RED;
+               node->tree_col = DLRBT_RED;
                
                /* perform BST balancing steps:
-                *      start from case 1, an trek through the tail-recursive insertion checks
+                *  start from case 1, an trek through the tail-recursive insertion checks
                 */
                insert_check_1(tree, node);
        }
index 48912eb..1aba8bb 100644 (file)
@@ -221,7 +221,7 @@ static int findFileRecursive(char *filename_new,
                return found;
 
        if (*filesize == -1)
-               *filesize = 0; /* dir opened fine */
+               *filesize = 0;  /* dir opened fine */
 
        while ((de = readdir(dir)) != NULL) {
 
@@ -231,7 +231,7 @@ static int findFileRecursive(char *filename_new,
                BLI_join_dirfile(path, sizeof(path), dirname, de->d_name);
 
                if (stat(path, &status) != 0)
-                       continue; /* cant stat, don't bother with this file, could print debug info here */
+                       continue;  /* cant stat, don't bother with this file, could print debug info here */
 
                if (S_ISREG(status.st_mode)) { /* is file */
                        if (strncmp(filename, de->d_name, FILE_MAX) == 0) { /* name matches */
@@ -388,29 +388,29 @@ void BLI_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
        }
 
        switch (GS(id->name)) {
-       case ID_IM:
-               ima= (Image *)id;
-               if (ima->packedfile == NULL || (flag & BLI_BPATH_TRAVERSE_SKIP_PACKED) == 0) {
-                       if (ELEM3(ima->source, IMA_SRC_FILE, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
-                               rewrite_path_fixed(ima->name, visit_cb, absbase, bpath_user_data);
+               case ID_IM:
+                       ima = (Image *)id;
+                       if (ima->packedfile == NULL || (flag & BLI_BPATH_TRAVERSE_SKIP_PACKED) == 0) {
+                               if (ELEM3(ima->source, IMA_SRC_FILE, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
+                                       rewrite_path_fixed(ima->name, visit_cb, absbase, bpath_user_data);
+                               }
                        }
-               }
-               break;
-       case ID_BR:
+                       break;
+               case ID_BR:
                {
-                       Brush *brush= (Brush *)id;
+                       Brush *brush = (Brush *)id;
                        if (brush->icon_filepath[0]) {
                                rewrite_path_fixed(brush->icon_filepath, visit_cb, absbase, bpath_user_data);
                        }
                }
                break;
-       case ID_OB:
+               case ID_OB:
 
 #define BPATH_TRAVERSE_POINTCACHE(ptcaches)                                    \
        {                                                                          \
                PointCache *cache;                                                     \
-               for (cache= (ptcaches).first; cache; cache= cache->next) {              \
-                       if (cache->flag & PTCACHE_DISK_CACHE) {                             \
+               for (cache = (ptcaches).first; cache; cache = cache->next) {           \
+                       if (cache->flag & PTCACHE_DISK_CACHE) {                            \
                                rewrite_path_fixed(cache->path,                                \
                                                   visit_cb,                                   \
                                                   absbase,                                    \
@@ -420,69 +420,69 @@ void BLI_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
        }                                                                          \
 
 
-               {
-                       Object *ob= (Object *)id;
-                       ModifierData *md;
-                       ParticleSystem *psys;
+                       {
+                               Object *ob = (Object *)id;
+                               ModifierData *md;
+                               ParticleSystem *psys;
 
-                       /* do via modifiers instead */
+                               /* do via modifiers instead */
 #if 0
-                       if (ob->fluidsimSettings) {
-                               rewrite_path_fixed(ob->fluidsimSettings->surfdataPath, visit_cb, absbase, bpath_user_data);
-                       }
+                               if (ob->fluidsimSettings) {
+                                       rewrite_path_fixed(ob->fluidsimSettings->surfdataPath, visit_cb, absbase, bpath_user_data);
+                               }
 #endif
 
-                       for (md= ob->modifiers.first; md; md= md->next) {
-                               if (md->type == eModifierType_Fluidsim) {
-                                       FluidsimModifierData *fluidmd= (FluidsimModifierData *)md;
-                                       if (fluidmd->fss) {
-                                               rewrite_path_fixed(fluidmd->fss->surfdataPath, visit_cb, absbase, bpath_user_data);
+                               for (md = ob->modifiers.first; md; md = md->next) {
+                                       if (md->type == eModifierType_Fluidsim) {
+                                               FluidsimModifierData *fluidmd = (FluidsimModifierData *)md;
+                                               if (fluidmd->fss) {
+                                                       rewrite_path_fixed(fluidmd->fss->surfdataPath, visit_cb, absbase, bpath_user_data);
+                                               }
                                        }
-                               }
-                               else if (md->type == eModifierType_Smoke) {
-                                       SmokeModifierData *smd= (SmokeModifierData *)md;
-                                       if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
-                                               BPATH_TRAVERSE_POINTCACHE(smd->domain->ptcaches[0]);
+                                       else if (md->type == eModifierType_Smoke) {
+                                               SmokeModifierData *smd = (SmokeModifierData *)md;
+                                               if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
+                                                       BPATH_TRAVERSE_POINTCACHE(smd->domain->ptcaches[0]);
+                                               }
+                                       }
+                                       else if (md->type == eModifierType_Cloth) {
+                                               ClothModifierData *clmd = (ClothModifierData *) md;
+                                               BPATH_TRAVERSE_POINTCACHE(clmd->ptcaches);
+                                       }
+                                       else if (md->type == eModifierType_Ocean) {
+                                               OceanModifierData *omd = (OceanModifierData *) md;
+                                               rewrite_path_fixed(omd->cachepath, visit_cb, absbase, bpath_user_data);
                                        }
                                }
-                               else if (md->type==eModifierType_Cloth) {
-                                       ClothModifierData *clmd= (ClothModifierData*) md;
-                                       BPATH_TRAVERSE_POINTCACHE(clmd->ptcaches);
-                               }
-                               else if (md->type==eModifierType_Ocean) {
-                                       OceanModifierData *omd= (OceanModifierData*) md;
-                                       rewrite_path_fixed(omd->cachepath, visit_cb, absbase, bpath_user_data);
-                               }
-                       }
 
-                       if (ob->soft) {
-                               BPATH_TRAVERSE_POINTCACHE(ob->soft->ptcaches);
-                       }
+                               if (ob->soft) {
+                                       BPATH_TRAVERSE_POINTCACHE(ob->soft->ptcaches);
+                               }
 
-                       for (psys= ob->particlesystem.first; psys; psys= psys->next) {
-                               BPATH_TRAVERSE_POINTCACHE(psys->ptcaches);
+                               for (psys = ob->particlesystem.first; psys; psys = psys->next) {
+                                       BPATH_TRAVERSE_POINTCACHE(psys->ptcaches);
+                               }
                        }
-               }
 
 #undef BPATH_TRAVERSE_POINTCACHE
 
-               break;
-       case ID_SO:
+                       break;
+               case ID_SO:
                {
-                       bSound *sound= (bSound *)id;
+                       bSound *sound = (bSound *)id;
                        if (sound->packedfile == NULL || (flag & BLI_BPATH_TRAVERSE_SKIP_PACKED) == 0) {
                                rewrite_path_fixed(sound->name, visit_cb, absbase, bpath_user_data);
                        }
                }
                break;
-       case ID_TXT:
-               if (((Text*)id)->name) {
-                       rewrite_path_alloc(&((Text *)id)->name, visit_cb, absbase, bpath_user_data);
-               }
-               break;
-       case ID_VF:
+               case ID_TXT:
+                       if (((Text *)id)->name) {
+                               rewrite_path_alloc(&((Text *)id)->name, visit_cb, absbase, bpath_user_data);
+                       }
+                       break;
+               case ID_VF:
                {
-                       VFont *vf= (VFont *)id;
+                       VFont *vf = (VFont *)id;
                        if (vf->packedfile == NULL || (flag & BLI_BPATH_TRAVERSE_SKIP_PACKED) == 0) {
                                if (strcmp(vf->name, FO_BUILTIN_NAME) != 0) {
                                        rewrite_path_fixed(((VFont *)id)->name, visit_cb, absbase, bpath_user_data);
@@ -490,7 +490,7 @@ void BLI_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
                        }
                }
                break;
-       case ID_TE:
+               case ID_TE:
                {
                        Tex *tex = (Tex *)id;
                        if (tex->plugin) {
@@ -504,13 +504,13 @@ void BLI_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
                }
                break;
 
-       case ID_SCE:
+               case ID_SCE:
                {
-                       Scene *scene= (Scene *)id;
+                       Scene *scene = (Scene *)id;
                        if (scene->ed) {
                                Sequence *seq;
 
-                               SEQ_BEGIN (scene->ed, seq)
+                               SEQ_BEGIN(scene->ed, seq)
                                {
                                        if (SEQ_HAS_PATH(seq)) {
                                                if (ELEM(seq->type, SEQ_MOVIE, SEQ_SOUND)) {
@@ -519,16 +519,16 @@ void BLI_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
                                                }
                                                else if (seq->type == SEQ_IMAGE) {
                                                        /* might want an option not to loop over all strips */
-                                                       StripElem *se= seq->strip->stripdata;
-                                                       int len= MEM_allocN_len(se) / sizeof(*se);
+                                                       StripElem *se = seq->strip->stripdata;
+                                                       int len = MEM_allocN_len(se) / sizeof(*se);
                                                        int i;
 
                                                        if (flag & BLI_BPATH_TRAVERSE_SKIP_MULTIFILE) {
                                                                /* only operate on one path */
-                                                               len= MIN2(1, len);
+                                                               len = MIN2(1, len);
                                                        }
 
-                                                       for (i= 0; i < len; i++, se++) {
+                                                       for (i = 0; i < len; i++, se++) {
                                                                rewrite_path_fixed_dirfile(seq->strip->dir, se->name,
                                                                                           visit_cb, absbase, bpath_user_data);
                                                        }
@@ -547,31 +547,31 @@ void BLI_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
                        }
                }
                break;
-       case ID_ME:
+               case ID_ME:
                {
-                       Mesh *me= (Mesh *)id;
+                       Mesh *me = (Mesh *)id;
                        if (me->fdata.external) {
                                rewrite_path_fixed(me->fdata.external->filename, visit_cb, absbase, bpath_user_data);
                        }
                }
                break;
-       case ID_LI:
+               case ID_LI:
                {
-                       Library *lib= (Library *)id;
+                       Library *lib = (Library *)id;
                        if (rewrite_path_fixed(lib->name, visit_cb, absbase, bpath_user_data)) {
                                BKE_library_filepath_set(lib, lib->name);
                        }
                }
                break;
-       case ID_MC:
+               case ID_MC:
                {
-                       MovieClip *clip= (MovieClip *)id;
+                       MovieClip *clip = (MovieClip *)id;
                        rewrite_path_fixed(clip->name, visit_cb, absbase, bpath_user_data);
                }
                break;
-       default:
-               /* Nothing to do for other IDs that don't contain file paths. */
-               break;
+               default:
+                       /* Nothing to do for other IDs that don't contain file paths. */
+                       break;
        }
 }
 
index 531a4de..cdaf270 100644 (file)
 #include "BLI_mempool.h"
 
 /**************inlined code************/
-static unsigned int _ehash_hashsizes[]= {
+static unsigned int _ehash_hashsizes[] = {
        1, 3, 5, 11, 17, 37, 67, 131, 257, 521, 1031, 2053, 4099, 8209,
        16411, 32771, 65537, 131101, 262147, 524309, 1048583, 2097169,
        4194319, 8388617, 16777259, 33554467, 67108879, 134217757,
        268435459
 };
 
-#define EDGE_HASH(v0, v1)  ((v0 * 39)^(v1 * 31))
+#define EDGE_HASH(v0, v1)  ((v0 * 39) ^ (v1 * 31))
 
 /* ensure v0 is smaller */
 #define EDGE_ORD(v0, v1) \
@@ -105,9 +105,9 @@ void BLI_edgehash_insert(EdgeHash *eh, unsigned int v0, unsigned int v1, void *v
        e->v1 = v1;
        e->val = val;
        e->next = eh->buckets[hash];
-       eh->buckets[hash]= e;
+       eh->buckets[hash] = e;
 
-       if (++eh->nentries>eh->nbuckets * 3) {
+       if (++eh->nentries > eh->nbuckets * 3) {
                EdgeEntry *e, **old = eh->buckets;
                int i, nold = eh->nbuckets;
 
@@ -116,12 +116,12 @@ void BLI_edgehash_insert(EdgeHash *eh, unsigned int v0, unsigned int v1, void *v
                memset(eh->buckets, 0, eh->nbuckets * sizeof(*eh->buckets));
 
                for (i = 0; i < nold; i++) {
-                       for (e = old[i]; e;) {
+                       for (e = old[i]; e; ) {
                                EdgeEntry *n = e->next;
 
                                hash = EDGE_HASH(e->v0, e->v1) % eh->nbuckets;
                                e->next = eh->buckets[hash];
-                               eh->buckets[hash]= e;
+                               eh->buckets[hash] = e;
 
                                e = n;
                        }
@@ -150,7 +150,7 @@ void *BLI_edgehash_lookup(EdgeHash *eh, unsigned int v0, unsigned int v1)
 {
        void **value_p = BLI_edgehash_lookup_p(eh, v0, v1);
 
-       return value_p?*value_p:NULL;
+       return value_p ? *value_p : NULL;
 }
 
 int BLI_edgehash_haskey(EdgeHash *eh, unsigned int v0, unsigned int v1)
@@ -167,7 +167,7 @@ void BLI_edgehash_clear(EdgeHash *eh, EdgeHashFreeFP valfreefp)
 {
        int i;
        
-       for (i = 0; i<eh->nbuckets; i++) {
+       for (i = 0; i < eh->nbuckets; i++) {
                EdgeEntry *e;
                
                for (e = eh->buckets[i]; e; ) {
@@ -231,7 +231,7 @@ void BLI_edgehashIterator_getKey(EdgeHashIterator *ehi, unsigned int *v0_r, unsi
 }
 void *BLI_edgehashIterator_getValue(EdgeHashIterator *ehi)
 {
-       return ehi->curEntry?ehi->curEntry->val:NULL;
+       return ehi->curEntry ? ehi->curEntry->val : NULL;
 }
 
 void BLI_edgehashIterator_setValue(EdgeHashIterator *ehi, void *val)
index 0a5e4d9..e6d0648 100644 (file)
@@ -74,7 +74,7 @@ int BLI_file_gzip(const char *from, const char *to)
        char buffer[10240];
        int file;
        int readsize = 0;
-       int rval= 0, err;
+       int rval = 0, err;
        gzFile gzfile;
 
        /* level 1 is very close to 3 (the default) in terms of file size,
@@ -82,7 +82,7 @@ int BLI_file_gzip(const char *from, const char *to)
        gzfile = BLI_gzopen(to, "wb1");
        if (gzfile == NULL)
                return -1;
-       file = BLI_open(from, O_BINARY|O_RDONLY, 0);
+       file = BLI_open(from, O_BINARY | O_RDONLY, 0);
        if (file < 0)
                return -2;
 
@@ -90,15 +90,15 @@ int BLI_file_gzip(const char *from, const char *to)
                readsize = read(file, buffer, sizeof(buffer));
 
                if (readsize < 0) {
-                       rval= -2; /* error happened in reading */
+                       rval = -2; /* error happened in reading */
                        fprintf(stderr, "Error reading file %s: %s.\n", from, strerror(errno));
                        break;
                }
                else if (readsize == 0)
-                       break; /* done reading */
+                       break;  /* done reading */
                
                if (gzwrite(gzfile, buffer, readsize) <= 0) {
-                       rval= -1; /* error happened in writing */
+                       rval = -1; /* error happened in writing */
                        fprintf(stderr, "Error writing gz file %s: %s.\n", to, gzerror(gzfile, &err));
                        break;
                }
@@ -116,38 +116,38 @@ int BLI_file_gzip(const char *from, const char *to)
 char *BLI_file_ungzip_to_mem(const char *from_file, int *size_r)
 {
        gzFile gzfile;
-       int readsize, size, alloc_size=0;
-       char *mem= NULL;
-       const int chunk_size= 512*1024;
+       int readsize, size, alloc_size = 0;
+       char *mem = NULL;
+       const int chunk_size = 512 * 1024;
 
-       size= 0;
+       size = 0;
 
-       gzfile = BLI_gzopen( from_file, "rb" );
-       for (;;) {
-               if (mem==NULL) {
-                       mem= MEM_callocN(chunk_size, "BLI_ungzip_to_mem");
-                       alloc_size= chunk_size;
+       gzfile = BLI_gzopen(from_file, "rb");
+       for (;; ) {
+               if (mem == NULL) {
+                       mem = MEM_callocN(chunk_size, "BLI_ungzip_to_mem");
+                       alloc_size = chunk_size;
                }
                else {
-                       mem= MEM_reallocN(mem, size+chunk_size);
-                       alloc_size+= chunk_size;
+                       mem = MEM_reallocN(mem, size + chunk_size);
+                       alloc_size += chunk_size;
                }
 
-               readsize= gzread(gzfile, mem+size, chunk_size);
-               if (readsize>0) {
-                       size+= readsize;
+               readsize = gzread(gzfile, mem + size, chunk_size);
+               if (readsize > 0) {
+                       size += readsize;
                }
                else break;
        }
 
-       if (size==0) {
+       if (size == 0) {
                MEM_freeN(mem);
-               mem= NULL;
+               mem = NULL;
        }
-       else if (alloc_size!=size)
-               mem= MEM_reallocN(mem, size);
+       else if (alloc_size != size)
+               mem = MEM_reallocN(mem, size);
 
-       *size_r= size;
+       *size_r = size;
 
        return mem;
 }
@@ -254,14 +254,14 @@ int BLI_delete(const char *file, int dir, int recursive)
 
        if (recursive) {
                callLocalErrorCallBack("Recursive delete is unsupported on Windows");
-               err= 1;
+               err = 1;
        }
        else if (dir) {
-               err= !RemoveDirectoryW(file_16);
-               if (err) printf ("Unable to remove directory");
+               err = !RemoveDirectoryW(file_16);
+               if (err) printf("Unable to remove directory");
        }
        else {
-               err= !DeleteFileW(file_16);
+               err = !DeleteFileW(file_16);
                if (err) callLocalErrorCallBack("Unable to delete file");
        }
 
@@ -288,7 +288,7 @@ int BLI_move(const char *file, const char *to)
        
        UTF16_ENCODE(file);
        UTF16_ENCODE(str);
-       err= !MoveFileW(file_16, str_16);
+       err = !MoveFileW(file_16, str_16);
        UTF16_UN_ENCODE(str);
        UTF16_UN_ENCODE(file);
 
@@ -350,7 +350,7 @@ void BLI_dir_create_recursive(const char *dirname)
         * blah1/blah2 (without slash) */
 
        BLI_strncpy(tmp, dirname, sizeof(tmp));
-       lslash= BLI_last_slash(tmp);
+       lslash = BLI_last_slash(tmp);
        
        if (lslash == tmp + strlen(tmp) - 1) {
                *lslash = 0;
@@ -358,7 +358,7 @@ void BLI_dir_create_recursive(const char *dirname)
        
        if (BLI_exists(tmp)) return;
 
-       lslash= BLI_last_slash(tmp);
+       lslash = BLI_last_slash(tmp);
        if (lslash) {
                /* Split about the last slash and recurse */
                *lslash = 0;
@@ -366,7 +366,7 @@ void BLI_dir_create_recursive(const char *dirname)
        }
        
        if (dirname[0]) /* patch, this recursive loop tries to create a nameless directory */
-               if (umkdir(dirname)==-1)
+               if (umkdir(dirname) == -1)
                        printf("Unable to create directory %s\n", dirname);
 }
 
@@ -394,7 +394,7 @@ enum {
        recursiveOp_Callback_Error = 2
 } recuresiveOp_Callback_Result;
 
-typedef int (*recursiveOp_Callback) (const char *from, const char *to);
+typedef int (*recursiveOp_Callback)(const char *from, const char *to);
 
 /* appending of filename to dir (ensures for buffer size before appending) */
 static void join_dirfile_alloc(char **dst, size_t *alloc_len, const char *dir, const char *file)
@@ -680,11 +680,11 @@ static int copy_single_file(const char *from, const char *to)
                        need_free = 0;
                }
                else {
-                       link_buffer = MEM_callocN(st.st_size+2, "copy_single_file link_buffer");
+                       link_buffer = MEM_callocN(st.st_size + 2, "copy_single_file link_buffer");
                        need_free = 1;
                }
 
-               link_len = readlink(from, link_buffer, st.st_size+1);
+               link_len = readlink(from, link_buffer, st.st_size + 1);
                if (link_len < 0) {
                        perror("readlink");
 
@@ -706,10 +706,10 @@ static int copy_single_file(const char *from, const char *to)
 
                return recursiveOp_Callback_OK;
        }
-       else if (S_ISCHR (st.st_mode) ||
-               S_ISBLK (st.st_mode) ||
-               S_ISFIFO (st.st_mode) ||
-               S_ISSOCK (st.st_mode))
+       else if (S_ISCHR(st.st_mode) ||
+                S_ISBLK(st.st_mode) ||
+                S_ISFIFO(st.st_mode) ||
+                S_ISSOCK(st.st_mode))
        {
                /* copy special type of file */
                if (mknod(to, st.st_mode, st.st_rdev)) {
@@ -798,7 +798,7 @@ static char *check_destination(const char *file, const char *to)
 
                        if (!filename) {
                                MEM_freeN(str);
-                               return (char*)to;
+                               return (char *)to;
                        }
 
                        /* skip slash */
@@ -814,7 +814,7 @@ static char *check_destination(const char *file, const char *to)
                }
        }
 
-       return (char*)to;
+       return (char *)to;
 }
 
 int BLI_copy(const char *file, const char *to)
@@ -824,7 +824,7 @@ 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(actual_to);
 
        return ret;
@@ -852,16 +852,16 @@ void BLI_dir_create_recursive(const char *dirname)
        tmp = static_buf;
        needs_free = 0;
 #else
-       size = strlen(dirname)+1;
+       size = strlen(dirname) + 1;
        tmp = MEM_callocN(size, "BLI_dir_create_recursive tmp");
        needs_free = 1;
 #endif
 
        BLI_strncpy(tmp, dirname, size);
                
-       lslash= BLI_last_slash(tmp);
+       lslash = BLI_last_slash(tmp);
        if (lslash) {
-                       /* Split about the last slash and recurse */    
+               /* Split about the last slash and recurse */
                *lslash = 0;
                BLI_dir_create_recursive(tmp);
        }
index afe31fb..6203a98 100644 (file)
@@ -43,41 +43,41 @@ void BLI_jitterate1(float *jit1, float *jit2, int num, float rad1)
        int i, j, k;
        float vecx, vecy, dvecx, dvecy, x, y, len;
 
-       for (i = 2*num-2; i>=0 ; i-=2) {
+       for (i = 2 * num - 2; i >= 0; i -= 2) {
                dvecx = dvecy = 0.0;
                x = jit1[i];
-               y = jit1[i+1];
-               for (j = 2*num-2; j>=0 ; j-=2) {
+               y = jit1[i + 1];
+               for (j = 2 * num - 2; j >= 0; j -= 2) {
                        if (i != j) {
                                vecx = jit1[j] - x - 1.0f;
-                               vecy = jit1[j+1] - y - 1.0f;
-                               for (k = 3; k>0 ; k--) {
-                                       if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
-                                               len=  sqrt(vecx*vecx + vecy*vecy);
-                                               if (len>0 && len<rad1) {
-                                                       len= len/rad1;
-                                                       dvecx += vecx/len;
-                                                       dvecy += vecy/len;
+                               vecy = jit1[j + 1] - y - 1.0f;
+                               for (k = 3; k > 0; k--) {
+                                       if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
+                                               len =  sqrt(vecx * vecx + vecy * vecy);
+                                               if (len > 0 && len < rad1) {
+                                                       len = len / rad1;
+                                                       dvecx += vecx / len;
+                                                       dvecy += vecy / len;
                                                }
                                        }
                                        vecx += 1.0f;
 
-                                       if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
-                                               len=  sqrt(vecx*vecx + vecy*vecy);
-                                               if (len>0 && len<rad1) {
-                                                       len= len/rad1;
-                                                       dvecx += vecx/len;
-                                                       dvecy += vecy/len;
+                                       if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
+                                               len =  sqrt(vecx * vecx + vecy * vecy);
+                                               if (len > 0 && len < rad1) {
+                                                       len = len / rad1;
+                                                       dvecx += vecx / len;
+                                                       dvecy += vecy / len;
                                                }
                                        }
                                        vecx += 1.0f;
 
-                                       if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
-                                               len=  sqrt(vecx*vecx + vecy*vecy);
-                                               if (len>0 && len<rad1) {
-                                                       len= len/rad1;
-                                                       dvecx += vecx/len;
-                                                       dvecy += vecy/len;
+                                       if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
+                                               len =  sqrt(vecx * vecx + vecy * vecy);
+                                               if (len > 0 && len < rad1) {
+                                                       len = len / rad1;
+                                                       dvecx += vecx / len;
+                                                       dvecy += vecy / len;
                                                }
                                        }
                                        vecx -= 2.0f;
@@ -86,12 +86,12 @@ void BLI_jitterate1(float *jit1, float *jit2, int num, float rad1)
                        }
                }
 
-               x -= dvecx/18.0f;
-               y -= dvecy/18.0f;
+               x -= dvecx / 18.0f;
+               y -= dvecy / 18.0f;
                x -= floorf(x);
                y -= floorf(y);
                jit2[i] = x;
-               jit2[i+1] = y;
+               jit2[i + 1] = y;
        }
        memcpy(jit1, jit2, 2 * num * sizeof(float));
 }
@@ -101,36 +101,36 @@ void BLI_jitterate2(float *jit1, float *jit2, int num, float rad2)
        int i, j;
        float vecx, vecy, dvecx, dvecy, x, y;
 
-       for (i=2*num -2; i>= 0 ; i-=2) {
+       for (i = 2 * num - 2; i >= 0; i -= 2) {
                dvecx = dvecy = 0.0;
                x = jit1[i];
-               y = jit1[i+1];
-               for (j =2*num -2; j>= 0 ; j-=2) {
+               y = jit1[i + 1];
+               for (j = 2 * num - 2; j >= 0; j -= 2) {
                        if (i != j) {
                                vecx = jit1[j] - x - 1.0f;
-                               vecy = jit1[j+1] - y - 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;
 
                        }
                }
 
-               x -= dvecx/2.0f;
-               y -= dvecy/2.0f;
+               x -= dvecx / 2.0f;
+               y -= dvecy / 2.0f;
                x -= floorf(x);
                y -= floorf(y);
                jit2[i] = x;
-               jit2[i+1] = y;
+               jit2[i + 1] = y;
        }
        memcpy(jit1, jit2, 2 * num * sizeof(float));
 }
@@ -141,23 +141,23 @@ void BLI_jitter_init(float *jitarr, int num)
        float *jit2, x, rad1, rad2, rad3;
        int i;
 
-       if (num==0) return;
+       if (num == 0) return;
 
-       jit2= MEM_mallocN(12 + 2*sizeof(float)*num, "initjit");
-       rad1= 1.0f/sqrtf((float)num);
-       rad2= 1.0f/((float)num);
-       rad3= sqrtf((float)num)/((float)num);
+       jit2 = MEM_mallocN(12 + 2 * sizeof(float) * num, "initjit");
+       rad1 = 1.0f / sqrtf((float)num);
+       rad2 = 1.0f / ((float)num);
+       rad3 = sqrtf((float)num) / ((float)num);
 
        BLI_srand(31415926 + num);
-       x= 0;
-       for (i=0; i<2*num; i+=2) {
-               jitarr[i]= x+ rad1*(float)(0.5-BLI_drand());
-               jitarr[i+1]= ((float)i/2)/num +rad1*(float)(0.5-BLI_drand());
-               x+= rad3;
+       x = 0;
+       for (i = 0; i < 2 * num; i += 2) {
+               jitarr[i] = x + rad1 * (float)(0.5 - BLI_drand());
+               jitarr[i + 1] = ((float)i / 2) / num + rad1 * (float)(0.5 - BLI_drand());
+               x += rad3;
                x -= floorf(x);
        }
 
-       for (i=0 ; i<24 ; i++) {
+       for (i = 0; i < 24; i++) {
                BLI_jitterate1(jitarr, jit2, num, rad1);
                BLI_jitterate1(jitarr, jit2, num, rad1);
                BLI_jitterate2(jitarr, jit2, num, rad2);
@@ -166,9 +166,9 @@ void BLI_jitter_init(float *jitarr, int num)
        MEM_freeN(jit2);
        
        /* finally, move jittertab to be centered around (0,0) */
-       for (i=0; i<2*num; i+=2) {
+       for (i = 0; i < 2 * num; i += 2) {
                jitarr[i] -= 0.5f;
-               jitarr[i+1] -= 0.5f;
+               jitarr[i + 1] -= 0.5f;
        }
        
 }
index a81656d..5f53211 100644 (file)
@@ -429,23 +429,23 @@ int isect_line_sphere_v3(const float l1[3], const float l2[3],
         */
 
        const float ldir[3] = {
-           l2[0] - l1[0],
-           l2[1] - l1[1],
-           l2[2] - l1[2]
+               l2[0] - l1[0],
+               l2[1] - l1[1],
+               l2[2] - l1[2]
        };
 
        const float a = dot_v3v3(ldir, ldir);
 
        const float b = 2.0f *
-               (ldir[0] * (l1[0] - sp[0]) +
-                ldir[1] * (l1[1] - sp[1]) +
-                ldir[2] * (l1[2] - sp[2]));
+                       (ldir[0] * (l1[0] - sp[0]) +
+                        ldir[1] * (l1[1] - sp[1]) +
+                        ldir[2] * (l1[2] - sp[2]));
 
        const float c =
-               dot_v3v3(sp, sp) +
-               dot_v3v3(l1, l1) -
-               (2.0f * dot_v3v3(sp, l1)) -
-               (r * r);
+           dot_v3v3(sp, sp) +
+           dot_v3v3(l1, l1) -
+           (2.0f * dot_v3v3(sp, l1)) -
+           (r * r);
 
        const float i = b * b - 4.0f * a * c;
 
@@ -490,14 +490,14 @@ int isect_line_sphere_v2(const float l1[2], const float l2[2],
        const float a = dot_v2v2(ldir, ldir);
 
        const float b = 2.0f *
-               (ldir[0] * (l1[0] - sp[0]) +
-                ldir[1] * (l1[1] - sp[1]));
+                       (ldir[0] * (l1[0] - sp[0]) +
+                        ldir[1] * (l1[1] - sp[1]));
 
        const float c =
-               dot_v2v2(sp, sp) +
-               dot_v2v2(l1, l1) -
-               (2.0f * dot_v2v2(sp, l1)) -
-               (r * r);
+           dot_v2v2(sp, sp) +
+           dot_v2v2(l1, l1) -
+           (2.0f * dot_v2v2(sp, l1)) -
+           (r * r);
 
        const float i = b * b - 4.0f * a * c;
 
@@ -1738,9 +1738,9 @@ void axis_dominant_v3(int *axis_a, int *axis_b, const float axis[3])
        const float yn = fabsf(axis[1]);
        const float zn = fabsf(axis[2]);
 
-       if      (zn >= xn && zn >= yn) { *axis_a= 0; *axis_b = 1; }
-       else if (yn >= xn && yn >= zn) { *axis_a= 0; *axis_b = 2; }
-       else                           { *axis_a= 1; *axis_b = 2; }
+       if      (zn >= xn && zn >= yn) { *axis_a = 0; *axis_b = 1; }
+       else if (yn >= xn && yn >= zn) { *axis_a = 0; *axis_b = 2; }
+       else                           { *axis_a = 1; *axis_b = 2; }
 }
 
 static float tri_signed_area(const float v1[3], const float v2[3], const float v3[3], const int i, const int j)
index 37402f9..066c9e7 100644 (file)
@@ -1691,12 +1691,13 @@ void quat_apply_track(float quat[4], short axis, short upflag)
 {
        /* rotations are hard coded to match vec_to_quat */
        const float quat_track[][4] = {
-           {0.70710676908493, 0.0, -0.70710676908493, 0.0}, /* pos-y90 */
-           {0.5, 0.5, 0.5, 0.5}, /* Quaternion((1,0,0), radians(90)) * Quaternion((0,1,0), radians(90)) */
-           {0.70710676908493, 0.0, 0.0, 0.70710676908493}, /* pos-z90 */
-           {0.70710676908493, 0.0, 0.70710676908493, 0.0}, /* neg-y90 */
-           {0.5, -0.5, -0.5, 0.5}, /* Quaternion((1,0,0), radians(-90)) * Quaternion((0,1,0), radians(-90)) */
-           {-3.0908619663705394e-08, 0.70710676908493, 0.70710676908493, 3.0908619663705394e-08}}; /* no rotation */
+               {0.70710676908493, 0.0, -0.70710676908493, 0.0}, /* pos-y90 */
+               {0.5, 0.5, 0.5, 0.5}, /* Quaternion((1,0,0), radians(90)) * Quaternion((0,1,0), radians(90)) */
+               {0.70710676908493, 0.0, 0.0, 0.70710676908493}, /* pos-z90 */
+               {0.70710676908493, 0.0, 0.70710676908493, 0.0}, /* neg-y90 */
+               {0.5, -0.5, -0.5, 0.5}, /* Quaternion((1,0,0), radians(-90)) * Quaternion((0,1,0), radians(-90)) */
+               {-3.0908619663705394e-08, 0.70710676908493, 0.70710676908493, 3.0908619663705394e-08} /* no rotation */
+       };
 
        assert(axis >= 0 && axis <= 5);
        assert(upflag >= 0 && upflag <= 2);
index d795f9b..f591dc1 100644 (file)
@@ -45,10 +45,10 @@ static float noise3_perlin(float vec[3]);
 //static float turbulence_perlin(float *point, float lofreq, float hifreq);
 //static float turbulencep(float noisesize, float x, float y, float z, int nr);
 
-#define HASHVEC(x, y, z) hashvectf + 3 * hash[ (hash[ (hash[(z) & 255] + (y)) & 255] + (x)) & 255]
+#define HASHVEC(x, y, z) hashvectf + 3 * hash[(hash[(hash[(z) & 255] + (y)) & 255] + (x)) & 255]
 
 /* needed for voronoi */
-#define HASHPNT(x, y, z) hashpntf + 3 * hash[ (hash[ (hash[(z) & 255] + (y)) & 255] + (x)) & 255]
+#define HASHPNT(x, y, z) hashpntf + 3 * hash[(hash[(hash[(z) & 255] + (y)) & 255] + (x)) & 255]
 static float hashpntf[768] = {
        0.536902, 0.020915, 0.501445, 0.216316, 0.517036, 0.822466, 0.965315,
        0.377313, 0.678764, 0.744545, 0.097731, 0.396357, 0.247202, 0.520897,
@@ -162,7 +162,7 @@ static float hashpntf[768] = {
        0.114246, 0.905043, 0.713870, 0.555261, 0.951333
 };
 
-unsigned char hash[512]= {
+unsigned char hash[512] = {
        0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0,  0xDE, 0x95, 0x2E, 0xDC,
        0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC,  0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8,  0x8B, 0x63,
        0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80,
@@ -193,7 +193,7 @@ unsigned char hash[512]= {
 };
 
 
-float hashvectf[768]= {
+float hashvectf[768] = {
        0.33783, 0.715698, -0.611206, -0.944031, -0.326599, -0.045624, -0.101074, -0.416443, -0.903503, 0.799286, 0.49411,
        -0.341949, -0.854645, 0.518036, 0.033936, 0.42514, -0.437866, -0.792114, -0.358948, 0.597046, 0.717377, -0.985413,
        0.144714, 0.089294, -0.601776, -0.33728, -0.723907, -0.449921, 0.594513, 0.666382, 0.208313, -0.10791, 0.972076,
@@ -263,7 +263,7 @@ float hashvectf[768]= {
        0.196045, -0.982941, 0.164307, -0.082245, 0.233734, -0.97226, -0.005005, -0.747253, -0.611328, 0.260437, 0.645599,
        0.592773, 0.481384, 0.117706, -0.949524, -0.29068, -0.535004, -0.791901, -0.294312, -0.627167, -0.214447, 0.748718,
        -0.047974, -0.813477, -0.57959, -0.175537, 0.477264, -0.860992, 0.738556, -0.414246, -0.53183, 0.562561, -0.704071,
-0.433289, -0.754944, 0.64801, -0.100586, 0.114716, 0.044525, -0.992371, 0.966003, 0.244873, -0.082764,
+       0.433289, -0.754944, 0.64801, -0.100586, 0.114716, 0.044525, -0.992371, 0.966003, 0.244873, -0.082764,
 };
 
 /**************************/
@@ -272,28 +272,28 @@ float hashvectf[768]= {
 
 static float lerp(float t, float a, float b)
 {
-       return (a+t*(b-a));
+       return (a + t * (b - a));
 }
 
 static float npfade(float t)
 {
-       return (t*t*t*(t*(t*6.0f-15.0f)+10.0f));
+       return (t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f));
 }
 
 static float grad(int hash, float x, float y, float z)
 {
        int h = hash & 15;                     // CONVERT LO 4 BITS OF HASH CODE
-       float u = h<8 ? x : y,                 // INTO 12 GRADIENT DIRECTIONS.
-                               v = h<4 ? y : h==12||h==14 ? x : z;
-       return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
+       float u = h < 8 ? x : y,                 // INTO 12 GRADIENT DIRECTIONS.
+             v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+       return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
 }
 
 /* instead of adding another permutation array, just use hash table defined above */
 static float newPerlin(float x, float y, float z)
 {
        int A, AA, AB, B, BA, BB;
-       float u=floor(x), v=floor(y), w=floor(z);
-       int X=((int)u) & 255, Y=((int)v) & 255, Z=((int)w) & 255;       // FIND UNIT CUBE THAT CONTAINS POINT
+       float u = floor(x), v = floor(y), w = floor(z);
+       int X = ((int)u) & 255, Y = ((int)v) & 255, Z = ((int)w) & 255;   // FIND UNIT CUBE THAT CONTAINS POINT
        x -= u;             // FIND RELATIVE X,Y,Z
        y -= v;             // OF POINT IN CUBE.
        z -= w;
@@ -315,7 +315,7 @@ static float newPerlin(float x, float y, float z)
 /* for use with BLI_gNoise()/BLI_gTurbulence(), returns unsigned improved perlin noise */
 static float newPerlinU(float x, float y, float z)
 {
-       return (0.5f+0.5f*newPerlin(x, y, z));
+       return (0.5f + 0.5f * newPerlin(x, y, z));
 }
 
 
@@ -328,92 +328,92 @@ static float orgBlenderNoise(float x, float y, float z)
 {
        register float cn1, cn2, cn3, cn4, cn5, cn6, i, *h;
        float fx, fy, fz, ox, oy, oz, jx, jy, jz;
-       float n= 0.5;
+       float n = 0.5;
        int ix, iy, iz, b00, b01, b10, b11, b20, b21;
 
-       fx= floor(x);
-       fy= floor(y);
-       fz= floor(z);
-
-       ox= x- fx;
-       oy= y- fy;
-       oz= z- fz;
-
-       ix= (int)fx;
-       iy= (int)fy;
-       iz= (int)fz;
-
-       jx= ox-1;
-       jy= oy-1;
-       jz= oz-1;
-
-       cn1=ox*ox; cn2=oy*oy; cn3=oz*oz;
-       cn4=jx*jx; cn5=jy*jy; cn6=jz*jz;
-
-       cn1= 1.0f-3.0f*cn1+2.0f*cn1*ox;
-       cn2= 1.0f-3.0f*cn2+2.0f*cn2*oy;
-       cn3= 1.0f-3.0f*cn3+2.0f*cn3*oz;
-       cn4= 1.0f-3.0f*cn4-2.0f*cn4*jx;
-       cn5= 1.0f-3.0f*cn5-2.0f*cn5*jy;
-       cn6= 1.0f-3.0f*cn6-2.0f*cn6*jz;
-
-       b00= hash[ hash[ix & 255]+(iy & 255)];
-       b10= hash[ hash[(ix+1) & 255]+(iy & 255)];
-       b01= hash[ hash[ix & 255]+((iy+1) & 255)];
-       b11= hash[ hash[(ix+1) & 255]+((iy+1) & 255)];
-
-       b20=iz & 255; b21= (iz+1) & 255;
-
-               /* 0 */
-       i= (cn1*cn2*cn3);
-               h=hashvectf+ 3*hash[b20+b00];
-               n+= i*(h[0]*ox+h[1]*oy+h[2]*oz);
-               /* 1 */
-       i= (cn1*cn2*cn6);
-               h=hashvectf+ 3*hash[b21+b00];
-               n+= i*(h[0]*ox+h[1]*oy+h[2]*jz);
-               /* 2 */
-       i= (cn1*cn5*cn3);
-               h=hashvectf+ 3*hash[b20+b01];
-               n+= i*(h[0]*ox+h[1]*jy+h[2]*oz);
-               /* 3 */
-       i= (cn1*cn5*cn6);
-               h=hashvectf+ 3*hash[b21+b01];
-               n+= i*(h[0]*ox+h[1]*jy+h[2]*jz);
-               /* 4 */
-       i= cn4*cn2*cn3;
-               h=hashvectf+ 3*hash[b20+b10];
-               n+= i*(h[0]*jx+h[1]*oy+h[2]*oz);
-               /* 5 */
-       i= cn4*cn2*cn6;
-               h=hashvectf+ 3*hash[b21+b10];
-               n+= i*(h[0]*jx+h[1]*oy+h[2]*jz);
-               /* 6 */
-       i= cn4*cn5*cn3;
-               h=hashvectf+ 3*hash[b20+b11];
-               n+=  i*(h[0]*jx+h[1]*jy+h[2]*oz);
-               /* 7 */
-       i= (cn4*cn5*cn6);
-               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;
+       fx = floor(x);
+       fy = floor(y);
+       fz = floor(z);
+
+       ox = x - fx;
+       oy = y - fy;
+       oz = z - fz;
+
+       ix = (int)fx;
+       iy = (int)fy;
+       iz = (int)fz;
+
+       jx = ox - 1;
+       jy = oy - 1;
+       jz = oz - 1;
+
+       cn1 = ox * ox; cn2 = oy * oy; cn3 = oz * oz;
+       cn4 = jx * jx; cn5 = jy * jy; cn6 = jz * jz;
+
+       cn1 = 1.0f - 3.0f * cn1 + 2.0f * cn1 * ox;
+       cn2 = 1.0f - 3.0f * cn2 + 2.0f * cn2 * oy;
+       cn3 = 1.0f - 3.0f * cn3 + 2.0f * cn3 * oz;
+       cn4 = 1.0f - 3.0f * cn4 - 2.0f * cn4 * jx;
+       cn5 = 1.0f - 3.0f * cn5 - 2.0f * cn5 * jy;
+       cn6 = 1.0f - 3.0f * cn6 - 2.0f * cn6 * jz;
+
+       b00 = hash[hash[ix & 255] + (iy & 255)];
+       b10 = hash[hash[(ix + 1) & 255] + (iy & 255)];
+       b01 = hash[hash[ix & 255] + ((iy + 1) & 255)];
+       b11 = hash[hash[(ix + 1) & 255] + ((iy + 1) & 255)];
+
+       b20 = iz & 255; b21 = (iz + 1) & 255;
+
+       /* 0 */
+       i = (cn1 * cn2 * cn3);
+       h = hashvectf + 3 * hash[b20 + b00];
+       n += i * (h[0] * ox + h[1] * oy + h[2] * oz);
+       /* 1 */
+       i = (cn1 * cn2 * cn6);
+       h = hashvectf + 3 * hash[b21 + b00];
+       n += i * (h[0] * ox + h[1] * oy + h[2] * jz);
+       /* 2 */
+       i = (cn1 * cn5 * cn3);
+       h = hashvectf + 3 * hash[b20 + b01];
+       n += i * (h[0] * ox + h[1] * jy + h[2] * oz);
+       /* 3 */
+       i = (cn1 * cn5 * cn6);
+       h = hashvectf + 3 * hash[b21 + b01];
+       n += i * (h[0] * ox + h[1] * jy + h[2] * jz);
+       /* 4 */
+       i = cn4 * cn2 * cn3;
+       h = hashvectf + 3 * hash[b20 + b10];
+       n += i * (h[0] * jx + h[1] * oy + h[2] * oz);
+       /* 5 */
+       i = cn4 * cn2 * cn6;
+       h = hashvectf + 3 * hash[b21 + b10];
+       n += i * (h[0] * jx + h[1] * oy + h[2] * jz);
+       /* 6 */
+       i = cn4 * cn5 * cn3;
+       h = hashvectf + 3 * hash[b20 + b11];
+       n +=  i * (h[0] * jx + h[1] * jy + h[2] * oz);
+       /* 7 */
+       i = (cn4 * cn5 * cn6);
+       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;
        return n;
 }
 
 /* as orgBlenderNoise(), returning signed noise */
 static float orgBlenderNoiseS(float x, float y, float z)
 {
-       return (2.0f*orgBlenderNoise(x, y, z)-1.0f);
+       return (2.0f * orgBlenderNoise(x, y, z) - 1.0f);
 }
 
 /* separated from orgBlenderNoise above, with scaling */
 float BLI_hnoise(float noisesize, float x, float y, float z)
 {
-       if (noisesize==0.0f) return 0.0f;
-       x= (1.0f+x)/noisesize;
-       y= (1.0f+y)/noisesize;
-       z= (1.0f+z)/noisesize;
+       if (noisesize == 0.0f) return 0.0f;
+       x = (1.0f + x) / noisesize;
+       y = (1.0f + y) / noisesize;
+       z = (1.0f + z) / noisesize;
        return orgBlenderNoise(x, y, z);
 }
 
@@ -421,53 +421,54 @@ float BLI_hnoise(float noisesize, float x, float y, float z)
 /* original turbulence functions */
 float BLI_turbulence(float noisesize, float x, float y, float z, int nr)
 {
-       float s, d= 0.5, div=1.0;
+       float s, d = 0.5, div = 1.0;
 
-       s= BLI_hnoise(noisesize, x, y, z);
+       s = BLI_hnoise(noisesize, x, y, z);
        
-       while (nr>0) {
+       while (nr > 0) {
        
-               s+= d*BLI_hnoise(noisesize*d, x, y, z);
-               div+= d;
-               d*= 0.5f;
+               s += d * BLI_hnoise(noisesize * d, x, y, z);
+               div += d;
+               d *= 0.5f;
 
                nr--;
        }
-       return s/div;
+       return s / div;
 }
 
 float BLI_turbulence1(float noisesize, float x, float y, float z, int nr)
 {
-       float s, d= 0.5, div=1.0;
+       float s, d = 0.5, div = 1.0;
 
-       s= fabsf((-1.0f + 2.0f * BLI_hnoise(noisesize, x, y, z)));
+       s = fabsf((-1.0f + 2.0f * BLI_hnoise(noisesize, x, y, z)));
        
-       while (nr>0) {
+       while (nr > 0) {
        
-               s+= fabsf(d* (-1.0f+2.0f*BLI_hnoise(noisesize*d, x, y, z)));
-               div+= d;
-               d*= 0.5f;
+               s += fabsf(d * (-1.0f + 2.0f * BLI_hnoise(noisesize * d, x, y, z)));
+               div += d;
+               d *= 0.5f;
                
                nr--;
        }
-       return s/div;
+       return s / div;
 }
 
 /* ********************* FROM PERLIN HIMSELF: ******************** */
 
-static char p[512+2]= {
-0xA2,0xA0,0x19,0x3B,0xF8,0xEB,0xAA,0xEE,0xF3,0x1C,0x67,0x28,0x1D,0xED,0x0,0xDE,0x95,0x2E,0xDC,0x3F,0x3A,0x82,0x35,0x4D,0x6C,0xBA,0x36,0xD0,0xF6,0xC,0x79,0x32,0xD1,0x59,0xF4,0x8,0x8B,0x63,0x89,0x2F,0xB8,0xB4,0x97,0x83,0xF2,0x8F,0x18,0xC7,0x51,0x14,0x65,0x87,0x48,0x20,0x42,0xA8,0x80,0xB5,0x40,0x13,0xB2,0x22,0x7E,0x57,
-0xBC,0x7F,0x6B,0x9D,0x86,0x4C,0xC8,0xDB,0x7C,0xD5,0x25,0x4E,0x5A,0x55,0x74,0x50,0xCD,0xB3,0x7A,0xBB,0xC3,0xCB,0xB6,0xE2,0xE4,0xEC,0xFD,0x98,0xB,0x96,0xD3,0x9E,0x5C,0xA1,0x64,0xF1,0x81,0x61,0xE1,0xC4,0x24,0x72,0x49,0x8C,0x90,0x4B,0x84,0x34,0x38,0xAB,0x78,0xCA,0x1F,0x1,0xD7,0x93,0x11,0xC1,0x58,0xA9,0x31,0xF9,0x44,0x6D,
-0xBF,0x33,0x9C,0x5F,0x9,0x94,0xA3,0x85,0x6,0xC6,0x9A,0x1E,0x7B,0x46,0x15,0x30,0x27,0x2B,0x1B,0x71,0x3C,0x5B,0xD6,0x6F,0x62,0xAC,0x4F,0xC2,0xC0,0xE,0xB1,0x23,0xA7,0xDF,0x47,0xB0,0x77,0x69,0x5,0xE9,0xE6,0xE7,0x76,0x73,0xF,0xFE,0x6E,0x9B,0x56,0xEF,0x12,0xA5,0x37,0xFC,0xAE,0xD9,0x3,0x8E,0xDD,0x10,0xB9,0xCE,0xC9,0x8D,
-0xDA,0x2A,0xBD,0x68,0x17,0x9F,0xBE,0xD4,0xA,0xCC,0xD2,0xE8,0x43,0x3D,0x70,0xB7,0x2,0x7D,0x99,0xD8,0xD,0x60,0x8A,0x4,0x2C,0x3E,0x92,0xE5,0xAF,0x53,0x7,0xE0,0x29,0xA6,0xC5,0xE3,0xF5,0xF7,0x4A,0x41,0x26,0x6A,0x16,0x5E,0x52,0x2D,0x21,0xAD,0xF0,0x91,0xFF,0xEA,0x54,0xFA,0x66,0x1A,0x45,0x39,0xCF,0x75,0xA4,0x88,0xFB,0x5D,
-0xA2,0xA0,0x19,0x3B,0xF8,0xEB,0xAA,0xEE,0xF3,0x1C,0x67,0x28,0x1D,0xED,0x0,0xDE,0x95,0x2E,0xDC,0x3F,0x3A,0x82,0x35,0x4D,0x6C,0xBA,0x36,0xD0,0xF6,0xC,0x79,0x32,0xD1,0x59,0xF4,0x8,0x8B,0x63,0x89,0x2F,0xB8,0xB4,0x97,0x83,0xF2,0x8F,0x18,0xC7,0x51,0x14,0x65,0x87,0x48,0x20,0x42,0xA8,0x80,0xB5,0x40,0x13,0xB2,0x22,0x7E,0x57,
-0xBC,0x7F,0x6B,0x9D,0x86,0x4C,0xC8,0xDB,0x7C,0xD5,0x25,0x4E,0x5A,0x55,0x74,0x50,0xCD,0xB3,0x7A,0xBB,0xC3,0xCB,0xB6,0xE2,0xE4,0xEC,0xFD,0x98,0xB,0x96,0xD3,0x9E,0x5C,0xA1,0x64,0xF1,0x81,0x61,0xE1,0xC4,0x24,0x72,0x49,0x8C,0x90,0x4B,0x84,0x34,0x38,0xAB,0x78,0xCA,0x1F,0x1,0xD7,0x93,0x11,0xC1,0x58,0xA9,0x31,0xF9,0x44,0x6D,
-0xBF,0x33,0x9C,0x5F,0x9,0x94,0xA3,0x85,0x6,0xC6,0x9A,0x1E,0x7B,0x46,0x15,0x30,0x27,0x2B,0x1B,0x71,0x3C,0x5B,0xD6,0x6F,0x62,0xAC,0x4F,0xC2,0xC0,0xE,0xB1,0x23,0xA7,0xDF,0x47,0xB0,0x77,0x69,0x5,0xE9,0xE6,0xE7,0x76,0x73,0xF,0xFE,0x6E,0x9B,0x56,0xEF,0x12,0xA5,0x37,0xFC,0xAE,0xD9,0x3,0x8E,0xDD,0x10,0xB9,0xCE,0xC9,0x8D,
-0xDA,0x2A,0xBD,0x68,0x17,0x9F,0xBE,0xD4,0xA,0xCC,0xD2,0xE8,0x43,0x3D,0x70,0xB7,0x2,0x7D,0x99,0xD8,0xD,0x60,0x8A,0x4,0x2C,0x3E,0x92,0xE5,0xAF,0x53,0x7,0xE0,0x29,0xA6,0xC5,0xE3,0xF5,0xF7,0x4A,0x41,0x26,0x6A,0x16,0x5E,0x52,0x2D,0x21,0xAD,0xF0,0x91,0xFF,0xEA,0x54,0xFA,0x66,0x1A,0x45,0x39,0xCF,0x75,0xA4,0x88,0xFB,0x5D,
-0xA2,0xA0};
+static char p[512 + 2] = {
+       0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0, 0xDE, 0x95, 0x2E, 0xDC, 0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC, 0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8, 0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57,
+       0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB, 0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1, 0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D,
+       0xBF, 0x33, 0x9C, 0x5F, 0x9, 0x94, 0xA3, 0x85, 0x6, 0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE, 0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5, 0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF, 0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3, 0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D,
+       0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA, 0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2, 0x7D, 0x99, 0xD8, 0xD, 0x60, 0x8A, 0x4, 0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7, 0xE0, 0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D,
+       0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0, 0xDE, 0x95, 0x2E, 0xDC, 0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC, 0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8, 0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57,
+       0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB, 0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1, 0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D,
+       0xBF, 0x33, 0x9C, 0x5F, 0x9, 0x94, 0xA3, 0x85, 0x6, 0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE, 0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5, 0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF, 0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3, 0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D,
+       0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA, 0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2, 0x7D, 0x99, 0xD8, 0xD, 0x60, 0x8A, 0x4, 0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7, 0xE0, 0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D,
+       0xA2, 0xA0
+};
 
 
-static float g[512+2][3]= {
+static float g[512 + 2][3] = {
        {0.33783, 0.715698, -0.611206},
        {-0.944031, -0.326599, -0.045624},
        {-0.101074, -0.416443, -0.903503},
@@ -1005,15 +1006,15 @@ static float noise3_perlin(float vec[3])
        SETUP(vec[1],  by0, by1,  ry0, ry1);
        SETUP(vec[2],  bz0, bz1,  rz0, rz1);
 
-       i = p[ bx0 ];
-       j = p[ bx1 ];
+       i = p[bx0];
+       j = p[bx1];
 
-       b00 = p[ i + by0 ];
-       b10 = p[ j + by0 ];
-       b01 = p[ i + by1 ];
-       b11 = p[ j + by1 ];
+       b00 = p[i + by0];
+       b10 = p[j + by0];
+       b01 = p[i + by1];
+       b11 = p[j + by1];
 
-#define VALUE_AT(rx,ry,rz) (rx * q[0] + ry * q[1] + rz * q[2])
+#define VALUE_AT(rx, ry, rz) (rx * q[0] + ry * q[1] + rz * q[2])
 #define SURVE(t) (t * t * (3.0f - 2.0f * t))
 
 /* lerp moved to improved perlin above */
@@ -1023,30 +1024,30 @@ static float noise3_perlin(float vec[3])
        sz = SURVE(rz0);
 
 
-       q = g[ b00 + bz0 ];
-       u = VALUE_AT(rx0,ry0,rz0);
-       q = g[ b10 + bz0 ];
-       v = VALUE_AT(rx1,ry0,rz0);
+       q = g[b00 + bz0];
+       u = VALUE_AT(rx0, ry0, rz0);
+       q = g[b10 + bz0];
+       v = VALUE_AT(rx1, ry0, rz0);
        a = lerp(sx, u, v);
 
-       q = g[ b01 + bz0 ];
-       u = VALUE_AT(rx0,ry1,rz0);
-       q = g[ b11 + bz0 ];
-       v = VALUE_AT(rx1,ry1,rz0);
+       q = g[b01 + bz0];
+       u = VALUE_AT(rx0, ry1, rz0);
+       q = g[b11 + bz0];
+       v = VALUE_AT(rx1, ry1, rz0);
        b = lerp(sx, u, v);
 
        c = lerp(sy, a, b);          /* interpolate in y at lo x */
 
-       q = g[ b00 + bz1 ];
-       u = VALUE_AT(rx0,ry0,rz1);
-       q = g[ b10 + bz1 ];
-       v = VALUE_AT(rx1,ry0,rz1);
+       q = g[b00 + bz1];
+       u = VALUE_AT(rx0, ry0, rz1);
+       q = g[b10 + bz1];
+       v = VALUE_AT(rx1, ry0, rz1);
        a = lerp(sx, u, v);
 
-       q = g[ b01 + bz1 ];
-       u = VALUE_AT(rx0,ry1,rz1);
-       q = g[ b11 + bz1 ];
-       v = VALUE_AT(rx1,ry1,rz1);
+       q = g[b01 + bz1];
+       u = VALUE_AT(rx0, ry1, rz1);
+       q = g[b11 + bz1];
+       v = VALUE_AT(rx1, ry1, rz1);
        b = lerp(sx, u, v);
 
        d = lerp(sy, a, b);          /* interpolate in y at hi x */
@@ -1067,7 +1068,7 @@ static float turbulence_perlin(float *point, float lofreq, float hifreq)
        p[2] = point[2];
 
        t = 0;
-       for (freq = lofreq ; freq < hifreq ; freq *= 2.0) {
+       for (freq = lofreq; freq < hifreq; freq *= 2.0) {
                t += fabsf(noise3_perlin(p)) / freq;
                p[0] *= 2.0f;
                p[1] *= 2.0f;
@@ -1096,7 +1097,7 @@ static float orgPerlinNoiseU(float x, float y, float z)
        v[0] = x;
        v[1] = y;
        v[2] = z;
-       return (0.5f+0.5f*noise3_perlin(v));
+       return (0.5f + 0.5f * noise3_perlin(v));
 }
 
 /* *************** CALL AS: *************** */
@@ -1105,9 +1106,9 @@ float BLI_hnoisep(float noisesize, float x, float y, float z)
 {
        float vec[3];
 
-       vec[0]= x/noisesize;
-       vec[1]= y/noisesize;
-       vec[2]= z/noisesize;
+       vec[0] = x / noisesize;
+       vec[1] = y / noisesize;
+       vec[2] = z / noisesize;
 
        return noise3_perlin(vec);
 }
@@ -1117,11 +1118,11 @@ static float turbulencep(float noisesize, float x, float y, float z, int nr)
 {
        float vec[3];
 
-       vec[0]= x/noisesize;
-       vec[1]= y/noisesize;
-       vec[2]= z/noisesize;
+       vec[0] = x / noisesize;
+       vec[1] = y / noisesize;
+       vec[2] = z / noisesize;
        nr++;
-       return turbulence_perlin(vec, 1.0, (float)(1<<nr));
+       return turbulence_perlin(vec, 1.0, (float)(1 << nr));
 }
 #endif
 
@@ -1133,11 +1134,17 @@ static float turbulencep(float noisesize, float x, float y, float z, int nr)
 /* Camberra omitted, didn't seem useful */
 
 /* distance squared */
-static float dist_Squared(float x, float y, float z, float e) { (void)e; return (x*x + y*y + z*z); }
+static float dist_Squared(float x, float y, float z, float e) {
+       (void)e; return (x * x + y * y + z * z);
+}
 /* real distance */
-static float dist_Real(float x, float y, float z, float e) { (void)e; return sqrtf(x*x + y*y + z*z); }
+static float dist_Real(float x, float y, float z, float e) {
+       (void)e; return sqrtf(x * x + y * y + z * z);
+}
 /* manhattan/taxicab/cityblock distance */
-static float dist_Manhattan(float x, float y, float z, float e) { (void)e; return (fabsf(x) + fabsf(y) + fabsf(z)); }
+static float dist_Manhattan(float x, float y, float z, float e) {
+       (void)e; return (fabsf(x) + fabsf(y) + fabsf(z));
+}
 /* Chebychev */
 static float dist_Chebychev(float x, float y, float z, float e)
 {
@@ -1147,8 +1154,8 @@ static float dist_Chebychev(float x, float y, float z, float e)
        x = fabsf(x);
        y = fabsf(y);
        z = fabsf(z);
-       t = (x>y)?x:y;
-       return ((z>t)?z:t);
+       t = (x > y) ? x : y;
+       return ((z > t) ? z : t);
 }
 
 /* minkovsky preset exponent 0.5 */
@@ -1156,7 +1163,7 @@ static float dist_MinkovskyH(float x, float y, float z, float e)
 {
        float d = sqrtf(fabsf(x)) + sqrtf(fabsf(y)) + sqrtf(fabsf(z));
        (void)e;
-       return (d*d);
+       return (d * d);
 }
 
 /* minkovsky preset exponent 4 */
@@ -1166,19 +1173,19 @@ static float dist_Minkovsky4(float x, float y, float z, float e)
        x *= x;
        y *= y;
        z *= z;
-       return sqrtf(sqrtf(x*x + y*y + z*z));
+       return sqrtf(sqrtf(x * x + y * y + z * z));
 }
 
 /* Minkovsky, general case, slow, maybe too slow to be useful */
 static float dist_Minkovsky(float x, float y, float z, float e)
 {
-       return powf(powf(fabsf(x), e) + powf(fabsf(y), e) + powf(fabsf(z), e), 1.0f/e);
+       return powf(powf(fabsf(x), e) + powf(fabsf(y), e) + powf(fabsf(z), e), 1.0f / e);
 }
 
 
 /* Not 'pure' Worley, but the results are virtually the same.
  * Returns distances in da and point coords in pa */
-void voronoi(float x, float y, float z, float* da, float* pa, float me, int dtype)
+void voronoi(float x, float y, float z, float *da, float *pa, float me, int dtype)
 {
        int xx, yy, zz, xi, yi, zi;
        float xd, yd, zd, d, *p;
@@ -1212,35 +1219,35 @@ void voronoi(float x, float y, float z, float* da, float* pa, float me, int dtyp
        yi = (int)(floor(y));
        zi = (int)(floor(z));
        da[0] = da[1] = da[2] = da[3] = 1e10f;
-       for (xx=xi-1;xx<=xi+1;xx++) {
-               for (yy=yi-1;yy<=yi+1;yy++) {
-                       for (zz=zi-1;zz<=zi+1;zz++) {
+       for (xx = xi - 1; xx <= xi + 1; xx++) {
+               for (yy = yi - 1; yy <= yi + 1; yy++) {
+                       for (zz = zi - 1; zz <= zi + 1; zz++) {
                                p = HASHPNT(xx, yy, zz);
                                xd = x - (p[0] + xx);
                                yd = y - (p[1] + yy);
                                zd = z - (p[2] + zz);
                                d = distfunc(xd, yd, zd, me);
-                               if (d<da[0]) {
-                                       da[3]=da[2];  da[2]=da[1];  da[1]=da[0];  da[0]=d;
-                                       pa[9]=pa[6];  pa[10]=pa[7];  pa[11]=pa[8];
-                                       pa[6]=pa[3];  pa[7]=pa[4];  pa[8]=pa[5];
-                                       pa[3]=pa[0];  pa[4]=pa[1];  pa[5]=pa[2];
-                                       pa[0]=p[0]+xx;  pa[1]=p[1]+yy;  pa[2]=p[2]+zz;
+                               if (d < da[0]) {
+                                       da[3] = da[2];  da[2] = da[1];  da[1] = da[0];  da[0] = d;
+                                       pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
+                                       pa[6] = pa[3];  pa[7] = pa[4];  pa[8] = pa[5];
+                                       pa[3] = pa[0];  pa[4] = pa[1];  pa[5] = pa[2];
+                                       pa[0] = p[0] + xx;  pa[1] = p[1] + yy;  pa[2] = p[2] + zz;
                                }
-                               else if (d<da[1]) {
-                                       da[3]=da[2];  da[2]=da[1];  da[1]=d;
-                                       pa[9]=pa[6];  pa[10]=pa[7];  pa[11]=pa[8];
-                                       pa[6]=pa[3];  pa[7]=pa[4];  pa[8]=pa[5];
-                                       pa[3]=p[0]+xx;  pa[4]=p[1]+yy;  pa[5]=p[2]+zz;
+                               else if (d < da[1]) {
+                                       da[3] = da[2];  da[2] = da[1];  da[1] = d;
+                                       pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
+                                       pa[6] = pa[3];  pa[7] = pa[4];  pa[8] = pa[5];
+                                       pa[3] = p[0] + xx;  pa[4] = p[1] + yy;  pa[5] = p[2] + zz;
                                }
-                               else if (d<da[2]) {
-                                       da[3]=da[2];  da[2]=d;
-                                       pa[9]=pa[6];  pa[10]=pa[7];  pa[11]=pa[8];
-                                       pa[6]=p[0]+xx;  pa[7]=p[1]+yy;  pa[8]=p[2]+zz;
+                               else if (d < da[2]) {
+                                       da[3] = da[2];  da[2] = d;
+                                       pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
+                                       pa[6] = p[0] + xx;  pa[7] = p[1] + yy;  pa[8] = p[2] + zz;
                                }
-                               else if (d<da[3]) {
-                                       da[3]=d;
-                                       pa[9]=p[0]+xx;  pa[10]=p[1]+yy;  pa[11]=p[2]+zz;
+                               else if (d < da[3]) {
+                                       da[3] = d;
+                                       pa[9] = p[0] + xx;  pa[10] = p[1] + yy;  pa[11] = p[2] + zz;
                                }
                        }
                }
@@ -1280,14 +1287,14 @@ static float voronoi_F1F2(float x, float y, float z)
 {
        float da[4], pa[12];
        voronoi(x, y, z, da, pa, 1, 0);
-       return (da[1]-da[0]);
+       return (da[1] - da[0]);
 }
 
 /* Crackle type pattern, just a scale/clamp of F2-F1 */
 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;
+       float t = 10 * voronoi_F1F2(x, y, z);
+       if (t > 1.f) return 1.f;
        return t;
 }
 
@@ -1298,43 +1305,43 @@ static float voronoi_F1S(float x, float y, float z)
 {
        float da[4], pa[12];
        voronoi(x, y, z, da, pa, 1, 0);
-       return (2.0f*da[0]-1.0f);
+       return (2.0f * da[0] - 1.0f);
 }
 
 static float voronoi_F2S(float x, float y, float z)
 {
        float da[4], pa[12];
        voronoi(x, y, z, da, pa, 1, 0);
-       return (2.0f*da[1]-1.0f);
+       return (2.0f * da[1] - 1.0f);
 }
 
 static float voronoi_F3S(float x, float y, float z)
 {
        float da[4], pa[12];
        voronoi(x, y, z, da, pa, 1, 0);
-       return (2.0f*da[2]-1.0f);
+       return (2.0f * da[2] - 1.0f);
 }
 
 static float voronoi_F4S(float x, float y, float z)
 {
        float da[4], pa[12];
        voronoi(x, y, z, da, pa, 1, 0);
-       return (2.0f*da[3]-1.0f);
+       return (2.0f * da[3] - 1.0f);
 }
 
 static float voronoi_F1F2S(float x, float y, float z)
 {
        float da[4], pa[12];
        voronoi(x, y, z, da, pa, 1, 0);
-       return (2.0f*(da[1]-da[0])-1.0f);
+       return (2.0f * (da[1] - da[0]) - 1.0f);
 }
 
 /* Crackle type pattern, just a scale/clamp of F2-F1 */
 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;
-       return (2.0f*t-1.0f);
+       float t = 10 * voronoi_F1F2(x, y, z);
+       if (t > 1.f) return 1.f;
+       return (2.0f * t - 1.0f);
 }
 
 
@@ -1352,15 +1359,15 @@ static float cellNoiseU(float x, float y, float z)
        int xi = (int)(floor(x));
        int yi = (int)(floor(y));
        int zi = (int)(floor(z));
-       unsigned int n = xi + yi*1301 + zi*314159;
-       n ^= (n<<13);
-       return ((float)(n*(n*n*15731 + 789221) + 1376312589) / 4294967296.0f);
+       unsigned int n = xi + yi * 1301 + zi * 314159;
+       n ^= (n << 13);
+       return ((float)(n * (n * n * 15731 + 789221) + 1376312589) / 4294967296.0f);
 }
 
 /* idem, signed */
 float cellNoise(float x, float y, float z)
 {
-       return (2.0f*cellNoiseU(x, y, z)-1.0f);
+       return (2.0f * cellNoiseU(x, y, z) - 1.0f);
 }
 
 /* returns a vector/point/color in ca, using point hasharray directly */
@@ -1423,14 +1430,14 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
                }
        }
 
-       if (noisesize!=0.0f) {
-               noisesize = 1.0f/noisesize;
+       if (noisesize != 0.0f) {
+               noisesize = 1.0f / noisesize;
                x *= noisesize;
                y *= noisesize;
                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);
 }
 
@@ -1438,7 +1445,7 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
 float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int hard, int noisebasis)
 {
        float (*noisefunc)(float, float, float);
-       float sum, t, amp=1, fscale=1;
+       float sum, t, amp = 1, fscale = 1;
        int i;
        
        switch (noisebasis) {
@@ -1477,21 +1484,21 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
                        z += 1;
        }
 
-       if (noisesize!=0.0f) {
-               noisesize = 1.0f/noisesize;
+       if (noisesize != 0.0f) {
+               noisesize = 1.0f / noisesize;
                x *= noisesize;
                y *= noisesize;
                z *= noisesize;
        }
 
        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);
+       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);
                sum += t * amp;
        }
        
-       sum *= ((float)(1<<oct)/(float)((1<<(oct+1))-1));
+       sum *= ((float)(1 << oct) / (float)((1 << (oct + 1)) - 1));
 
        return sum;
 
@@ -1513,8 +1520,8 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
  */
 float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves, int noisebasis)
 {
-       float   rmd, value=0.0, pwr=1.0, pwHL=powf(lacunarity, -H);
-       int     i;
+       float rmd, value = 0.0, pwr = 1.0, pwHL = powf(lacunarity, -H);
+       int i;
 
        float (*noisefunc)(float, float, float);
        switch (noisebasis) {
@@ -1551,7 +1558,7 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
                }
        }
        
-       for (i=0; i<(int)octaves; i++) {
+       for (i = 0; i < (int)octaves; i++) {
                value += noisefunc(x, y, z) * pwr;
                pwr *= pwHL;
                x *= lacunarity;
@@ -1560,7 +1567,7 @@ 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.f) value += rmd * noisefunc(x, y, z) * pwr;
 
        return value;
 
@@ -1583,7 +1590,7 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
  * I modified it to something that made sense to me, so it might be wrong... */
 float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, int noisebasis)
 {
-       float   rmd, value=1.0, pwr=1.0, pwHL=powf(lacunarity, -H);
+       float rmd, value = 1.0, pwr = 1.0, pwHL = powf(lacunarity, -H);
        int i;
 
        float (*noisefunc)(float, float, float);
@@ -1621,7 +1628,7 @@ float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, floa
                }
        }
 
-       for (i=0; i<(int)octaves; i++) {
+       for (i = 0; i < (int)octaves; i++) {
                value *= (pwr * noisefunc(x, y, z) + 1.0f);
                pwr *= pwHL;
                x *= lacunarity;
@@ -1629,7 +1636,7 @@ 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;
 
@@ -1647,10 +1654,10 @@ float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, floa
  */
 float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, float octaves, float offset, int noisebasis)
 {
-       float   value, increment, rmd;
+       float value, increment, rmd;
        int i;
        float pwHL = powf(lacunarity, -H);
-       float pwr = pwHL;       /* starts with i=1 instead of 0 */
+       float pwr = pwHL;   /* starts with i=1 instead of 0 */
 
        float (*noisefunc)(float, float, float);
        switch (noisebasis) {
@@ -1693,7 +1700,7 @@ float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, flo
        y *= lacunarity;
        z *= lacunarity;
 
-       for (i=1; i<(int)octaves; i++) {
+       for (i = 1; i < (int)octaves; i++) {
                increment = (noisefunc(x, y, z) + offset) * pwr * value;
                value += increment;
                pwr *= pwHL;
@@ -1703,7 +1710,7 @@ float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, flo
        }
 
        rmd = octaves - floorf(octaves);
-       if (rmd!=0.0f) {
+       if (rmd != 0.0f) {
                increment = (noisefunc(x, y, z) + offset) * pwr * value;
                value += rmd * increment;
        }
@@ -1723,7 +1730,7 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
        float result, signal, weight, rmd;
        int i;
        float pwHL = powf(lacunarity, -H);
-       float pwr = pwHL;       /* starts with i=1 instead of 0 */
+       float pwr = pwHL;   /* starts with i=1 instead of 0 */
        float (*noisefunc)(float, float, float);
 
        switch (noisebasis) {
@@ -1766,8 +1773,8 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
        y *= lacunarity;
        z *= lacunarity;
 
-       for (i=1; (weight>0.001f) && (i<(int)octaves); i++) {
-               if (weight>1.0f)  weight=1.0f;
+       for (i = 1; (weight > 0.001f) && (i < (int)octaves); i++) {
+               if (weight > 1.0f) weight = 1.0f;
                signal = (noisefunc(x, y, z) + offset) * pwr;
                pwr *= pwHL;
                result += weight * signal;
@@ -1778,7 +1785,7 @@ 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;
 
@@ -1796,9 +1803,9 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
 float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, float offset, float gain, int noisebasis)
 {
        float result, signal, weight;
-       int     i;
+       int i;
        float pwHL = powf(lacunarity, -H);
-       float pwr = pwHL;       /* starts with i=1 instead of 0 */
+       float pwr = pwHL;   /* starts with i=1 instead of 0 */
        
        float (*noisefunc)(float, float, float);
        switch (noisebasis) {
@@ -1840,12 +1847,12 @@ float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity
        result = signal;
 
 
-       for ( i=1; i<(int)octaves; i++ ) {
+       for (i = 1; i < (int)octaves; i++) {
                x *= 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;
@@ -1934,10 +1941,10 @@ float mg_VLNoise(float x, float y, float z, float distortion, int nbas1, int nba
        }
 
        /* get a random vector and scale the randomization */
-       rv[0] = noisefunc1(x+13.5f, y+13.5f, z+13.5f) * distortion;
+       rv[0] = noisefunc1(x + 13.5f, y + 13.5f, z + 13.5f) * distortion;
        rv[1] = noisefunc1(x, y, z) * distortion;
-       rv[2] = noisefunc1(x-13.5f, y-13.5f, z-13.5f) * distortion;
-       return noisefunc2(x+rv[0], y+rv[1], z+rv[2]);   /* distorted-domain noise */
+       rv[2] = noisefunc1(x - 13.5f, y - 13.5f, z - 13.5f) * distortion;
+       return noisefunc2(x + rv[0], y + rv[1], z + rv[2]);   /* distorted-domain noise */
 }
 
 /****************/
index b2e6cab..4435e9c 100644 (file)
 #include "BLI_rand.h"
 
 #if defined(WIN32) && !defined(FREE_WINDOWS)
-typedef unsigned __int64       r_uint64;
+typedef unsigned __int64 r_uint64;
 
-#define MULTIPLIER     0x5DEECE66Di64 
-#define MASK           0x0000FFFFFFFFFFFFi64
+#define MULTIPLIER  0x5DEECE66Di64
+#define MASK        0x0000FFFFFFFFFFFFi64
 #else
-typedef unsigned long long     r_uint64;
+typedef unsigned long long r_uint64;
 
-#define MULTIPLIER     0x5DEECE66Dll
-#define MASK           0x0000FFFFFFFFFFFFll
+#define MULTIPLIER  0x5DEECE66Dll
+#define MASK        0x0000FFFFFFFFFFFFll
 #endif
 
-#define ADDEND         0xB
+#define ADDEND      0xB
 
-#define LOWSEED                0x330E
+#define LOWSEED     0x330E
 
-extern unsigned char hash[];   // noise.c
+extern unsigned char hash[];    // noise.c
 
 /***/
 
@@ -64,7 +64,7 @@ struct RNG {
        r_uint64 X;
 };
 
-RNG    *rng_new(unsigned int seed)
+RNG *rng_new(unsigned int seed)
 {
        RNG *rng = MEM_mallocN(sizeof(*rng), "rng");
 
@@ -73,39 +73,39 @@ RNG *rng_new(unsigned int seed)
        return rng;
 }
 
-void rng_free(RNGrng)
+void rng_free(RNG *rng)
 {
        MEM_freeN(rng);
 }
 
 void rng_seed(RNG *rng, unsigned int seed)
 {
-       rng->X= (((r_uint64) seed)<<16) | LOWSEED;
+       rng->X = (((r_uint64) seed) << 16) | LOWSEED;
 }
 
 void rng_srandom(RNG *rng, unsigned int seed)
 {
        rng_seed(rng, seed + hash[seed & 255]);
-       seed= rng_getInt(rng);
+       seed = rng_getInt(rng);
        rng_seed(rng, seed + hash[seed & 255]);
-       seed= rng_getInt(rng);
+       seed = rng_getInt(rng);
        rng_seed(rng, seed + hash[seed & 255]);
 }
 
 int rng_getInt(RNG *rng)
 {
-       rng->X= (MULTIPLIER*rng->X + ADDEND)&MASK;
-       return (int) (rng->X>>17);
+       rng->X = (MULTIPLIER * rng->X + ADDEND) & MASK;
+       return (int) (rng->X >> 17);
 }
 
 double rng_getDouble(RNG *rng)
 {
-       return (double) rng_getInt(rng)/0x80000000;
+       return (double) rng_getInt(rng) / 0x80000000;
 }
 
 float rng_getFloat(RNG *rng)
 {
-       return (float) rng_getInt(rng)/0x80000000;
+       return (float) rng_getInt(rng) / 0x80000000;
 }
 
 void rng_shuffleArray(RNG *rng, void *data, int elemSize, int numElems)
@@ -122,10 +122,10 @@ void rng_shuffleArray(RNG *rng, void *data, int elemSize, int numElems)
        /* XXX Shouldn't it rather be "while (i--) {" ?
         *     Else we have no guaranty first (0) element has a chance to be shuffled... --mont29 */
        while (--i) {
-               int j = rng_getInt(rng)%numElems;
-               if (i!=j) {
-                       void *iElem = (unsigned char*)data + i*elemSize;
-                       void *jElem = (unsigned char*)data + j*elemSize;
+               int j = rng_getInt(rng) % numElems;
+               if (i != j) {
+                       void *iElem = (unsigned char *)data + i * elemSize;
+                       void *jElem = (unsigned char *)data + j * elemSize;
                        memcpy(temp, iElem, elemSize);
                        memcpy(iElem, jElem, elemSize);
                        memcpy(jElem, temp, elemSize);
@@ -139,7 +139,7 @@ void rng_skip(RNG *rng, int n)
 {
        int i;
 
-       for (i=0; i<n; i++)
+       for (i = 0; i < n; i++)
                rng_getInt(rng);
 }
 
@@ -177,10 +177,10 @@ float BLI_frand(void)
 void BLI_fillrand(void *addr, int len)
 {
        RNG rng;
-       unsigned char *p= addr;
+       unsigned char *p = addr;
 
-       rng_seed(&rng, (unsigned int) (PIL_check_seconds_timer()*0x7FFFFFFF));
-       while (len--) *p++= rng_getInt(&rng)&0xFF;
+       rng_seed(&rng, (unsigned int) (PIL_check_seconds_timer() * 0x7FFFFFFF));
+       while (len--) *p++ = rng_getInt(&rng) & 0xFF;
 }
 
 void BLI_array_randomize(void *data, int elemSize, int numElems, unsigned int seed)
@@ -198,12 +198,12 @@ static RNG rng_tab[BLENDER_MAX_THREADS];
 void BLI_thread_srandom(int thread, unsigned int seed)
 {
        if (thread >= BLENDER_MAX_THREADS)
-               thread= 0;
+               thread = 0;
        
        rng_seed(&rng_tab[thread], seed + hash[seed & 255]);
-       seed= rng_getInt(&rng_tab[thread]);
+       seed = rng_getInt(&rng_tab[thread]);
        rng_seed(&rng_tab[thread], seed + hash[seed & 255]);
-       seed= rng_getInt(&rng_tab[thread]);
+       seed = rng_getInt(&rng_tab[thread]);
        rng_seed(&rng_tab[thread], seed + hash[seed & 255]);
 }
 
index fb03849..92125c6 100644 (file)
@@ -40,8 +40,8 @@
  *
  * note: these have the SMHASH suffix because we may want to make them public.
  */
-#define SMHASH_CELL_UNUSED     ((void *)0x7FFFFFFF)
-#define SMHASH_CELL_FREE       ((void *)0x7FFFFFFD)
+#define SMHASH_CELL_UNUSED  ((void *)0x7FFFFFFF)
+#define SMHASH_CELL_FREE    ((void *)0x7FFFFFFD)
 
 #define SMHASH_NONZERO(n) ((n) + !(n))
 #define SMHASH_NEXT(h, hoff) ABS(((h) + ((hoff = SMHASH_NONZERO(hoff * 2) + 1), hoff)))
@@ -80,7 +80,7 @@ void BLI_smallhash_release(SmallHash *hash)
 
 void BLI_smallhash_insert(SmallHash *hash, uintptr_t key, void *item)
 {
-       int h, hoff=1;
+       int h, hoff = 1;
 
        if (hash->size < hash->used * 3) {
                int newsize = hashsizes[++hash->curhash];
@@ -103,7 +103,7 @@ void BLI_smallhash_insert(SmallHash *hash, uintptr_t key, void *item)
                        hash->table[i].val = SMHASH_CELL_FREE;
                }
 
-               for (i = 0; i<hashsizes[hash->curhash - 1]; i++) {
+               for (i = 0; i < hashsizes[hash->curhash - 1]; i++) {
                        if (ELEM(tmp[i].val, SMHASH_CELL_UNUSED, SMHASH_CELL_FREE)) {
                                continue;
                        }
@@ -141,7 +141,7 @@ void BLI_smallhash_insert(SmallHash *hash, uintptr_t key, void *item)
 
 void BLI_smallhash_remove(SmallHash *hash, uintptr_t key)
 {
-       int h, hoff=1;
+       int h, hoff = 1;
 
        h = ABS((int)key);
 
@@ -162,7 +162,7 @@ void BLI_smallhash_remove(SmallHash *hash, uintptr_t key)
 
 void *BLI_smallhash_lookup(SmallHash *hash, uintptr_t key)
 {
-       int h, hoff=1;
+       int h, hoff = 1;
        void *v;
 
        h = ABS((int)key);
@@ -193,7 +193,7 @@ void *BLI_smallhash_lookup(SmallHash *hash, uintptr_t key)
 int BLI_smallhash_haskey(SmallHash *hash, uintptr_t key)
 {
        int h = ABS((int)key);
-       int hoff =1;
+       int hoff = 1;
 
        if (hash->table == NULL) {
                return 0;
@@ -251,21 +251,21 @@ void *BLI_smallhash_iternew(SmallHash *hash, SmallHashIter *iter, uintptr_t *key
 #if 0
 void BLI_smallhash_print(SmallHash *hash)
 {
-       int i, linecol=79, c=0;
+       int i, linecol = 79, c = 0;
 
        printf("{");
-       for (i=0; i<hash->size; i++) {
+       for (i = 0; i < hash->size; i++) {
                if (hash->table[i].val == SMHASH_CELL_UNUSED) {
                        printf("--u-");
                }
                else if (hash->table[i].val == SMHASH_CELL_FREE) {
                        printf("--f-");
                }
-               else    {
+               else {
                        printf("%2x", (unsigned int)hash->table[i].key);
                }
 
-               if (i != hash->size-1)
+               if (i != hash->size - 1)
                        printf(", ");
 
                c += 6;
index 047463f..d4f251d 100644 (file)
 #include <time.h>
 #include <sys/stat.h>
 
-#if defined (__sun__) || defined (__sun) || defined (__NetBSD__)
+#if defined(__sun__) || defined(__sun) || defined(__NetBSD__)
 #include <sys/statvfs.h> /* Other modern unix os's should probably use this also */
 #elif !defined(__FreeBSD__) && !defined(linux) && (defined(__sparc) || defined(__sparc__))
 #include <sys/statfs.h>
 #endif
 
-#if defined (__FreeBSD__) || defined (__OpenBSD__)
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
 #include <sys/param.h>
 #include <sys/mount.h>
 #endif
@@ -66,7 +66,7 @@
 
 
 #include <fcntl.h>
-#include <string.h>                    /* strcpy etc.. */
+#include <string.h>  /* strcpy etc.. */
 
 #ifdef WIN32
 #  include <io.h>
 static int totnum, actnum;
 static struct direntry *files;
 
-static struct ListBase dirbase_={NULL, NULL};
+static struct ListBase dirbase_ = {NULL, NULL};
 static struct ListBase *dirbase = &dirbase_;
 
 /* can return NULL when the size is not big enough */
 char *BLI_current_working_dir(char *dir, const int maxncpy)
 {
-       const char *pwd= getenv("PWD");
+       const char *pwd = getenv("PWD");
        if (pwd) {
                BLI_strncpy(dir, pwd, maxncpy);
                return dir;
@@ -119,13 +119,13 @@ static int bli_compare(struct direntry *entry1, struct direntry *entry2)
        /* type is equal to stat.st_mode */
 
        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_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);
@@ -134,10 +134,10 @@ static int bli_compare(struct direntry *entry1, struct direntry *entry2)
        if ((entry1->type & S_IFMT) > (entry2->type & S_IFMT)) return (1);
        
        /* make sure "." and ".." are always first */
-       if ( strcmp(entry1->relname, ".")==0 ) return (-1);
-       if ( strcmp(entry2->relname, ".")==0 ) return (1);
-       if ( strcmp(entry1->relname, "..")==0 ) return (-1);
-       if ( strcmp(entry2->relname, "..")==0 ) return (1);
+       if (strcmp(entry1->relname, ".") == 0) return (-1);
+       if (strcmp(entry2->relname, ".") == 0) return (1);
+       if (strcmp(entry1->relname, "..") == 0) return (-1);
+       if (strcmp(entry2->relname, "..") == 0) return (1);
 
        return (BLI_natstrcmp(entry1->relname, entry2->relname));
 }
@@ -149,24 +149,24 @@ double BLI_dir_free_space(const char *dir)
        DWORD sectorspc, bytesps, freec, clusters;
        char tmp[4];
        
-       tmp[0]='\\'; tmp[1]=0; /* Just a failsafe */
-       if (dir[0]=='/' || dir[0]=='\\') {
-               tmp[0]='\\';
-               tmp[1]=0;
+       tmp[0] = '\\'; tmp[1] = 0; /* Just a failsafe */
+       if (dir[0] == '/' || dir[0] == '\\') {
+               tmp[0] = '\\';
+               tmp[1] = 0;
        }
-       else if (dir[1]==':') {
-               tmp[0]=dir[0];
-               tmp[1]=':';
-               tmp[2]='\\';
-               tmp[3]=0;
+       else if (dir[1] == ':') {
+               tmp[0] = dir[0];
+               tmp[1] = ':';
+               tmp[2] = '\\';
+               tmp[3] = 0;
        }
 
        GetDiskFreeSpace(tmp, &sectorspc, &bytesps, &freec, &clusters);
 
-       return (double) (freec*bytesps*sectorspc);
+       return (double) (freec * bytesps * sectorspc);
 #else
 
-#if defined (__sun__) || defined (__sun) || defined (__NetBSD__)
+#if defined(__sun__) || defined(__sun) || defined(__NetBSD__)
        struct statvfs disk;
 #else
        struct statfs disk;
@@ -185,11 +185,11 @@ double BLI_dir_free_space(const char *dir)
        }
        else strcpy(name, "/");
 
-#if defined (__FreeBSD__) || defined (linux) || defined (__OpenBSD__) || defined (__APPLE__) || defined(__GNU__) || defined(__GLIBC__)
+#if defined(__FreeBSD__) || defined(linux) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__GNU__) || defined(__GLIBC__)
        if (statfs(name, &disk)) return(-1);
 #endif
 
-#if defined (__sun__) || defined (__sun) || defined (__NetBSD__)
+#if defined(__sun__) || defined(__sun) || defined(__NetBSD__)
        if (statvfs(name, &disk)) return(-1);   
 #elif !defined(__FreeBSD__) && !defined(linux) && (defined(__sparc) || defined(__sparc__))
        /* WARNING - This may not be supported by geeneric unix os's - Campbell */
@@ -209,10 +209,10 @@ static void bli_builddir(const char *dirname, const char *relname)
        DIR *dir;
 
        BLI_strncpy(buf, relname, sizeof(buf));
-       rellen=strlen(relname);
+       rellen = strlen(relname);
 
        if (rellen) {
-               buf[rellen]='/';
+               buf[rellen] = '/';
                rellen++;
        }
 #ifndef WIN32
@@ -231,7 +231,7 @@ static void bli_builddir(const char *dirname, const char *relname)
 
 #endif
        if ((dir = (DIR *)opendir("."))) {
-               while ((fname = (struct dirent*) readdir(dir)) != NULL) {
+               while ((fname = (struct dirent *) readdir(dir)) != NULL) {
                        dlink = (struct dirlink *)malloc(sizeof(struct dirlink));
                        if (dlink) {
                                BLI_strncpy(buf + rellen, fname->d_name, sizeof(buf) - rellen);
@@ -244,7 +244,7 @@ static void bli_builddir(const char *dirname, const char *relname)
                if (newnum) {
 
                        if (files) {
-                               void *tmp = realloc(files, (totnum+newnum) * sizeof(struct direntry));
+                               void *tmp = realloc(files, (totnum + newnum) * sizeof(struct direntry));
                                if (tmp) {
                                        files = (struct direntry *)tmp;
                                }
@@ -254,8 +254,8 @@ static void bli_builddir(const char *dirname, const char *relname)
                                }
                        }
                        
-                       if (files==NULL)
-                               files=(struct direntry *)malloc(newnum * sizeof(struct direntry));
+                       if (files == NULL)
+                               files = (struct direntry *)malloc(newnum * sizeof(struct direntry));
 
                        if (files) {
                                dlink = (struct dirlink *) dirbase->first;
@@ -266,18 +266,20 @@ static void bli_builddir(const char *dirname, const char *relname)
 // use 64 bit file size, only needed for WIN32 and WIN64. 
 // Excluding other than current MSVC compiler until able to test
 #ifdef WIN32
-                                       {wchar_t * name_16 = alloc_utf16_from_8(dlink->name, 0);
-#if (defined(WIN32) || defined(WIN64)) && (_MSC_VER>=1500)
-                                       _wstat64(name_16, &files[actnum].s);
+                                       {
+                                               wchar_t *name_16 = alloc_utf16_from_8(dlink->name, 0);
+#if (defined(WIN32) || defined(WIN64)) && (_MSC_VER >= 1500)
+                                               _wstat64(name_16, &files[actnum].s);
 #elif defined(__MINGW32__)
-                                       _stati64(dlink->name, &files[actnum].s);
+                                               _stati64(dlink->name, &files[actnum].s);
 #endif
-                                       free(name_16);};
+                                               free(name_16);
+                                       }
 
 #else
                                        stat(dlink->name, &files[actnum].s);
 #endif
-                                       files[actnum].type=files[actnum].s.st_mode;
+                                       files[actnum].type = files[actnum].s.st_mode;
                                        files[actnum].flags = 0;
                                        totnum++;
                                        actnum++;
@@ -290,7 +292,7 @@ static void bli_builddir(const char *dirname, const char *relname)
                        }
 
                        BLI_freelist(dirbase);
-                       if (files) qsort(files, actnum, sizeof(struct direntry), (int (*)(const void *, const void*))bli_compare);
+                       if (files) qsort(files, actnum, sizeof(struct direntry), (int (*)(const void *, const void *))bli_compare);
                }
                else {
                        printf("%s empty directory\n", dirname);
@@ -308,7 +310,7 @@ static void bli_adddirstrings(void)
        char datum[100];
        char buf[512];
        char size[250];
-       static const char * types[8] = {"---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"};
+       static const char *types[8] = {"---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"};
        int num, mode;
 #ifdef WIN32
        __int64 st_size;
@@ -316,11 +318,11 @@ static void bli_adddirstrings(void)
        off_t st_size;
 #endif
        
-       struct direntry * file;
+       struct direntry *file;
        struct tm *tm;
-       time_t zero= 0;
+       time_t zero = 0;
        
-       for (num=0, file= files; num<actnum; num++, file++) {
+       for (num = 0, file = files; num < actnum; num++, file++) {
 #ifdef WIN32
                mode = 0;
                BLI_strncpy(file->mode1, types[0], sizeof(file->mode1));
@@ -333,13 +335,13 @@ static void bli_adddirstrings(void)
                BLI_strncpy(file->mode2, types[(mode & 0070) >> 3], sizeof(file->mode2));
                BLI_strncpy(file->mode3, types[(mode & 0007)], sizeof(file->mode3));
                
-               if (((mode & S_ISGID) == S_ISGID) && (file->mode2[2]=='-'))file->mode2[2]='l';
+               if (((mode & S_ISGID) == S_ISGID) && (file->mode2[2] == '-')) file->mode2[2] = 'l';
 
                if (mode & (S_ISUID | S_ISGID)) {
-                       if (file->mode1[2]=='x') file->mode1[2]='s';
-                       else file->mode1[2]='S';
+                       if (file->mode1[2] == 'x') file->mode1[2] = 's';
+                       else file->mode1[2] = 'S';
 
-                       if (file->mode2[2]=='x')file->mode2[2]='s';
+                       if (file->mode2[2] == 'x') file->mode2[2] = 's';
                }
 
                if (mode & S_ISVTX) {
@@ -354,7 +356,7 @@ static void bli_adddirstrings(void)
                {
                        struct passwd *pwuser;
                        pwuser = getpwuid(file->s.st_uid);
-                       if ( pwuser ) {
+                       if (pwuser) {
                                BLI_strncpy(file->owner, pwuser->pw_name, sizeof(file->owner));
                        }
                        else {
@@ -363,9 +365,9 @@ static void bli_adddirstrings(void)
                }
 #endif
 
-               tm= localtime(&file->s.st_mtime);
+               tm = localtime(&file->s.st_mtime);
                // prevent impossible dates in windows
-               if (tm==NULL) tm= localtime(&zero);
+               if (tm == NULL) tm = localtime(&zero);
                strftime(file->time, sizeof(file->time), "%H:%M", tm);
                strftime(file->date, sizeof(file->date), "%d-%b-%y", tm);
 
@@ -374,16 +376,16 @@ static void bli_adddirstrings(void)
                 * will buy us some time until files get bigger than 4GB or until
                 * everyone starts using __USE_FILE_OFFSET64 or equivalent.
                 */
-               st_size= file->s.st_size;
+               st_size = file->s.st_size;
 
-               if (st_size > 1024*1024*1024) {
-                       BLI_snprintf(file->size, sizeof(file->size), "%.2f GB", ((double)st_size)/(1024*1024*1024));
+               if (st_size > 1024 * 1024 * 1024) {
+                       BLI_snprintf(file->size, sizeof(file->size), "%.2f GB", ((double)st_size) / (1024 * 1024 * 1024));
                }
-               else if (st_size > 1024*1024) {
-                       BLI_snprintf(file->size, sizeof(file->size), "%.1f MB", ((double)st_size)/(1024*1024));
+               else if (st_size > 1024 * 1024) {
+                       BLI_snprintf(file->size, sizeof(file->size), "%.1f MB", ((double)st_size) / (1024 * 1024));
                }
                else if (st_size > 1024) {
-                       BLI_snprintf(file->size, sizeof(file->size), "%d KB", (int)(st_size/1024));
+                       BLI_snprintf(file->size, sizeof(file->size), "%d KB", (int)(st_size / 1024));
                }
                else {
                        BLI_snprintf(file->size, sizeof(file->size), "%d B", (int)st_size);
@@ -401,7 +403,7 @@ static void bli_adddirstrings(void)
                }
                else if (st_size < 100 * 1000 * 1000) {
                        BLI_snprintf(size, sizeof(size), "%2d %03d %03d",
-                                    (int) (st_size / (1000 * 1000)), (int) ((st_size / 1000) % 1000), (int) ( st_size % 1000));
+                                    (int) (st_size / (1000 * 1000)), (int) ((st_size / 1000) % 1000), (int) (st_size % 1000));
                }
                else {
                        /* XXX, whats going on here?. 2x calls - campbell */
@@ -447,13 +449,13 @@ size_t BLI_file_descriptor_size(int file)
        struct stat buf;
 
        if (file <= 0) return (-1);
-       fstat(file, &buf);//CHANGE
+       fstat(file, &buf); /* CHANGE */
        return (buf.st_size);
 }
 
 size_t BLI_file_size(const char *path)
 {
-       int size, file = BLI_open(path, O_BINARY|O_RDONLY, 0);
+       int size, file = BLI_open(path, O_BINARY | O_RDONLY, 0);
        
        if (file == -1)
                return -1;
@@ -475,10 +477,10 @@ int BLI_exists(const char *name)
        /* in Windows stat doesn't recognize dir ending on a slash
         * To not break code where the ending slash is expected we
         * don't mess with the argument name directly here - elubie */
-       wchar_t * tmp_16 = alloc_utf16_from_8(name, 0);
+       wchar_t *tmp_16 = alloc_utf16_from_8(name, 0);
        int len, res;
        len = wcslen(tmp_16);
-       if (len > 3 && ( tmp_16[len-1]==L'\\' || tmp_16[len-1]==L'/') ) tmp_16[len-1] = '\0';
+       if (len > 3 && (tmp_16[len - 1] == L'\\' || tmp_16[len - 1] == L'/') ) tmp_16[len - 1] = '\0';
 #ifndef __MINGW32__
        res = _wstat(tmp_16, &st);
 #else
@@ -499,7 +501,7 @@ int BLI_stat(const char *path, struct stat *buffer)
 {
        int r;
        UTF16_ENCODE(path);
-       r=_wstat(path_16,buffer);
+       r = _wstat(path_16, buffer);
        UTF16_UN_ENCODE(path);
        return r;
 }
@@ -518,39 +520,39 @@ int BLI_is_dir(const char *file)
 
 int BLI_is_file(const char *path)
 {
-       int mode= BLI_exists(path);
+       int mode = BLI_exists(path);
        return (mode && !S_ISDIR(mode));
 }
 
 LinkNode *BLI_file_read_as_lines(const char *name)
 {
-       FILE *fp= BLI_fopen(name, "r");
-       LinkNode *lines= NULL;
+       FILE *fp = BLI_fopen(name, "r");
+       LinkNode *lines = NULL;
        char *buf;
        size_t size;
 
        if (!fp) return NULL;
                
        fseek(fp, 0, SEEK_END);
-       size= (size_t)ftell(fp);
+       size = (size_t)ftell(fp);
        fseek(fp, 0, SEEK_SET);
 
-       buf= MEM_mallocN(size, "file_as_lines");
+       buf = MEM_mallocN(size, "file_as_lines");
        if (buf) {
-               size_t i, last= 0;
+               size_t i, last = 0;
                
-                       /* 
-                        * size = because on win32 reading
-                        * all the bytes in the file will return
-                        * less bytes because of crnl changes.
-                        */
-               size= fread(buf, 1, size, fp);
-               for (i=0; i<=size; i++) {
-                       if (i==size || buf[i]=='\n') {
-                               char *line= BLI_strdupn(&buf[last], i-last);
+               /*
+                * size = because on win32 reading
+                * all the bytes in the file will return
+                * less bytes because of crnl changes.
+                */
+               size = fread(buf, 1, size, fp);
+               for (i = 0; i <= size; i++) {
+                       if (i == size || buf[i] == '\n') {
+                               char *line = BLI_strdupn(&buf[last], i - last);
 
                                BLI_linklist_prepend(&lines, line);
-                               last= i+1;
+                               last = i + 1;
                        }
                }
                
@@ -565,7 +567,7 @@ LinkNode *BLI_file_read_as_lines(const char *name)
 
 void BLI_file_free_lines(LinkNode *lines)
 {
-       BLI_linklist_free(lines, (void(*)(void*)) MEM_freeN);
+       BLI_linklist_free(lines, (void (*)(void *))MEM_freeN);
 }
 
 /** is file1 older then file2 */
index 448f1c1..4f5ea0b 100644 (file)
@@ -114,7 +114,7 @@ static pthread_mutex_t _opengl_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_mutex_t _nodes_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_mutex_t _movieclip_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_t mainid;
-static int thread_levels= 0;   /* threads can be invoked inside threads */
+static int thread_levels = 0;  /* threads can be invoked inside threads */
 
 /* just a max for security reasons */
 #define RE_MAX_THREAD BLENDER_MAX_THREADS
@@ -151,16 +151,16 @@ void BLI_init_threads(ListBase *threadbase, void *(*do_thread)(void *), int tot)
        int a;
 
        if (threadbase != NULL && tot > 0) {
-               threadbase->first= threadbase->last= NULL;
+               threadbase->first = threadbase->last = NULL;
        
-               if (tot>RE_MAX_THREAD) tot= RE_MAX_THREAD;
-               else if (tot<1) tot= 1;
+               if (tot > RE_MAX_THREAD) tot = RE_MAX_THREAD;
+               else if (tot < 1) tot = 1;
        
-               for (a=0; a<tot; a++) {
-                       ThreadSlot *tslot= MEM_callocN(sizeof(ThreadSlot), "threadslot");
+               for (a = 0; a < tot; a++) {
+                       ThreadSlot *tslot = MEM_callocN(sizeof(ThreadSlot), "threadslot");
                        BLI_addtail(threadbase, tslot);
-                       tslot->do_thread= do_thread;
-                       tslot->avail= 1;
+                       tslot->do_thread = do_thread;
+                       tslot->avail = 1;
                }
        }
        
@@ -182,9 +182,9 @@ void BLI_init_threads(ListBase *threadbase, void *(*do_thread)(void *), int tot)
 int BLI_available_threads(ListBase *threadbase)
 {
        ThreadSlot *tslot;
-       int counter=0;
+       int counter = 0;
        
-       for (tslot= threadbase->first; tslot; tslot= tslot->next) {
+       for (tslot = threadbase->first; tslot; tslot = tslot->next) {
                if (tslot->avail)
                        counter++;
        }
@@ -195,9 +195,9 @@ int BLI_available_threads(ListBase *threadbase)
 int BLI_available_thread_index(ListBase *threadbase)
 {
        ThreadSlot *tslot;
-       int counter=0;
+       int counter = 0;
        
-       for (tslot= threadbase->first; tslot; tslot= tslot->next, counter++) {
+       for (tslot = threadbase->first; tslot; tslot = tslot->next, counter++) {
                if (tslot->avail)
                        return counter;
        }
@@ -206,12 +206,12 @@ int BLI_available_thread_index(ListBase *threadbase)
 
 static void *tslot_thread_start(void *tslot_p)
 {
-       ThreadSlot *tslot= (ThreadSlot*)tslot_p;
+       ThreadSlot *tslot = (ThreadSlot *)tslot_p;
 
 #if defined(__APPLE__) && (PARALLEL == 1) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
        /* workaround for Apple gcc 4.2.1 omp vs background thread bug,
         * set gomp thread local storage pointer which was copied beforehand */
-       pthread_setspecific (gomp_tls_key, thread_tls_data);
+       pthread_setspecific(gomp_tls_key, thread_tls_data);
 #endif
 
        return tslot->do_thread(tslot->callerdata);
@@ -226,10 +226,10 @@ void BLI_insert_thread(ListBase *threadbase, void *callerdata)
 {
        ThreadSlot *tslot;
        
-       for (tslot= threadbase->first; tslot; tslot= tslot->next) {
+       for (tslot = threadbase->first; tslot; tslot = tslot->next) {
                if (tslot->avail) {
-                       tslot->avail= 0;
-                       tslot->callerdata= callerdata;
+                       tslot->avail = 0;
+                       tslot->callerdata = callerdata;
                        pthread_create(&tslot->pthread, NULL, tslot_thread_start, tslot);
                        return;
                }
@@ -241,11 +241,11 @@ void BLI_remove_thread(ListBase *threadbase, void *callerdata)
 {
        ThreadSlot *tslot;
        
-       for (tslot= threadbase->first; tslot; tslot= tslot->next) {
-               if (tslot->callerdata==callerdata) {
+       for (tslot = threadbase->first; tslot; tslot = tslot->next) {
+               if (tslot->callerdata == callerdata) {
                        pthread_join(tslot->pthread, NULL);
-                       tslot->callerdata= NULL;
-                       tslot->avail= 1;
+                       tslot->callerdata = NULL;
+                       tslot->avail = 1;
                }
        }
 }
@@ -253,7 +253,7 @@ void BLI_remove_thread(ListBase *threadbase, void *callerdata)
 void BLI_remove_thread_index(ListBase *threadbase, int index)
 {
        ThreadSlot *tslot;
-       int counter=0;
+       int counter = 0;
        
        for (tslot = threadbase->first; tslot; tslot = tslot->next, counter++) {
                if (counter == index && tslot->avail == 0) {
@@ -286,8 +286,8 @@ void BLI_end_threads(ListBase *threadbase)
         * this way we don't end up decrementing thread_levels on an empty threadbase 
         * */
        if (threadbase && threadbase->first != NULL) {
-               for (tslot= threadbase->first; tslot; tslot= tslot->next) {
-                       if (tslot->avail==0) {
+               for (tslot = threadbase->first; tslot; tslot = tslot->next) {
+                       if (tslot->avail == 0) {
                                pthread_join(tslot->pthread, NULL);
                        }
                }
@@ -295,7 +295,7 @@ void BLI_end_threads(ListBase *threadbase)
        }
 
        thread_levels--;
-       if (thread_levels==0)
+       if (thread_levels == 0)
                MEM_set_lock_callback(NULL, NULL);
 }
 
@@ -310,7 +310,7 @@ int BLI_system_thread_count(void)
        GetSystemInfo(&info);
        t = (int) info.dwNumberOfProcessors;
 #else 
-#      ifdef __APPLE__
+#   ifdef __APPLE__
        int mib[2];
        size_t len;
        
@@ -318,14 +318,14 @@ int BLI_system_thread_count(void)
        mib[1] = HW_NCPU;
        len = sizeof(t);
        sysctl(mib, 2, &t, &len, NULL, 0);
-#      else
+#   else
        t = (int)sysconf(_SC_NPROCESSORS_ONLN);
-#      endif
+#   endif
 #endif
        
-       if (t>RE_MAX_THREAD)
+       if (t > RE_MAX_THREAD)
                return RE_MAX_THREAD;
-       if (t<1)
+       if (t < 1)
                return 1;
        
        return t;
@@ -335,41 +335,41 @@ int BLI_system_thread_count(void)
 
 void BLI_lock_thread(int type)
 {
-       if (type==LOCK_IMAGE)
+       if (type == LOCK_IMAGE)
                pthread_mutex_lock(&_image_lock);
-       else if (type==LOCK_PREVIEW)
+       else if (type == LOCK_PREVIEW)
                pthread_mutex_lock(&_preview_lock);
-       else if (type==LOCK_VIEWER)
+       else if (type == LOCK_VIEWER)
                pthread_mutex_lock(&_viewer_lock);
-       else if (type==LOCK_CUSTOM1)
+       else if (type == LOCK_CUSTOM1)
                pthread_mutex_lock(&_custom1_lock);
-       else if (type==LOCK_RCACHE)
+       else if (type == LOCK_RCACHE)
                pthread_mutex_lock(&_rcache_lock);
-       else if (type==LOCK_OPENGL)
+       else if (type == LOCK_OPENGL)
                pthread_mutex_lock(&_opengl_lock);
-       else if (type==LOCK_NODES)
+       else if (type == LOCK_NODES)
                pthread_mutex_lock(&_nodes_lock);
-       else if (type==LOCK_MOVIECLIP)
+       else if (type == LOCK_MOVIECLIP)
                pthread_mutex_lock(&_movieclip_lock);
 }
 
 void BLI_unlock_thread(int type)
 {
-       if (type==LOCK_IMAGE)
+       if (type == LOCK_IMAGE)
                pthread_mutex_unlock(&_image_lock);
-       else if (type==LOCK_PREVIEW)
+       else if (type == LOCK_PREVIEW)
                pthread_mutex_unlock(&_preview_lock);
-       else if (type==LOCK_VIEWER)
+       else if (type == LOCK_VIEWER)
                pthread_mutex_unlock(&_viewer_lock);
-       else if (type==LOCK_CUSTOM1)
+       else if (type == LOCK_CUSTOM1)
                pthread_mutex_unlock(&_custom1_lock);
-       else if (type==LOCK_RCACHE)
+       else if (type == LOCK_RCACHE)
                pthread_mutex_unlock(&_rcache_lock);
-       else if (type==LOCK_OPENGL)
+       else if (type == LOCK_OPENGL)
                pthread_mutex_unlock(&_opengl_lock);
-       else if (type==LOCK_NODES)
+       else if (type == LOCK_NODES)
                pthread_mutex_unlock(&_nodes_lock);
-       else if (type==LOCK_MOVIECLIP)
+       else if (type == LOCK_MOVIECLIP)
                pthread_mutex_unlock(&_movieclip_lock);
 }
 
@@ -425,20 +425,20 @@ void BLI_rw_mutex_end(ThreadRWMutex *mutex)
 typedef struct ThreadedWorker {
        ListBase threadbase;
        void *(*work_fnct)(void *);
-       char     busy[RE_MAX_THREAD];
-       int              total;
-       int              sleep_time;
+       char busy[RE_MAX_THREAD];
+       int total;
+       int sleep_time;
 } ThreadedWorker;
 
 typedef struct WorkParam {
        ThreadedWorker *worker;
        void *param;
-       int       index;
+       int index;
 } WorkParam;
 
 static void *exec_work_fnct(void *v_param)
 {
-       WorkParam *p = (WorkParam*)v_param;
+       WorkParam *p = (WorkParam *)v_param;
        void *value;
        
        value = p->worker->work_fnct(p->param);
@@ -461,7 +461,7 @@ ThreadedWorker *BLI_create_worker(void *(*do_thread)(void *), int tot, int sleep
                tot = RE_MAX_THREAD;
        }
        else if (tot < 1) {
-               tot= 1;
+               tot = 1;
        }
        
        worker->total = tot;
@@ -528,8 +528,8 @@ ThreadQueue *BLI_thread_queue_init(void)
 {
        ThreadQueue *queue;
 
-       queue= MEM_callocN(sizeof(ThreadQueue), "ThreadQueue");
-       queue->queue= BLI_gsqueue_new(sizeof(void*));
+       queue = MEM_callocN(sizeof(ThreadQueue), "ThreadQueue");
+       queue->queue = BLI_gsqueue_new(sizeof(void *));
 
        pthread_mutex_init(&queue->mutex, NULL);
        pthread_cond_init(&queue->cond, NULL);
@@ -560,7 +560,7 @@ void BLI_thread_queue_push(ThreadQueue *queue, void *work)
 
 void *BLI_thread_queue_pop(ThreadQueue *queue)
 {
-       void *work= NULL;
+       void *work = NULL;
 
        /* wait until there is work */
        pthread_mutex_lock(&queue->mutex);
@@ -586,7 +586,7 @@ static void wait_timeout(struct timespec *timeout, int ms)
                struct _timeb now;
                _ftime(&now);
                sec = now.time;
-               usec = now.millitm*1000; /* microsecond precision would be better */
+               usec = now.millitm * 1000; /* microsecond precision would be better */
        }
 #else
        {
@@ -601,23 +601,23 @@ static void wait_timeout(struct timespec *timeout, int ms)
        div_result = ldiv(ms, 1000);
        timeout->tv_sec = sec + div_result.quot;
 
-       x = usec + (div_result.rem*1000);
+       x = usec + (div_result.rem * 1000);
 
        if (x >= 1000000) {
                timeout->tv_sec++;
                x -= 1000000;
        }
 
-       timeout->tv_nsec = x*1000;
+       timeout->tv_nsec = x * 1000;
 }
 
 void *BLI_thread_queue_pop_timeout(ThreadQueue *queue, int ms)
 {
        double t;
-       void *work= NULL;
+       void *work = NULL;
        struct timespec timeout;
 
-       t= PIL_check_seconds_timer();
+       t = PIL_check_seconds_timer();
        wait_timeout(&timeout, ms);
 
        /* wait until there is work */
@@ -625,7 +625,7 @@ void *BLI_thread_queue_pop_timeout(ThreadQueue *queue, int ms)
        while (BLI_gsqueue_is_empty(queue->queue) && !queue->nowait) {
                if (pthread_cond_timedwait(&queue->cond, &queue->mutex, &timeout) == ETIMEDOUT)
                        break;
-               else if (PIL_check_seconds_timer() - t >= ms*0.001)
+               else if (PIL_check_seconds_timer() - t >= ms * 0.001)
                        break;
        }
 
@@ -643,7 +643,7 @@ int BLI_thread_queue_size(ThreadQueue *queue)
        int size;
 
        pthread_mutex_lock(&queue->mutex);
-       size= BLI_gsqueue_size(queue->queue);
+       size = BLI_gsqueue_size(queue->queue);
        pthread_mutex_unlock(&queue->mutex);
 
        return size;
@@ -653,7 +653,7 @@ void BLI_thread_queue_nowait(ThreadQueue *queue)
 {
        pthread_mutex_lock(&queue->mutex);
 
-       queue->nowait= 1;
+       queue->nowait = 1;
 
        /* signal threads waiting to pop */
        pthread_cond_signal(&queue->cond);
@@ -671,6 +671,6 @@ void BLI_begin_threaded_malloc(void)
 void BLI_end_threaded_malloc(void)
 {
        thread_levels--;
-       if (thread_levels==0)
+       if (thread_levels == 0)
                MEM_set_lock_callback(NULL, NULL);
 }
index 8f3131c..4abbcb1 100644 (file)
 /* local prototypes --------------------- */
 void BLO_blendhandle_print_sizes(BlendHandle *, void *); 
 
-       /* Access routines used by filesel. */
+/* Access routines used by filesel. */
         
 BlendHandle *BLO_blendhandle_from_file(char *file, ReportList *reports)
 {
        BlendHandle *bh;
 
-       bh= (BlendHandle*)blo_openblenderfile(file, reports);
+       bh = (BlendHandle *)blo_openblenderfile(file, reports);
 
        return bh;
 }
@@ -86,36 +86,36 @@ BlendHandle *BLO_blendhandle_from_memory(void *mem, int memsize)
 {
        BlendHandle *bh;
 
-       bh= (BlendHandle*)blo_openblendermemory(mem, memsize, NULL);
+       bh = (BlendHandle *)blo_openblendermemory(mem, memsize, NULL);
 
        return bh;
 }
 
 void BLO_blendhandle_print_sizes(BlendHandle *bh, void *fp) 
 {
-       FileData *fd= (FileData*) bh;
+       FileData *fd = (FileData *) bh;
        BHead *bhead;
 
        fprintf(fp, "[\n");
-       for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) {
-               if (bhead->code==ENDB)
+       for (bhead = blo_firstbhead(fd); bhead; bhead = blo_nextbhead(fd, bhead)) {
+               if (bhead->code == ENDB)
                        break;
                else {
-                       short *sp= fd->filesdna->structs[bhead->SDNAnr];
-                       char *name= fd->filesdna->types[ sp[0] ];
+                       short *sp = fd->filesdna->structs[bhead->SDNAnr];
+                       char *name = fd->filesdna->types[sp[0]];
                        char buf[4];
                        
-                       buf[0]= (bhead->code>>24)&0xFF;
-                       buf[1]= (bhead->code>>16)&0xFF;
-                       buf[2]= (bhead->code>>8)&0xFF;
-                       buf[3]= (bhead->code>>0)&0xFF;
+                       buf[0] = (bhead->code >> 24) & 0xFF;
+                       buf[1] = (bhead->code >> 16) & 0xFF;
+                       buf[2] = (bhead->code >> 8) & 0xFF;
+                       buf[3] = (bhead->code >> 0) & 0xFF;
+
+                       buf[0] = buf[0] ? buf[0] : ' ';
+                       buf[1] = buf[1] ? buf[1] : ' ';
+                       buf[2] = buf[2] ? buf[2] : ' ';
+                       buf[3] = buf[3] ? buf[3] : ' ';
                        
-                       buf[0]= buf[0]?buf[0]:' ';
-                       buf[1]= buf[1]?buf[1]:' ';
-                       buf[2]= buf[2]?buf[2]:' ';
-                       buf[3]= buf[3]?buf[3]:' ';
-                       
-                       fprintf(fp, "['%.4s', '%s', %d, %ld ],\n", buf, name, bhead->nr, (long int)(bhead->len+sizeof(BHead)));
+                       fprintf(fp, "['%.4s', '%s', %d, %ld ],\n", buf, name, bhead->nr, (long int)(bhead->len + sizeof(BHead)));
                }
        }
        fprintf(fp, "]\n");
@@ -123,39 +123,39 @@ void BLO_blendhandle_print_sizes(BlendHandle *bh, void *fp)
 
 LinkNode *BLO_blendhandle_get_datablock_names(BlendHandle *bh, int ofblocktype, int *tot_names)
 {
-       FileData *fd= (FileData*) bh;
-       LinkNode *names= NULL;
+       FileData *fd = (FileData *) bh;
+       LinkNode *names = NULL;
        BHead *bhead;
-       int tot= 0;
+       int tot = 0;
 
-       for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) {
-               if (bhead->code==ofblocktype) {
-                       char *idname= bhead_id_name(fd, bhead);
+       for (bhead = blo_firstbhead(fd); bhead; bhead = blo_nextbhead(fd, bhead)) {
+               if (bhead->code == ofblocktype) {
+                       char *idname = bhead_id_name(fd, bhead);
 
-                       BLI_linklist_prepend(&names, strdup(idname+2));
+                       BLI_linklist_prepend(&names, strdup(idname + 2));
                        tot++;
                }
-               else if (bhead->code==ENDB)
+               else if (bhead->code == ENDB)
                        break;
        }
 
-       *tot_names= tot;
+       *tot_names = tot;
        return names;
 }
 
 LinkNode *BLO_blendhandle_get_previews(BlendHandle *bh, int ofblocktype, int *tot_prev)
 {
-       FileData *fd= (FileData*) bh;
-       LinkNode *previews= NULL;
+       FileData *fd = (FileData *) bh;
+       LinkNode *previews = NULL;
        BHead *bhead;
-       int looking=0;
-       PreviewImageprv = NULL;
-       PreviewImagenew_prv = NULL;
-       int tot= 0;
-       
-       for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) {
-               if (bhead->code==ofblocktype) {
-                       char *idname= bhead_id_name(fd, bhead);
+       int looking = 0;
+       PreviewImage *prv = NULL;
+       PreviewImage *new_prv = NULL;
+       int tot = 0;
+
+       for (bhead = blo_firstbhead(fd); bhead; bhead = blo_nextbhead(fd, bhead)) {
+               if (bhead->code == ofblocktype) {
+                       char *idname = bhead_id_name(fd, bhead);
                        switch (GS(idname)) {
                                case ID_MA: /* fall through */
                                case ID_TE: /* fall through */
@@ -171,7 +171,7 @@ LinkNode *BLO_blendhandle_get_previews(BlendHandle *bh, int ofblocktype, int *to
                                        break;
                        }
                }
-               else if (bhead->code==DATA) {
+               else if (bhead->code == DATA) {
                        if (looking) {
                                if (bhead->SDNAnr == DNA_struct_find_nr(fd->filesdna, "PreviewImage") ) {
                                        prv = BLO_library_read_struct(fd, bhead, "PreviewImage");       
@@ -179,9 +179,9 @@ LinkNode *BLO_blendhandle_get_previews(BlendHandle *bh, int ofblocktype, int *to
                                                memcpy(new_prv, prv, sizeof(PreviewImage));
                                                if (prv->rect[0]) {
                                                        unsigned int *rect = NULL;
-                                                       new_prv->rect[0] = MEM_callocN(new_prv->w[0]*new_prv->h[0]*sizeof(unsigned int), "prvrect");
-                                                       bhead= blo_nextbhead(fd, bhead);
-                                                       rect = (unsigned int*)(bhead+1);
+                                                       new_prv->rect[0] = MEM_callocN(new_prv->w[0] * new_prv->h[0] * sizeof(unsigned int), "prvrect");
+                                                       bhead = blo_nextbhead(fd, bhead);
+                                                       rect = (unsigned int *)(bhead + 1);
                                                        memcpy(new_prv->rect[0], rect, bhead->len);                                     
                                                }
                                                else {
@@ -190,9 +190,9 @@ LinkNode *BLO_blendhandle_get_previews(BlendHandle *bh, int ofblocktype, int *to
                                                
                                                if (prv->rect[1]) {
                                                        unsigned int *rect = NULL;
-                                                       new_prv->rect[1] = MEM_callocN(new_prv->w[1]*new_prv->h[1]*sizeof(unsigned int), "prvrect");
-                                                       bhead= blo_nextbhead(fd, bhead);
-                                                       rect = (unsigned int*)(bhead+1);
+                                                       new_prv->rect[1] = MEM_callocN(new_prv->w[1] * new_prv->h[1] * sizeof(unsigned int), "prvrect");
+                                                       bhead = blo_nextbhead(fd, bhead);
+                                                       rect = (unsigned int *)(bhead + 1);
                                                        memcpy(new_prv->rect[1], rect, bhead->len);                                                     
                                                }
                                                else {
@@ -203,7 +203,7 @@ LinkNode *BLO_blendhandle_get_previews(BlendHandle *bh, int ofblocktype, int *to
                                }
                        }
                }
-               else if (bhead->code==ENDB) {
+               else if (bhead->code == ENDB) {
                        break;
                }
                else {
@@ -214,24 +214,24 @@ LinkNode *BLO_blendhandle_get_previews(BlendHandle *bh, int ofblocktype, int *to
                
        }
 
-       *tot_prev= tot;
+       *tot_prev = tot;
        return previews;
 }
 
 LinkNode *BLO_blendhandle_get_linkable_groups(BlendHandle *bh) 
 {
-       FileData *fd= (FileData*) bh;
-       GHash *gathered= BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "linkable_groups gh");
-       LinkNode *names= NULL;
+       FileData *fd = (FileData *) bh;
+       GHash *gathered = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "linkable_groups gh");
+       LinkNode *names = NULL;
        BHead *bhead;
        
-       for (bhead= blo_firstbhead(fd); bhead; bhead= blo_nextbhead(fd, bhead)) {
-               if (bhead->code==ENDB) {
+       for (bhead = blo_firstbhead(fd); bhead; bhead = blo_nextbhead(fd, bhead)) {
+               if (bhead->code == ENDB) {
                        break;
                }
                else if (BKE_idcode_is_valid(bhead->code)) {
                        if (BKE_idcode_is_linkable(bhead->code)) {
-                               const char *str= BKE_idcode_to_name(bhead->code);
+                               const char *str = BKE_idcode_to_name(bhead->code);
                                
                                if (!BLI_ghash_haskey(gathered, (void *)str)) {
                                        BLI_linklist_prepend(&names, strdup(str));
@@ -248,12 +248,12 @@ LinkNode *BLO_blendhandle_get_linkable_groups(BlendHandle *bh)
 
 void BLO_blendhandle_close(BlendHandle *bh)
 {
-       FileData *fd= (FileData*) bh;
+       FileData *fd = (FileData *) bh;
        
        blo_freefiledata(fd);
 }
 
-       /**********/
+/**********/
 
 BlendFileData *BLO_read_from_file(const char *filepath, ReportList *reports)
 {
@@ -262,8 +262,8 @@ BlendFileData *BLO_read_from_file(const char *filepath, ReportList *reports)
                
        fd = blo_openblenderfile(filepath, reports);
        if (fd) {
-               fd->reports= reports;
-               bfd= blo_read_file_internal(fd, filepath);
+               fd->reports = reports;
+               bfd = blo_read_file_internal(fd, filepath);
                blo_freefiledata(fd);                   
        }
 
@@ -277,8 +277,8 @@ BlendFileData *BLO_read_from_memory(void *mem, int memsize, ReportList *reports)
                
        fd = blo_openblendermemory(mem, memsize,  reports);
        if (fd) {
-               fd->reports= reports;
-               bfd= blo_read_file_internal(fd, "");
+               fd->reports = reports;
+               bfd = blo_read_file_internal(fd, "");
                blo_freefiledata(fd);                   
        }
 
@@ -293,7 +293,7 @@ BlendFileData *BLO_read_from_memfile(Main *oldmain, const char *filename, MemFil
        
        fd = blo_openblendermemfile(memfile, reports);
        if (fd) {
-               fd->reports= reports;
+               fd->reports = reports;
                BLI_strncpy(fd->relabase, filename, sizeof(fd->relabase));
                
                /* clear ob->proxy_from pointers in old main */
@@ -310,7 +310,7 @@ BlendFileData *BLO_read_from_memfile(Main *oldmain, const char *filename, MemFil
                /* makes lookup of existing video clips in old main */
                blo_make_movieclip_pointer_map(fd, oldmain);
                
-               bfd= blo_read_file_internal(fd, filename);
+               bfd = blo_read_file_internal(fd, filename);
                
                /* ensures relinked images are not freed */
                blo_end_image_pointer_map(fd, oldmain);
@@ -319,11 +319,11 @@ BlendFileData *BLO_read_from_memfile(Main *oldmain, const char *filename, MemFil
                blo_end_movieclip_pointer_map(fd, oldmain);
                
                /* move libraries from old main to new main */
-               if (bfd && mainlist.first!=mainlist.last) {
+               if (bfd && mainlist.first != mainlist.last) {
                        
                        /* Library structs themselves */
-                       bfd->main->library= oldmain->library;
-                       oldmain->library.first= oldmain->library.last= NULL;
+                       bfd->main->library = oldmain->library;
+                       oldmain->library.first = oldmain->library.last = NULL;
                        
                        /* add the Library mainlist to the new main */
                        BLI_remlink(&mainlist, oldmain);
index 75fa8d0..21a9290 100644 (file)
@@ -56,11 +56,11 @@ void BLO_free_memfile(MemFile *memfile)
        MemFileChunk *chunk;
        
        while ( (chunk = (memfile->chunks.first) ) ) {
-               if (chunk->ident==0) MEM_freeN(chunk->buf);
+               if (chunk->ident == 0) MEM_freeN(chunk->buf);
                BLI_remlink(&memfile->chunks, chunk);
                MEM_freeN(chunk);
        }
-       memfile->size= 0;
+       memfile->size = 0;
 }
 
 /* to keep list of memfiles consistent, 'first' is always first in list */
@@ -69,17 +69,17 @@ void BLO_merge_memfile(MemFile *first, MemFile *second)
 {
        MemFileChunk *fc, *sc;
        
-       fc= first->chunks.first;
-       sc= second->chunks.first;
+       fc = first->chunks.first;
+       sc = second->chunks.first;
        while (fc || sc) {
                if (fc && sc) {
                        if (sc->ident) {
-                               sc->ident= 0;
-                               fc->ident= 1;
+                               sc->ident = 0;
+                               fc->ident = 1;
                        }
                }
-               if (fc) fc= fc->next;
-               if (sc) sc= sc->next;
+               if (fc) fc = fc->next;
+               if (sc) sc = sc->next;
        }
        
        BLO_free_memfile(first);
@@ -92,7 +92,7 @@ static int my_memcmp(const int *mem1, const int *mem2, const int len)
        register const int *memb = mem2;
   &nbs