From 2f2b15bbb2a30ee312d65c627d54a12445f4b987 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Sat, 12 May 2012 15:02:10 +0000 Subject: style cleanup: whitespace, bli & makesdna --- source/blender/blenlib/intern/BLI_args.c | 26 +- source/blender/blenlib/intern/BLI_dynstr.c | 88 +-- source/blender/blenlib/intern/BLI_ghash.c | 10 +- source/blender/blenlib/intern/BLI_heap.c | 2 +- source/blender/blenlib/intern/BLI_kdopbvh.c | 441 ++++++------- source/blender/blenlib/intern/BLI_kdtree.c | 246 +++---- source/blender/blenlib/intern/BLI_linklist.c | 46 +- source/blender/blenlib/intern/BLI_memarena.c | 8 +- source/blender/blenlib/intern/DLRB_tree.c | 188 +++--- source/blender/blenlib/intern/bpath.c | 148 ++--- source/blender/blenlib/intern/edgehash.c | 18 +- source/blender/blenlib/intern/fileops.c | 90 +-- source/blender/blenlib/intern/jitter.c | 104 +-- source/blender/blenlib/intern/math_geom.c | 38 +- source/blender/blenlib/intern/math_rotation.c | 13 +- source/blender/blenlib/intern/noise.c | 447 ++++++------- source/blender/blenlib/intern/rand.c | 58 +- source/blender/blenlib/intern/smallhash.c | 22 +- source/blender/blenlib/intern/storage.c | 156 ++--- source/blender/blenlib/intern/threads.c | 128 ++-- source/blender/blenloader/intern/readblenentry.c | 126 ++-- source/blender/blenloader/intern/undofile.c | 44 +- source/blender/makesdna/intern/dna_genfile.c | 790 +++++++++++------------ source/blender/makesdna/intern/makesdna.c | 492 +++++++------- 24 files changed, 1864 insertions(+), 1865 deletions(-) (limited to 'source') diff --git a/source/blender/blenlib/intern/BLI_args.c b/source/blender/blenlib/intern/BLI_args.c index ed3c6fad1a0..4e194b24c1e 100644 --- a/source/blender/blenlib/intern/BLI_args.c +++ b/source/blender/blenlib/intern/BLI_args.c @@ -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; diff --git a/source/blender/blenlib/intern/BLI_dynstr.c b/source/blender/blenlib/intern/BLI_dynstr.c index 54d9bc5f16d..d1c30504153 100644 --- a/source/blender/blenlib/intern/BLI_dynstr.c +++ b/source/blender/blenlib/intern/BLI_dynstr.c @@ -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); diff --git a/source/blender/blenlib/intern/BLI_ghash.c b/source/blender/blenlib/intern/BLI_ghash.c index 65461b7258a..6ec3d033672 100644 --- a/source/blender/blenlib/intern/BLI_ghash.c +++ b/source/blender/blenlib/intern/BLI_ghash.c @@ -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); } diff --git a/source/blender/blenlib/intern/BLI_heap.c b/source/blender/blenlib/intern/BLI_heap.c index fa7b91b8539..4e135805efb 100644 --- a/source/blender/blenlib/intern/BLI_heap.c +++ b/source/blender/blenlib/intern/BLI_heap.c @@ -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); diff --git a/source/blender/blenlib/intern/BLI_kdopbvh.c b/source/blender/blenlib/intern/BLI_kdopbvh.c index 8662406b0e9..2b21758fdc1 100644 --- a/source/blender/blenlib/intern/BLI_kdopbvh.c +++ b/source/blender/blenlib/intern/BLI_kdopbvh.c @@ -50,59 +50,54 @@ #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; iindex, 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; itree_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; - BVHNode* parent = 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; - BVHNode* root = 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; diff --git a/source/blender/blenlib/intern/BLI_kdtree.c b/source/blender/blenlib/intern/BLI_kdtree.c index a518d1445e3..4878c0f05a6 100644 --- a/source/blender/blenlib/intern/BLI_kdtree.c +++ b/source/blender/blenlib/intern/BLI_kdtree.c @@ -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_distco, co, node->nor, nor); - if (cur_distco, 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_distco, co, node->nor, nor); - if (cur_distco, 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 (*found0; 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 (foundco, co, node->nor, nor); + if (found < n || -cur_dist < nearest[found - 1].dist) { + cur_dist = squared_distance(node->co, co, node->nor, nor); - if (foundindex, 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 (foundco, co, node->nor, nor); - if (foundco, 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 *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; } } diff --git a/source/blender/blenlib/intern/BLI_linklist.c b/source/blender/blenlib/intern/BLI_linklist.c index 5c7d7089825..0e630efc349 100644 --- a/source/blender/blenlib/intern/BLI_linklist.c +++ b/source/blender/blenlib/intern/BLI_linklist.c @@ -38,12 +38,12 @@ 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); } diff --git a/source/blender/blenlib/intern/BLI_memarena.c b/source/blender/blenlib/intern/BLI_memarena.c index 95a007db43e..8c9993afee8 100644 --- a/source/blender/blenlib/intern/BLI_memarena.c +++ b/source/blender/blenlib/intern/BLI_memarena.c @@ -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; } diff --git a/source/blender/blenlib/intern/DLRB_tree.c b/source/blender/blenlib/intern/DLRB_tree.c index 6398bd863db..bed5750ad44 100644 --- a/source/blender/blenlib/intern/DLRB_tree.c +++ b/source/blender/blenlib/intern/DLRB_tree.c @@ -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); } diff --git a/source/blender/blenlib/intern/bpath.c b/source/blender/blenlib/intern/bpath.c index 48912eb927a..1aba8bbeaf2 100644 --- a/source/blender/blenlib/intern/bpath.c +++ b/source/blender/blenlib/intern/bpath.c @@ -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; } } diff --git a/source/blender/blenlib/intern/edgehash.c b/source/blender/blenlib/intern/edgehash.c index 531a4de361e..cdaf270adcb 100644 --- a/source/blender/blenlib/intern/edgehash.c +++ b/source/blender/blenlib/intern/edgehash.c @@ -41,14 +41,14 @@ #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; inbuckets; 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) diff --git a/source/blender/blenlib/intern/fileops.c b/source/blender/blenlib/intern/fileops.c index 0a5e4d9fd48..e6d06484e74 100644 --- a/source/blender/blenlib/intern/fileops.c +++ b/source/blender/blenlib/intern/fileops.c @@ -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); } diff --git a/source/blender/blenlib/intern/jitter.c b/source/blender/blenlib/intern/jitter.c index afe31fb1377..6203a98828b 100644 --- a/source/blender/blenlib/intern/jitter.c +++ b/source/blender/blenlib/intern/jitter.c @@ -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)0 && len 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)0 && len 0 && len < rad1) { + len = len / rad1; + dvecx += vecx / len; + dvecy += vecy / len; } } vecx += 1.0f; - if ( fabsf(vecx)0 && 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)= 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) diff --git a/source/blender/blenlib/intern/math_rotation.c b/source/blender/blenlib/intern/math_rotation.c index 37402f9391c..066c9e7cd15 100644 --- a/source/blender/blenlib/intern/math_rotation.c +++ b/source/blender/blenlib/intern/math_rotation.c @@ -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); diff --git a/source/blender/blenlib/intern/noise.c b/source/blender/blenlib/intern/noise.c index d795f9bf332..f591dc17f5b 100644 --- a/source/blender/blenlib/intern/noise.c +++ b/source/blender/blenlib/intern/noise.c @@ -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<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 (d1.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<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 */ } /****************/ diff --git a/source/blender/blenlib/intern/rand.c b/source/blender/blenlib/intern/rand.c index b2e6cabec57..4435e9ce09c 100644 --- a/source/blender/blenlib/intern/rand.c +++ b/source/blender/blenlib/intern/rand.c @@ -41,22 +41,22 @@ #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(RNG* rng) +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= 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]); } diff --git a/source/blender/blenlib/intern/smallhash.c b/source/blender/blenlib/intern/smallhash.c index fb03849bfb3..92125c6e988 100644 --- a/source/blender/blenlib/intern/smallhash.c +++ b/source/blender/blenlib/intern/smallhash.c @@ -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; icurhash - 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; isize; 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; diff --git a/source/blender/blenlib/intern/storage.c b/source/blender/blenlib/intern/storage.c index 047463f1e26..d4f251d4f5e 100644 --- a/source/blender/blenlib/intern/storage.c +++ b/source/blender/blenlib/intern/storage.c @@ -43,13 +43,13 @@ #include #include -#if defined (__sun__) || defined (__sun) || defined (__NetBSD__) +#if defined(__sun__) || defined(__sun) || defined(__NetBSD__) #include /* Other modern unix os's should probably use this also */ #elif !defined(__FreeBSD__) && !defined(linux) && (defined(__sparc) || defined(__sparc__)) #include #endif -#if defined (__FreeBSD__) || defined (__OpenBSD__) +#if defined(__FreeBSD__) || defined(__OpenBSD__) #include #include #endif @@ -66,7 +66,7 @@ #include -#include /* strcpy etc.. */ +#include /* strcpy etc.. */ #ifdef WIN32 # include @@ -98,13 +98,13 @@ 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, §orspc, &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; nummode1, 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 */ diff --git a/source/blender/blenlib/intern/threads.c b/source/blender/blenlib/intern/threads.c index 448f1c1b408..4f5ea0b23bd 100644 --- a/source/blender/blenlib/intern/threads.c +++ b/source/blender/blenlib/intern/threads.c @@ -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; ado_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); } diff --git a/source/blender/blenloader/intern/readblenentry.c b/source/blender/blenloader/intern/readblenentry.c index 8f3131c733a..4abbcb1888c 100644 --- a/source/blender/blenloader/intern/readblenentry.c +++ b/source/blender/blenloader/intern/readblenentry.c @@ -71,13 +71,13 @@ /* 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; - 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); + 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); diff --git a/source/blender/blenloader/intern/undofile.c b/source/blender/blenloader/intern/undofile.c index 75fa8d0c3d2..21a9290968b 100644 --- a/source/blender/blenloader/intern/undofile.c +++ b/source/blender/blenloader/intern/undofile.c @@ -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; while (a--) { - if ( *mema != *memb) return 1; + if (*mema != *memb) return 1; mema++; memb++; } @@ -101,39 +101,39 @@ static int my_memcmp(const int *mem1, const int *mem2, const int len) void add_memfilechunk(MemFile *compare, MemFile *current, const char *buf, unsigned int size) { - static MemFileChunk *compchunk=NULL; + static MemFileChunk *compchunk = NULL; MemFileChunk *curchunk; /* this function inits when compare != NULL or when current==NULL */ if (compare) { - compchunk= compare->chunks.first; + compchunk = compare->chunks.first; return; } - if (current==NULL) { - compchunk= NULL; + if (current == NULL) { + compchunk = NULL; return; } - curchunk= MEM_mallocN(sizeof(MemFileChunk), "MemFileChunk"); - curchunk->size= size; - curchunk->buf= NULL; - curchunk->ident= 0; + curchunk = MEM_mallocN(sizeof(MemFileChunk), "MemFileChunk"); + curchunk->size = size; + curchunk->buf = NULL; + curchunk->ident = 0; BLI_addtail(¤t->chunks, curchunk); /* we compare compchunk with buf */ if (compchunk) { if (compchunk->size == curchunk->size) { if (my_memcmp((int *)compchunk->buf, (const int *)buf, size / 4) == 0) { - curchunk->buf= compchunk->buf; - curchunk->ident= 1; + curchunk->buf = compchunk->buf; + curchunk->ident = 1; } } - compchunk= compchunk->next; + compchunk = compchunk->next; } /* not equal... */ - if (curchunk->buf==NULL) { - curchunk->buf= MEM_mallocN(size, "Chunk buffer"); + if (curchunk->buf == NULL) { + curchunk->buf = MEM_mallocN(size, "Chunk buffer"); memcpy(curchunk->buf, buf, size); current->size += size; } diff --git a/source/blender/makesdna/intern/dna_genfile.c b/source/blender/makesdna/intern/dna_genfile.c index d0429041d9b..472278340e5 100644 --- a/source/blender/makesdna/intern/dna_genfile.c +++ b/source/blender/makesdna/intern/dna_genfile.c @@ -143,10 +143,10 @@ static short le_short(short temp); static short le_short(short temp) { short new; - char *rt=(char *)&temp, *rtn=(char *)&new; + char *rt = (char *)&temp, *rtn = (char *)&new; - rtn[0]= rt[1]; - rtn[1]= rt[0]; + rtn[0] = rt[1]; + rtn[1] = rt[0]; return new; } @@ -155,12 +155,12 @@ static short le_short(short temp) static int le_int(int temp) { int new; - char *rt=(char *)&temp, *rtn=(char *)&new; + char *rt = (char *)&temp, *rtn = (char *)&new; - rtn[0]= rt[3]; - rtn[1]= rt[2]; - rtn[2]= rt[1]; - rtn[3]= rt[0]; + rtn[0] = rt[3]; + rtn[1] = rt[2]; + rtn[2] = rt[1]; + rtn[3] = rt[0]; return new; } @@ -171,18 +171,18 @@ static int le_int(int temp) /* allowed duplicate code from makesdna.c */ int DNA_elem_array_size(const char *astr, int len) { - int a, mul=1; - char str[100], *cp= NULL; + int a, mul = 1; + char str[100], *cp = NULL; - memcpy(str, astr, len+1); + memcpy(str, astr, len + 1); - for (a=0; anames[name]; - len= 0; + cp = sdna->names[name]; + len = 0; - namelen= strlen(cp); + namelen = strlen(cp); /* is it a pointer or function pointer? */ if (ispointer(cp)) { /* has the naam an extra length? (array) */ - mul= 1; - if ( cp[namelen-1]==']') mul= DNA_elem_array_size(cp, namelen); + mul = 1; + if (cp[namelen - 1] == ']') mul = DNA_elem_array_size(cp, namelen); - len= sdna->pointerlen*mul; + len = sdna->pointerlen * mul; } - else if ( sdna->typelens[type] ) { + else if (sdna->typelens[type]) { /* has the naam an extra length? (array) */ - mul= 1; - if ( cp[namelen-1]==']') mul= DNA_elem_array_size(cp, namelen); + mul = 1; + if (cp[namelen - 1] == ']') mul = DNA_elem_array_size(cp, namelen); - len= mul*sdna->typelens[type]; + len = mul * sdna->typelens[type]; } @@ -250,13 +250,13 @@ static void printstruct(SDNA *sdna, short strnr) int b, nr; short *sp; - sp= sdna->structs[strnr]; + sp = sdna->structs[strnr]; - printf("struct %s\n", sdna->types[ sp[0] ]); - nr= sp[1]; - sp+= 2; + printf("struct %s\n", sdna->types[sp[0]]); + nr = sp[1]; + sp += 2; - for (b=0; b< nr; b++, sp+= 2) { + for (b = 0; b < nr; b++, sp += 2) { printf(" %s %s\n", sdna->types[sp[0]], sdna->names[sp[1]]); } } @@ -265,14 +265,14 @@ static void printstruct(SDNA *sdna, short strnr) static short *findstruct_name(SDNA *sdna, const char *str) { int a; - short *sp= NULL; + short *sp = NULL; - for (a=0; anr_structs; a++) { + for (a = 0; a < sdna->nr_structs; a++) { - sp= sdna->structs[a]; + sp = sdna->structs[a]; - if (strcmp( sdna->types[ sp[0] ], str )==0) return sp; + if (strcmp(sdna->types[sp[0]], str) == 0) return sp; } return NULL; @@ -280,11 +280,11 @@ static short *findstruct_name(SDNA *sdna, const char *str) int DNA_struct_find_nr(SDNA *sdna, const char *str) { - short *sp= NULL; + short *sp = NULL; - if (sdna->lastfindnr_structs) { - sp= sdna->structs[sdna->lastfind]; - if (strcmp( sdna->types[ sp[0] ], str )==0) return sdna->lastfind; + if (sdna->lastfind < sdna->nr_structs) { + sp = sdna->structs[sdna->lastfind]; + if (strcmp(sdna->types[sp[0]], str) == 0) return sdna->lastfind; } #ifdef WITH_DNA_GHASH @@ -293,12 +293,12 @@ int DNA_struct_find_nr(SDNA *sdna, const char *str) { int a; - for (a=0; anr_structs; a++) { + for (a = 0; a < sdna->nr_structs; a++) { - sp= sdna->structs[a]; + sp = sdna->structs[a]; - if (strcmp( sdna->types[ sp[0] ], str )==0) { - sdna->lastfind= a; + if (strcmp(sdna->types[sp[0]], str) == 0) { + sdna->lastfind = a; return a; } } @@ -314,172 +314,172 @@ int DNA_struct_find_nr(SDNA *sdna, const char *str) static void init_structDNA(SDNA *sdna, int do_endian_swap) /* in sdna->data the data, now we convert that to something understandable */ { - int *data, *verg, gravity_fix= -1; + int *data, *verg, gravity_fix = -1; intptr_t nr; short *sp; char str[8], *cp; - verg= (int *)str; - data= (int *)sdna->data; + verg = (int *)str; + data = (int *)sdna->data; strcpy(str, "SDNA"); - if ( *data == *verg ) { + if (*data == *verg) { data++; /* load names array */ strcpy(str, "NAME"); - if ( *data == *verg ) { + if (*data == *verg) { data++; - if (do_endian_swap) sdna->nr_names= le_int(*data); - else sdna->nr_names= *data; + if (do_endian_swap) sdna->nr_names = le_int(*data); + else sdna->nr_names = *data; data++; - sdna->names= MEM_callocN(sizeof(void *)*sdna->nr_names, "sdnanames"); + sdna->names = MEM_callocN(sizeof(void *) * sdna->nr_names, "sdnanames"); } else { printf("NAME error in SDNA file\n"); return; } - nr= 0; - cp= (char *)data; - while (nrnr_names) { - sdna->names[nr]= cp; + nr = 0; + cp = (char *)data; + while (nr < sdna->nr_names) { + sdna->names[nr] = cp; /* "float gravity [3]" was parsed wrong giving both "gravity" and * "[3]" members. we rename "[3]", and later set the type of * "gravity" to "void" so the offsets work out correct */ - if (*cp == '[' && strcmp(cp, "[3]")==0) { - if (nr && strcmp(sdna->names[nr-1], "Cvi") == 0) { - sdna->names[nr]= "gravity[3]"; - gravity_fix= nr; + if (*cp == '[' && strcmp(cp, "[3]") == 0) { + if (nr && strcmp(sdna->names[nr - 1], "Cvi") == 0) { + sdna->names[nr] = "gravity[3]"; + gravity_fix = nr; } } - while ( *cp) cp++; + while (*cp) cp++; cp++; nr++; } - nr= (intptr_t)cp; /* prevent BUS error */ - nr= (nr+3) & ~3; - cp= (char *)nr; + nr = (intptr_t)cp; /* prevent BUS error */ + nr = (nr + 3) & ~3; + cp = (char *)nr; /* load type names array */ - data= (int *)cp; + data = (int *)cp; strcpy(str, "TYPE"); - if ( *data == *verg ) { + if (*data == *verg) { data++; - if (do_endian_swap) sdna->nr_types= le_int(*data); - else sdna->nr_types= *data; + if (do_endian_swap) sdna->nr_types = le_int(*data); + else sdna->nr_types = *data; data++; - sdna->types= MEM_callocN(sizeof(void *)*sdna->nr_types, "sdnatypes"); + sdna->types = MEM_callocN(sizeof(void *) * sdna->nr_types, "sdnatypes"); } else { printf("TYPE error in SDNA file\n"); return; } - nr= 0; - cp= (char *)data; - while (nrnr_types) { - sdna->types[nr]= cp; + nr = 0; + cp = (char *)data; + while (nr < sdna->nr_types) { + sdna->types[nr] = cp; /* this is a patch, to change struct names without a conflict with SDNA */ /* be careful to use it, in this case for a system-struct (opengl/X) */ - if ( *cp == 'b') { + if (*cp == 'b') { /* struct Screen was already used by X, 'bScreen' replaces the old IrisGL 'Screen' struct */ - if ( strcmp("bScreen", cp)==0 ) sdna->types[nr]= cp+1; + if (strcmp("bScreen", cp) == 0) sdna->types[nr] = cp + 1; } - while ( *cp) cp++; + while (*cp) cp++; cp++; nr++; } - nr= (intptr_t)cp; /* prevent BUS error */ - nr= (nr+3) & ~3; - cp= (char *)nr; + nr = (intptr_t)cp; /* prevent BUS error */ + nr = (nr + 3) & ~3; + cp = (char *)nr; /* load typelen array */ - data= (int *)cp; + data = (int *)cp; strcpy(str, "TLEN"); - if ( *data == *verg ) { + if (*data == *verg) { data++; - sp= (short *)data; - sdna->typelens= sp; + sp = (short *)data; + sdna->typelens = sp; if (do_endian_swap) { - short a, *spo= sp; + short a, *spo = sp; - a= sdna->nr_types; + a = sdna->nr_types; while (a--) { - spo[0]= le_short(spo[0]); + spo[0] = le_short(spo[0]); spo++; } } - sp+= sdna->nr_types; + sp += sdna->nr_types; } else { printf("TLEN error in SDNA file\n"); return; } - if (sdna->nr_types & 1) sp++; /* prevent BUS error */ + if (sdna->nr_types & 1) sp++; /* prevent BUS error */ /* load struct array */ - data= (int *)sp; + data = (int *)sp; strcpy(str, "STRC"); - if ( *data == *verg ) { + if (*data == *verg) { data++; - if (do_endian_swap) sdna->nr_structs= le_int(*data); - else sdna->nr_structs= *data; + if (do_endian_swap) sdna->nr_structs = le_int(*data); + else sdna->nr_structs = *data; data++; - sdna->structs= MEM_callocN(sizeof(void *)*sdna->nr_structs, "sdnastrcs"); + sdna->structs = MEM_callocN(sizeof(void *) * sdna->nr_structs, "sdnastrcs"); } else { printf("STRC error in SDNA file\n"); return; } - nr= 0; - sp= (short *)data; - while (nrnr_structs) { - sdna->structs[nr]= sp; + nr = 0; + sp = (short *)data; + while (nr < sdna->nr_structs) { + sdna->structs[nr] = sp; if (do_endian_swap) { short a; - sp[0]= le_short(sp[0]); - sp[1]= le_short(sp[1]); + sp[0] = le_short(sp[0]); + sp[1] = le_short(sp[1]); - a= sp[1]; - sp+= 2; + a = sp[1]; + sp += 2; while (a--) { - sp[0]= le_short(sp[0]); - sp[1]= le_short(sp[1]); - sp+= 2; + sp[0] = le_short(sp[0]); + sp[1] = le_short(sp[1]); + sp += 2; } } else { - sp+= 2*sp[1]+2; + sp += 2 * sp[1] + 2; } nr++; } /* finally pointerlen: use struct ListBase to test it, never change the size of it! */ - sp= findstruct_name(sdna, "ListBase"); + sp = findstruct_name(sdna, "ListBase"); /* weird; i have no memory of that... I think I used sizeof(void *) before... (ton) */ - sdna->pointerlen= sdna->typelens[ sp[0] ]/2; + sdna->pointerlen = sdna->typelens[sp[0]] / 2; - if (sp[1]!=2 || (sdna->pointerlen!=4 && sdna->pointerlen!=8)) { + if (sp[1] != 2 || (sdna->pointerlen != 4 && sdna->pointerlen != 8)) { printf("ListBase struct error! Needs it to calculate pointerize.\n"); exit(0); /* well, at least sizeof(ListBase) is error proof! (ton) */ @@ -487,19 +487,19 @@ static void init_structDNA(SDNA *sdna, int do_endian_swap) /* second part of gravity problem, setting "gravity" type to void */ if (gravity_fix > -1) { - for (nr=0; nrnr_structs; nr++) { - sp= sdna->structs[nr]; + for (nr = 0; nr < sdna->nr_structs; nr++) { + sp = sdna->structs[nr]; if (strcmp(sdna->types[sp[0]], "ClothSimSettings") == 0) - sp[10]= SDNA_TYPE_VOID; + sp[10] = SDNA_TYPE_VOID; } } #ifdef WITH_DNA_GHASH /* create a ghash lookup to speed up */ - sdna->structs_map= BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "init_structDNA gh"); + sdna->structs_map = BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "init_structDNA gh"); for (nr = 0; nr < sdna->nr_structs; nr++) { - sp= sdna->structs[nr]; + sp = sdna->structs[nr]; BLI_ghash_insert(sdna->structs_map, (void *)sdna->types[sp[0]], (void *)(nr + 1)); } #endif @@ -508,12 +508,12 @@ static void init_structDNA(SDNA *sdna, int do_endian_swap) SDNA *DNA_sdna_from_data(void *data, int datalen, int do_endian_swap) { - SDNA *sdna= MEM_mallocN(sizeof(*sdna), "sdna"); + SDNA *sdna = MEM_mallocN(sizeof(*sdna), "sdna"); - sdna->lastfind= 0; + sdna->lastfind = 0; - sdna->datalen= datalen; - sdna->data= MEM_mallocN(datalen, "sdna_data"); + sdna->datalen = datalen; + sdna->data = MEM_mallocN(datalen, "sdna_data"); memcpy(sdna->data, data, datalen); init_structDNA(sdna, do_endian_swap); @@ -532,19 +532,19 @@ static void recurs_test_compflags(SDNA *sdna, char *compflags, int structnr) const char *cp; /* check all structs, test if it's inside another struct */ - sp= sdna->structs[structnr]; - typenr= sp[0]; + sp = sdna->structs[structnr]; + typenr = sp[0]; - for (a=0; anr_structs; a++) { - if (a!=structnr && compflags[a]==1) { - sp= sdna->structs[a]; - elems= sp[1]; - sp+= 2; - for (b=0; bnames[ sp[1] ]; + for (a = 0; a < sdna->nr_structs; a++) { + if (a != structnr && compflags[a] == 1) { + sp = sdna->structs[a]; + elems = sp[1]; + sp += 2; + for (b = 0; b < elems; b++, sp += 2) { + if (sp[0] == typenr) { + cp = sdna->names[sp[1]]; if (!ispointer(cp)) { - compflags[a]= 2; + compflags[a] = 2; recurs_test_compflags(sdna, compflags, a); } } @@ -554,11 +554,11 @@ static void recurs_test_compflags(SDNA *sdna, char *compflags, int structnr) } - /* Unsure of exact function - compares the sdna argument to - * newsdna and sets up the information necessary to convert - * data written with a dna of oldsdna to inmemory data with a - * structure defined by the newsdna sdna (I think). -zr - */ +/* Unsure of exact function - compares the sdna argument to + * newsdna and sets up the information necessary to convert + * data written with a dna of oldsdna to inmemory data with a + * structure defined by the newsdna sdna (I think). -zr + */ /* well, the function below is just a lookup table to speed * up reading files. doh! -ton @@ -576,53 +576,53 @@ char *DNA_struct_get_compareflags(SDNA *sdna, SDNA *newsdna) const char *str1, *str2; char *compflags; - if (sdna->nr_structs==0) { + if (sdna->nr_structs == 0) { printf("error: file without SDNA\n"); return NULL; } - compflags= MEM_callocN(sdna->nr_structs, "compflags"); + compflags = MEM_callocN(sdna->nr_structs, "compflags"); /* we check all structs in 'sdna' and compare them with * the structs in 'newsdna' */ - for (a=0; anr_structs; a++) { - spold= sdna->structs[a]; + for (a = 0; a < sdna->nr_structs; a++) { + spold = sdna->structs[a]; /* search for type in cur */ - spcur= findstruct_name(newsdna, sdna->types[spold[0]]); + spcur = findstruct_name(newsdna, sdna->types[spold[0]]); if (spcur) { - compflags[a]= 2; + compflags[a] = 2; /* compare length and amount of elems */ - if ( spcur[1] == spold[1]) { - if ( newsdna->typelens[spcur[0]] == sdna->typelens[spold[0]] ) { + if (spcur[1] == spold[1]) { + if (newsdna->typelens[spcur[0]] == sdna->typelens[spold[0]]) { /* same length, same amount of elems, now per type and name */ - b= spold[1]; - spold+= 2; - spcur+= 2; + b = spold[1]; + spold += 2; + spcur += 2; while (b > 0) { - str1= newsdna->types[spcur[0]]; - str2= sdna->types[spold[0]]; - if (strcmp(str1, str2)!=0) break; + str1 = newsdna->types[spcur[0]]; + str2 = sdna->types[spold[0]]; + if (strcmp(str1, str2) != 0) break; - str1= newsdna->names[spcur[1]]; - str2= sdna->names[spold[1]]; - if (strcmp(str1, str2)!=0) break; + str1 = newsdna->names[spcur[1]]; + str2 = sdna->names[spold[1]]; + if (strcmp(str1, str2) != 0) break; /* same type and same name, now pointersize */ if (ispointer(str1)) { - if (sdna->pointerlen!=newsdna->pointerlen) break; + if (sdna->pointerlen != newsdna->pointerlen) break; } b--; - spold+= 2; - spcur+= 2; + spold += 2; + spcur += 2; } - if (b==0) compflags[a]= 1; + if (b == 0) compflags[a] = 1; } } @@ -633,20 +633,20 @@ char *DNA_struct_get_compareflags(SDNA *sdna, SDNA *newsdna) /* first struct in util.h is struct Link, this is skipped in compflags (als # 0). * was a bug, and this way dirty patched! Solve this later.... */ - compflags[0]= 1; + compflags[0] = 1; /* Because structs can be inside structs, we recursively * set flags when a struct is altered */ - for (a=0; anr_structs; a++) { - if (compflags[a]==2) recurs_test_compflags(sdna, compflags, a); + for (a = 0; a < sdna->nr_structs; a++) { + if (compflags[a] == 2) recurs_test_compflags(sdna, compflags, a); } #if 0 - for (a=0; anr_structs; a++) { - if (compflags[a]==2) { - spold= sdna->structs[a]; - printf("changed: %s\n", sdna->types[ spold[0] ]); + for (a = 0; a < sdna->nr_structs; a++) { + if (compflags[a] == 2) { + spold = sdna->structs[a]; + printf("changed: %s\n", sdna->types[spold[0]]); } } #endif @@ -656,94 +656,94 @@ char *DNA_struct_get_compareflags(SDNA *sdna, SDNA *newsdna) static eSDNA_Type sdna_type_nr(const char *dna_type) { - if ((strcmp(dna_type, "char")==0) || (strcmp(dna_type, "const char")==0)) return SDNA_TYPE_CHAR; - else if ((strcmp(dna_type, "uchar")==0) || (strcmp(dna_type, "unsigned char")==0)) return SDNA_TYPE_UCHAR; - else if ( strcmp(dna_type, "short")==0) return SDNA_TYPE_SHORT; - else if ((strcmp(dna_type, "ushort")==0)||(strcmp(dna_type, "unsigned short")==0)) return SDNA_TYPE_USHORT; - else if ( strcmp(dna_type, "int")==0) return SDNA_TYPE_INT; - else if ( strcmp(dna_type, "long")==0) return SDNA_TYPE_LONG; - else if ((strcmp(dna_type, "ulong")==0)||(strcmp(dna_type, "unsigned long")==0)) return SDNA_TYPE_ULONG; - else if ( strcmp(dna_type, "float")==0) return SDNA_TYPE_FLOAT; - else if ( strcmp(dna_type, "double")==0) return SDNA_TYPE_DOUBLE; - else if ( strcmp(dna_type, "int64_t")==0) return SDNA_TYPE_INT64; - else if ( strcmp(dna_type, "uint64_t")==0) return SDNA_TYPE_UINT64; - else return -1; /* invalid! */ + if ((strcmp(dna_type, "char") == 0) || (strcmp(dna_type, "const char") == 0)) return SDNA_TYPE_CHAR; + else if ((strcmp(dna_type, "uchar") == 0) || (strcmp(dna_type, "unsigned char") == 0)) return SDNA_TYPE_UCHAR; + else if ( strcmp(dna_type, "short") == 0) return SDNA_TYPE_SHORT; + else if ((strcmp(dna_type, "ushort") == 0)||(strcmp(dna_type, "unsigned short") == 0)) return SDNA_TYPE_USHORT; + else if ( strcmp(dna_type, "int") == 0) return SDNA_TYPE_INT; + else if ( strcmp(dna_type, "long") == 0) return SDNA_TYPE_LONG; + else if ((strcmp(dna_type, "ulong") == 0)||(strcmp(dna_type, "unsigned long") == 0)) return SDNA_TYPE_ULONG; + else if ( strcmp(dna_type, "float") == 0) return SDNA_TYPE_FLOAT; + else if ( strcmp(dna_type, "double") == 0) return SDNA_TYPE_DOUBLE; + else if ( strcmp(dna_type, "int64_t") == 0) return SDNA_TYPE_INT64; + else if ( strcmp(dna_type, "uint64_t") == 0) return SDNA_TYPE_UINT64; + else return -1; /* invalid! */ } static void cast_elem(const char *ctype, const char *otype, const char *name, char *curdata, char *olddata) { double val = 0.0; - int arrlen, curlen=1, oldlen=1; + int arrlen, curlen = 1, oldlen = 1; eSDNA_Type ctypenr, otypenr; - arrlen= DNA_elem_array_size(name, strlen(name)); + arrlen = DNA_elem_array_size(name, strlen(name)); - if ( (otypenr= sdna_type_nr(otype)) == -1 || - (ctypenr= sdna_type_nr(ctype)) == -1 ) + if ( (otypenr = sdna_type_nr(otype)) == -1 || + (ctypenr = sdna_type_nr(ctype)) == -1) { return; } /* define lengths */ - oldlen= DNA_elem_type_size(otypenr); - curlen= DNA_elem_type_size(ctypenr); + oldlen = DNA_elem_type_size(otypenr); + curlen = DNA_elem_type_size(ctypenr); - while (arrlen>0) { + while (arrlen > 0) { switch (otypenr) { - case SDNA_TYPE_CHAR: - val= *olddata; break; - case SDNA_TYPE_UCHAR: - val= *( (unsigned char *)olddata); break; - case SDNA_TYPE_SHORT: - val= *( (short *)olddata); break; - case SDNA_TYPE_USHORT: - val= *( (unsigned short *)olddata); break; - case SDNA_TYPE_INT: - val= *( (int *)olddata); break; - case SDNA_TYPE_LONG: - val= *( (int *)olddata); break; - case SDNA_TYPE_ULONG: - val= *( (unsigned int *)olddata); break; - case SDNA_TYPE_FLOAT: - val= *( (float *)olddata); break; - case SDNA_TYPE_DOUBLE: - val= *( (double *)olddata); break; - case SDNA_TYPE_INT64: - val= *( (int64_t *)olddata); break; - case SDNA_TYPE_UINT64: - val= *( (uint64_t *)olddata); break; + case SDNA_TYPE_CHAR: + val = *olddata; break; + case SDNA_TYPE_UCHAR: + val = *( (unsigned char *)olddata); break; + case SDNA_TYPE_SHORT: + val = *( (short *)olddata); break; + case SDNA_TYPE_USHORT: + val = *( (unsigned short *)olddata); break; + case SDNA_TYPE_INT: + val = *( (int *)olddata); break; + case SDNA_TYPE_LONG: + val = *( (int *)olddata); break; + case SDNA_TYPE_ULONG: + val = *( (unsigned int *)olddata); break; + case SDNA_TYPE_FLOAT: + val = *( (float *)olddata); break; + case SDNA_TYPE_DOUBLE: + val = *( (double *)olddata); break; + case SDNA_TYPE_INT64: + val = *( (int64_t *)olddata); break; + case SDNA_TYPE_UINT64: + val = *( (uint64_t *)olddata); break; } switch (ctypenr) { - case SDNA_TYPE_CHAR: - *curdata= val; break; - case SDNA_TYPE_UCHAR: - *( (unsigned char *)curdata)= val; break; - case SDNA_TYPE_SHORT: - *( (short *)curdata)= val; break; - case SDNA_TYPE_USHORT: - *( (unsigned short *)curdata)= val; break; - case SDNA_TYPE_INT: - *( (int *)curdata)= val; break; - case SDNA_TYPE_LONG: - *( (int *)curdata)= val; break; - case SDNA_TYPE_ULONG: - *( (unsigned int *)curdata)= val; break; - case SDNA_TYPE_FLOAT: - if (otypenr<2) val/= 255; - *( (float *)curdata)= val; break; - case SDNA_TYPE_DOUBLE: - if (otypenr<2) val/= 255; - *( (double *)curdata)= val; break; - case SDNA_TYPE_INT64: - *( (int64_t *)curdata)= val; break; - case SDNA_TYPE_UINT64: - *( (uint64_t *)curdata)= val; break; + case SDNA_TYPE_CHAR: + *curdata = val; break; + case SDNA_TYPE_UCHAR: + *( (unsigned char *)curdata) = val; break; + case SDNA_TYPE_SHORT: + *( (short *)curdata) = val; break; + case SDNA_TYPE_USHORT: + *( (unsigned short *)curdata) = val; break; + case SDNA_TYPE_INT: + *( (int *)curdata) = val; break; + case SDNA_TYPE_LONG: + *( (int *)curdata) = val; break; + case SDNA_TYPE_ULONG: + *( (unsigned int *)curdata) = val; break; + case SDNA_TYPE_FLOAT: + if (otypenr < 2) val /= 255; + *( (float *)curdata) = val; break; + case SDNA_TYPE_DOUBLE: + if (otypenr < 2) val /= 255; + *( (double *)curdata) = val; break; + case SDNA_TYPE_INT64: + *( (int64_t *)curdata) = val; break; + case SDNA_TYPE_UINT64: + *( (uint64_t *)curdata) = val; break; } - olddata+= oldlen; - curdata+= curlen; + olddata += oldlen; + curdata += curlen; arrlen--; } } @@ -757,26 +757,26 @@ static void cast_pointer(int curlen, int oldlen, const char *name, char *curdata #endif int arrlen; - arrlen= DNA_elem_array_size(name, strlen(name)); + arrlen = DNA_elem_array_size(name, strlen(name)); - while (arrlen>0) { + while (arrlen > 0) { - if (curlen==oldlen) { + if (curlen == oldlen) { memcpy(curdata, olddata, curlen); } - else if (curlen==4 && oldlen==8) { + else if (curlen == 4 && oldlen == 8) { #ifdef WIN32 - lval= *( (__int64 *)olddata ); + lval = *( (__int64 *)olddata); #else - lval= *( (long long *)olddata ); + lval = *( (long long *)olddata); #endif - *((int *)curdata) = lval>>3; /* is of course gambling! */ + *((int *)curdata) = lval >> 3; /* is of course gambling! */ } - else if (curlen==8 && oldlen==4) { + else if (curlen == 8 && oldlen == 4) { #ifdef WIN32 - *( (__int64 *)curdata ) = *((int *)olddata); + *( (__int64 *)curdata) = *((int *)olddata); #else - *( (long long *)curdata ) = *((int *)olddata); + *( (long long *)curdata) = *((int *)olddata); #endif } else { @@ -784,8 +784,8 @@ static void cast_pointer(int curlen, int oldlen, const char *name, char *curdata printf("errpr: illegal pointersize!\n"); } - olddata+= oldlen; - curdata+= curlen; + olddata += oldlen; + curdata += curlen; arrlen--; } @@ -793,14 +793,14 @@ static void cast_pointer(int curlen, int oldlen, const char *name, char *curdata static int elem_strcmp(const char *name, const char *oname) { - int a=0; + int a = 0; /* strcmp without array part */ while (1) { if (name[a] != oname[a]) return 1; - if (name[a]=='[') break; - if (name[a]==0) break; + if (name[a] == '[') break; + if (name[a] == 0) break; a++; } return 0; @@ -814,25 +814,25 @@ static char *find_elem(SDNA *sdna, const char *type, const char *name, short *ol /* without arraypart, so names can differ: return old namenr and type */ /* in old is the old struct */ - elemcount= old[1]; - old+= 2; - for (a=0; atypes[old[0]]; - oname= sdna->names[old[1]]; - - len= elementsize(sdna, old[0], old[1]); - - if ( elem_strcmp(name, oname)==0 ) { /* naam equal */ - if ( strcmp(type, otype)==0 ) { /* type equal */ - if (sppo) *sppo= old; + elemcount = old[1]; + old += 2; + for (a = 0; a < elemcount; a++, old += 2) { + + otype = sdna->types[old[0]]; + oname = sdna->names[old[1]]; + + len = elementsize(sdna, old[0], old[1]); + + if (elem_strcmp(name, oname) == 0) { /* naam equal */ + if (strcmp(type, otype) == 0) { /* type equal */ + if (sppo) *sppo = old; return olddata; } return NULL; } - olddata+= len; + olddata += len; } return NULL; } @@ -841,11 +841,11 @@ static void reconstruct_elem(SDNA *newsdna, SDNA *oldsdna, char *type, const char *name, char *curdata, short *old, char *olddata) { /* rules: test for NAME: - * - name equal: - * - cast type - * - name partially equal (array differs) - * - type equal: memcpy - * - types casten + * - name equal: + * - cast type + * - name partially equal (array differs) + * - type equal: memcpy + * - types casten * (nzc 2-4-2001 I want the 'unsigned' bit to be parsed as well. Where * can I force this?) */ @@ -854,61 +854,61 @@ static void reconstruct_elem(SDNA *newsdna, SDNA *oldsdna, const char *oname, *cp; /* is 'name' an array? */ - cp= name; - array= 0; - while ( *cp && *cp!='[') { + cp = name; + array = 0; + while (*cp && *cp != '[') { cp++; array++; } - if ( *cp!= '[' ) array= 0; + if (*cp != '[') array = 0; /* in old is the old struct */ - elemcount= old[1]; - old+= 2; - for (a=0; atypes[old[0]]; - oname= oldsdna->names[old[1]]; - len= elementsize(oldsdna, old[0], old[1]); + elemcount = old[1]; + old += 2; + for (a = 0; a < elemcount; a++, old += 2) { + otype = oldsdna->types[old[0]]; + oname = oldsdna->names[old[1]]; + len = elementsize(oldsdna, old[0], old[1]); - if ( strcmp(name, oname)==0 ) { /* name equal */ + if (strcmp(name, oname) == 0) { /* name equal */ - if (ispointer(name)) { /* pointer of functionpointer afhandelen */ + if (ispointer(name)) { /* pointer of functionpointer afhandelen */ cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, name, curdata, olddata); } - else if ( strcmp(type, otype)==0 ) { /* type equal */ + else if (strcmp(type, otype) == 0) { /* type equal */ memcpy(curdata, olddata, len); } else cast_elem(type, otype, name, curdata, olddata); return; } - else if (array) { /* name is an array */ + else if (array) { /* name is an array */ - if (oname[array]=='[' && strncmp(name, oname, array)==0 ) { /* basis equal */ + if (oname[array] == '[' && strncmp(name, oname, array) == 0) { /* basis equal */ - cursize= DNA_elem_array_size(name, strlen(name)); - oldsize= DNA_elem_array_size(oname, strlen(oname)); + cursize = DNA_elem_array_size(name, strlen(name)); + oldsize = DNA_elem_array_size(oname, strlen(oname)); - if (ispointer(name)) { /* handle pointer or functionpointer */ - if (cursize>oldsize) cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, oname, curdata, olddata); + if (ispointer(name)) { /* handle pointer or functionpointer */ + if (cursize > oldsize) cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, oname, curdata, olddata); else cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, name, curdata, olddata); } - else if (name[0]=='*' || strcmp(type, otype)==0 ) { /* type equal */ - mul= len/oldsize; - mul*= (cursize < oldsize)? cursize: oldsize; + else if (name[0] == '*' || strcmp(type, otype) == 0) { /* type equal */ + mul = len / oldsize; + mul *= (cursize < oldsize) ? cursize : oldsize; memcpy(curdata, olddata, mul); /* terminate strings */ - if (oldsize > cursize && strcmp(type, "char")==0) - curdata[mul-1]= 0; + if (oldsize > cursize && strcmp(type, "char") == 0) + curdata[mul - 1] = 0; } else { - if (cursize>oldsize) cast_elem(type, otype, oname, curdata, olddata); + if (cursize > oldsize) cast_elem(type, otype, oname, curdata, olddata); else cast_elem(type, otype, name, curdata, olddata); } return; } } - olddata+= len; + olddata += len; } } @@ -924,69 +924,69 @@ static void reconstruct_struct(SDNA *newsdna, SDNA *oldsdna, char *type, *cpo, *cpc; const char *name, *nameo; - if (oldSDNAnr== -1) return; - if (curSDNAnr== -1) return; + if (oldSDNAnr == -1) return; + if (curSDNAnr == -1) return; - if ( compflags[oldSDNAnr]==1 ) { /* if recursive: test for equal */ + if (compflags[oldSDNAnr] == 1) { /* if recursive: test for equal */ - spo= oldsdna->structs[oldSDNAnr]; - elen= oldsdna->typelens[ spo[0] ]; + spo = oldsdna->structs[oldSDNAnr]; + elen = oldsdna->typelens[spo[0]]; memcpy(cur, data, elen); return; } - firststructtypenr= *(newsdna->structs[0]); + firststructtypenr = *(newsdna->structs[0]); - spo= oldsdna->structs[oldSDNAnr]; - spc= newsdna->structs[curSDNAnr]; + spo = oldsdna->structs[oldSDNAnr]; + spc = newsdna->structs[curSDNAnr]; - elemcount= spc[1]; + elemcount = spc[1]; - spc+= 2; - cpc= cur; - for (a=0; atypes[spc[0]]; - name= newsdna->names[spc[1]]; + spc += 2; + cpc = cur; + for (a = 0; a < elemcount; a++, spc += 2) { + type = newsdna->types[spc[0]]; + name = newsdna->names[spc[1]]; - elen= elementsize(newsdna, spc[0], spc[1]); + elen = elementsize(newsdna, spc[0], spc[1]); /* test: is type a struct? */ - if (spc[0]>=firststructtypenr && !ispointer(name)) { + if (spc[0] >= firststructtypenr && !ispointer(name)) { /* where does the old struct data start (and is there an old one?) */ - cpo= find_elem(oldsdna, type, name, spo, data, &sppo); + cpo = find_elem(oldsdna, type, name, spo, data, &sppo); if (cpo) { - oldSDNAnr= DNA_struct_find_nr(oldsdna, type); - curSDNAnr= DNA_struct_find_nr(newsdna, type); + oldSDNAnr = DNA_struct_find_nr(oldsdna, type); + curSDNAnr = DNA_struct_find_nr(newsdna, type); /* array! */ - mul= DNA_elem_array_size(name, strlen(name)); - nameo= oldsdna->names[sppo[1]]; - mulo= DNA_elem_array_size(nameo, strlen(nameo)); + mul = DNA_elem_array_size(name, strlen(name)); + nameo = oldsdna->names[sppo[1]]; + mulo = DNA_elem_array_size(nameo, strlen(nameo)); - eleno= elementsize(oldsdna, sppo[0], sppo[1]); + eleno = elementsize(oldsdna, sppo[0], sppo[1]); - elen/= mul; - eleno/= mulo; + elen /= mul; + eleno /= mulo; while (mul--) { reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc); - cpo+= eleno; - cpc+= elen; + cpo += eleno; + cpc += elen; /* new struct array larger than old */ mulo--; - if (mulo<=0) break; + if (mulo <= 0) break; } } - else cpc+= elen; + else cpc += elen; } else { reconstruct_elem(newsdna, oldsdna, type, name, cpc, spo, data); - cpc+= elen; + cpc += elen; } } @@ -1002,32 +1002,32 @@ void DNA_struct_switch_endian(SDNA *oldsdna, int oldSDNAnr, char *data) char *type, *cpo, *cur, cval; const char *name; - if (oldSDNAnr== -1) return; - firststructtypenr= *(oldsdna->structs[0]); + if (oldSDNAnr == -1) return; + firststructtypenr = *(oldsdna->structs[0]); - spo= spc= oldsdna->structs[oldSDNAnr]; + spo = spc = oldsdna->structs[oldSDNAnr]; - elemcount= spo[1]; + elemcount = spo[1]; - spc+= 2; - cur= data; + spc += 2; + cur = data; - for (a=0; atypes[spc[0]]; - name= oldsdna->names[spc[1]]; + for (a = 0; a < elemcount; a++, spc += 2) { + type = oldsdna->types[spc[0]]; + name = oldsdna->names[spc[1]]; /* elementsize = including arraysize */ - elen= elementsize(oldsdna, spc[0], spc[1]); + elen = elementsize(oldsdna, spc[0], spc[1]); /* test: is type a struct? */ - if (spc[0]>=firststructtypenr && !ispointer(name)) { + if (spc[0] >= firststructtypenr && !ispointer(name)) { /* where does the old data start (is there one?) */ - cpo= find_elem(oldsdna, type, name, spo, data, NULL); + cpo = find_elem(oldsdna, type, name, spo, data, NULL); if (cpo) { - oldSDNAnr= DNA_struct_find_nr(oldsdna, type); + oldSDNAnr = DNA_struct_find_nr(oldsdna, type); - mul= DNA_elem_array_size(name, strlen(name)); - elena= elen/mul; + mul = DNA_elem_array_size(name, strlen(name)); + elena = elen / mul; while (mul--) { DNA_struct_switch_endian(oldsdna, oldSDNAnr, cpo); @@ -1038,113 +1038,113 @@ void DNA_struct_switch_endian(SDNA *oldsdna, int oldSDNAnr, char *data) else { if (ispointer(name)) { - if (oldsdna->pointerlen==8) { + if (oldsdna->pointerlen == 8) { - mul= DNA_elem_array_size(name, strlen(name)); - cpo= cur; + mul = DNA_elem_array_size(name, strlen(name)); + cpo = cur; while (mul--) { - cval= cpo[0]; cpo[0]= cpo[7]; cpo[7]= cval; - cval= cpo[1]; cpo[1]= cpo[6]; cpo[6]= cval; - cval= cpo[2]; cpo[2]= cpo[5]; cpo[5]= cval; - cval= cpo[3]; cpo[3]= cpo[4]; cpo[4]= cval; + cval = cpo[0]; cpo[0] = cpo[7]; cpo[7] = cval; + cval = cpo[1]; cpo[1] = cpo[6]; cpo[6] = cval; + cval = cpo[2]; cpo[2] = cpo[5]; cpo[5] = cval; + cval = cpo[3]; cpo[3] = cpo[4]; cpo[4] = cval; - cpo+= 8; + cpo += 8; } } } else { - if ( spc[0]==SDNA_TYPE_SHORT || - spc[0]==SDNA_TYPE_USHORT ) + if (spc[0] == SDNA_TYPE_SHORT || + spc[0] == SDNA_TYPE_USHORT) { /* exception: variable called blocktype/ipowin: derived from ID_ */ - skip= 0; - if (name[0]=='b' && name[1]=='l') { - if (strcmp(name, "blocktype")==0) skip= 1; + skip = 0; + if (name[0] == 'b' && name[1] == 'l') { + if (strcmp(name, "blocktype") == 0) skip = 1; } - else if (name[0]=='i' && name[1]=='p') { - if (strcmp(name, "ipowin")==0) skip= 1; + else if (name[0] == 'i' && name[1] == 'p') { + if (strcmp(name, "ipowin") == 0) skip = 1; } - if (skip==0) { - mul= DNA_elem_array_size(name, strlen(name)); - cpo= cur; + if (skip == 0) { + mul = DNA_elem_array_size(name, strlen(name)); + cpo = cur; while (mul--) { - cval= cpo[0]; - cpo[0]= cpo[1]; - cpo[1]= cval; - cpo+= 2; + cval = cpo[0]; + cpo[0] = cpo[1]; + cpo[1] = cval; + cpo += 2; } } } - else if ( (spc[0]==SDNA_TYPE_INT || - spc[0]==SDNA_TYPE_LONG || - spc[0]==SDNA_TYPE_ULONG || - spc[0]==SDNA_TYPE_FLOAT)) + else if ( (spc[0] == SDNA_TYPE_INT || + spc[0] == SDNA_TYPE_LONG || + spc[0] == SDNA_TYPE_ULONG || + spc[0] == SDNA_TYPE_FLOAT)) { - mul= DNA_elem_array_size(name, strlen(name)); - cpo= cur; + mul = DNA_elem_array_size(name, strlen(name)); + cpo = cur; while (mul--) { - cval= cpo[0]; - cpo[0]= cpo[3]; - cpo[3]= cval; - cval= cpo[1]; - cpo[1]= cpo[2]; - cpo[2]= cval; - cpo+= 4; + cval = cpo[0]; + cpo[0] = cpo[3]; + cpo[3] = cval; + cval = cpo[1]; + cpo[1] = cpo[2]; + cpo[2] = cval; + cpo += 4; } } - else if ( (spc[0]==SDNA_TYPE_INT64) || - (spc[0]==SDNA_TYPE_UINT64)) + else if ( (spc[0] == SDNA_TYPE_INT64) || + (spc[0] == SDNA_TYPE_UINT64)) { - mul= DNA_elem_array_size(name, strlen(name)); - cpo= cur; + mul = DNA_elem_array_size(name, strlen(name)); + cpo = cur; while (mul--) { - cval= cpo[0]; cpo[0]= cpo[7]; cpo[7]= cval; - cval= cpo[1]; cpo[1]= cpo[6]; cpo[6]= cval; - cval= cpo[2]; cpo[2]= cpo[5]; cpo[5]= cval; - cval= cpo[3]; cpo[3]= cpo[4]; cpo[4]= cval; + cval = cpo[0]; cpo[0] = cpo[7]; cpo[7] = cval; + cval = cpo[1]; cpo[1] = cpo[6]; cpo[6] = cval; + cval = cpo[2]; cpo[2] = cpo[5]; cpo[5] = cval; + cval = cpo[3]; cpo[3] = cpo[4]; cpo[4] = cval; - cpo+= 8; + cpo += 8; } } } } - cur+= elen; + cur += elen; } } void *DNA_struct_reconstruct(SDNA *newsdna, SDNA *oldsdna, char *compflags, int oldSDNAnr, int blocks, void *data) { - int a, curSDNAnr, curlen=0, oldlen; + int a, curSDNAnr, curlen = 0, oldlen; short *spo, *spc; char *cur, *type, *cpc, *cpo; /* oldSDNAnr == structnr, we're looking for the corresponding 'cur' number */ - spo= oldsdna->structs[oldSDNAnr]; - type= oldsdna->types[ spo[0] ]; - oldlen= oldsdna->typelens[ spo[0] ]; - curSDNAnr= DNA_struct_find_nr(newsdna, type); + spo = oldsdna->structs[oldSDNAnr]; + type = oldsdna->types[spo[0]]; + oldlen = oldsdna->typelens[spo[0]]; + curSDNAnr = DNA_struct_find_nr(newsdna, type); /* init data and alloc */ if (curSDNAnr >= 0) { - spc= newsdna->structs[curSDNAnr]; - curlen= newsdna->typelens[ spc[0] ]; + spc = newsdna->structs[curSDNAnr]; + curlen = newsdna->typelens[spc[0]]; } - if (curlen==0) { + if (curlen == 0) { return NULL; } - cur= MEM_callocN(blocks*curlen, "reconstruct"); - cpc= cur; - cpo= data; - for (a=0; astructs[SDNAnr]; - char *cp= find_elem(sdna, vartype, name, spo, NULL, NULL); + int SDNAnr = DNA_struct_find_nr(sdna, stype); + short *spo = sdna->structs[SDNAnr]; + char *cp = find_elem(sdna, vartype, name, spo, NULL, NULL); return (int)((intptr_t)cp); } diff --git a/source/blender/makesdna/intern/makesdna.c b/source/blender/makesdna/intern/makesdna.c index 5ce5827fac3..fd32def784d 100644 --- a/source/blender/makesdna/intern/makesdna.c +++ b/source/blender/makesdna/intern/makesdna.c @@ -137,18 +137,18 @@ static const char *includefiles[] = { "" }; -static int maxdata= 500000, maxnr= 50000; -static int nr_names=0; -static int nr_types=0; -static int nr_structs=0; -static char **names, *namedata; /* at address names[a] is string a */ -static char **types, *typedata; /* at address types[a] is string a */ -static short *typelens; /* at typelens[a] is de length of type a */ -static short *alphalens; /* contains sizes as they are calculated on the DEC Alpha (64 bits), infact any 64bit system */ -static short **structs, *structdata;/* at sp= structs[a] is the first address of a struct definition - * sp[0] is type number - * sp[1] is amount of elements - * sp[2] sp[3] is typenr, namenr (etc) */ +static int maxdata = 500000, maxnr = 50000; +static int nr_names = 0; +static int nr_types = 0; +static int nr_structs = 0; +static char **names, *namedata; /* at address names[a] is string a */ +static char **types, *typedata; /* at address types[a] is string a */ +static short *typelens; /* at typelens[a] is de length of type a */ +static short *alphalens; /* contains sizes as they are calculated on the DEC Alpha (64 bits), infact any 64bit system */ +static short **structs, *structdata; /* at sp= structs[a] is the first address of a struct definition + * sp[0] is type number + * sp[1] is amount of elements + * sp[2] sp[3] is typenr, namenr (etc) */ /** * Variable to control debug output of makesdna. * debugSDNA: @@ -228,7 +228,7 @@ static int add_type(const char *str, int len) char *cp; /* first do validity check */ - if (str[0]==0) { + if (str[0] == 0) { return -1; } else if (strchr(str, '*')) { @@ -238,10 +238,10 @@ static int add_type(const char *str, int len) } /* search through type array */ - for (nr=0; nr=maxnr) { + if (nr_types >= maxnr) { printf("too many types\n"); - return nr_types-1; + return nr_types - 1; } nr_types++; - return nr_types-1; + return nr_types - 1; } @@ -285,14 +285,14 @@ static int add_name(const char *str) additional_slen_offset = 0; - if (str[0]==0 /* || (str[1]==0) */) return -1; + if (str[0] == 0 /* || (str[1]==0) */) return -1; if (str[0] == '(' && str[1] == '*') { /* we handle function pointer and special array cases here, e.g. * void (*function)(...) and float (*array)[..]. the array case * name is still converted to (array*)() though because it is that * way in old dna too, and works correct with elementsize() */ - int isfuncptr = (strchr(str+1, '(')) != NULL; + int isfuncptr = (strchr(str + 1, '(')) != NULL; if (debugSDNA > 3) printf("\t\t\t\t*** Function pointer or multidim array pointer found\n"); /* functionpointer: transform the type (sometimes) */ @@ -311,13 +311,13 @@ static int add_name(const char *str) if (debugSDNA > 3) printf("first brace after offset %d\n", i); j++; /* j beyond closing brace ? */ - while ((str[j] != 0) && (str[j] != ')' )) { + while ((str[j] != 0) && (str[j] != ')')) { if (debugSDNA > 3) printf("seen %c ( %d)\n", str[j], str[j]); j++; } if (debugSDNA > 3) printf("seen %c ( %d)\n" - "special after offset%d\n", - str[j], str[j], j); + "special after offset%d\n", + str[j], str[j], j); if (!isfuncptr) { /* multidimensional array pointer case */ @@ -327,7 +327,7 @@ static int add_name(const char *str) else printf("Error during tokening multidim array pointer\n"); } - else if (str[j] == 0 ) { + else if (str[j] == 0) { if (debugSDNA > 3) printf("offsetting for space\n"); /* get additional offset */ k = 0; @@ -338,7 +338,7 @@ static int add_name(const char *str) if (debugSDNA > 3) printf("extra offset %d\n", k); additional_slen_offset = k; } - else if (str[j] == ')' ) { + else if (str[j] == ')') { if (debugSDNA > 3) printf("offsetting for brace\n"); ; /* don't get extra offset */ } @@ -364,22 +364,22 @@ static int add_name(const char *str) (strncmp(buf, "(*windraw", 9) == 0) ) { buf[i] = ')'; - buf[i+1] = '('; - buf[i+2] = 'v'; - buf[i+3] = 'o'; - buf[i+4] = 'i'; - buf[i+5] = 'd'; - buf[i+6] = ')'; - buf[i+7] = 0; + buf[i + 1] = '('; + buf[i + 2] = 'v'; + buf[i + 3] = 'o'; + buf[i + 4] = 'i'; + buf[i + 5] = 'd'; + buf[i + 6] = ')'; + buf[i + 7] = 0; } else { buf[i] = ')'; - buf[i+1] = '('; - buf[i+2] = ')'; - buf[i+3] = 0; + buf[i + 1] = '('; + buf[i + 2] = ')'; + buf[i + 3] = 0; } /* now precede with buf*/ - if (debugSDNA > 3) printf("\t\t\t\t\tProposing fp name %s\n", buf); + if (debugSDNA > 3) printf("\t\t\t\t\tProposing fp name %s\n", buf); name = buf; } else { @@ -388,27 +388,27 @@ static int add_name(const char *str) } /* search name array */ - for (nr=0; nr=maxnr) { + if (nr_names >= maxnr) { printf("too many names\n"); - return nr_names-1; + return nr_names - 1; } nr_names++; - return nr_names-1; + return nr_names - 1; } static short *add_struct(int namecode) @@ -416,19 +416,19 @@ static short *add_struct(int namecode) int len; short *sp; - if (nr_structs==0) { - structs[0]= structdata; + if (nr_structs == 0) { + structs[0] = structdata; } else { - sp= structs[nr_structs-1]; - len= sp[1]; - structs[nr_structs]= sp+ 2*len+2; + sp = structs[nr_structs - 1]; + len = sp[1]; + structs[nr_structs] = sp + 2 * len + 2; } - sp= structs[nr_structs]; - sp[0]= namecode; + sp = structs[nr_structs]; + sp[0] = namecode; - if (nr_structs>=maxnr) { + if (nr_structs >= maxnr) { printf("too many structs\n"); return sp; } @@ -444,58 +444,58 @@ static int preprocess_include(char *maindata, int len) /* note: len + 1, last character is a dummy to prevent * comparisons using uninitialized memory */ - temp= MEM_mallocN(len + 1, "preprocess_include"); - temp[len]= ' '; + temp = MEM_mallocN(len + 1, "preprocess_include"); + temp[len] = ' '; memcpy(temp, maindata, len); // remove all c++ comments /* replace all enters/tabs/etc with spaces */ - cp= temp; - a= len; + cp = temp; + a = len; comment = 0; while (a--) { - if (cp[0]=='/' && cp[1]=='/') { + if (cp[0] == '/' && cp[1] == '/') { comment = 1; } - else if (*cp<32) { + else if (*cp < 32) { comment = 0; } - if (comment || *cp<32 || *cp>128 ) *cp= 32; + if (comment || *cp < 32 || *cp > 128) *cp = 32; cp++; } /* data from temp copy to maindata, remove comments and double spaces */ - cp= temp; - md= maindata; - newlen= 0; - comment= 0; - a= len; + cp = temp; + md = maindata; + newlen = 0; + comment = 0; + a = len; while (a--) { - if (cp[0]=='/' && cp[1]=='*') { - comment= 1; - cp[0]=cp[1]= 32; + if (cp[0] == '/' && cp[1] == '*') { + comment = 1; + cp[0] = cp[1] = 32; } - if (cp[0]=='*' && cp[1]=='/') { - comment= 0; - cp[0]=cp[1]= 32; + if (cp[0] == '*' && cp[1] == '/') { + comment = 0; + cp[0] = cp[1] = 32; } /* do not copy when: */ - if (comment); - else if ( cp[0]==' ' && cp[1]==' ' ); - else if ( cp[-1]=='*' && cp[0]==' ' ); /* pointers with a space */ + if (comment) ; + else if (cp[0] == ' ' && cp[1] == ' ') ; + else if (cp[-1] == '*' && cp[0] == ' ') ; /* pointers with a space */ /* skip special keywords */ - else if (strncmp("DNA_DEPRECATED", cp, 14)==0) { + else if (strncmp("DNA_DEPRECATED", cp, 14) == 0) { /* single values are skipped already, so decrement 1 less */ a -= 13; cp += 13; } else { - md[0]= cp[0]; + md[0] = cp[0]; md++; newlen++; } @@ -509,30 +509,30 @@ static int preprocess_include(char *maindata, int len) static void *read_file_data(char *filename, int *len_r) { #ifdef WIN32 - FILE *fp= fopen(filename, "rb"); + FILE *fp = fopen(filename, "rb"); #else - FILE *fp= fopen(filename, "r"); + FILE *fp = fopen(filename, "r"); #endif void *data; if (!fp) { - *len_r= -1; + *len_r = -1; return NULL; } fseek(fp, 0L, SEEK_END); - *len_r= ftell(fp); + *len_r = ftell(fp); fseek(fp, 0L, SEEK_SET); - data= MEM_mallocN(*len_r, "read_file_data"); + data = MEM_mallocN(*len_r, "read_file_data"); if (!data) { - *len_r= -1; + *len_r = -1; fclose(fp); return NULL; } - if (fread(data, *len_r, 1, fp)!=1) { - *len_r= -1; + if (fread(data, *len_r, 1, fp) != 1) { + *len_r = -1; MEM_freeN(data); fclose(fp); return NULL; @@ -551,38 +551,38 @@ static int convert_include(char *filename) short *structpoin, *sp; char *maindata, *mainend, *md, *md1; - md= maindata= read_file_data(filename, &filelen); - if (filelen==-1) { + md = maindata = read_file_data(filename, &filelen); + if (filelen == -1) { printf("Can't read file %s\n", filename); return 1; } - filelen= preprocess_include(maindata, filelen); - mainend= maindata+filelen-1; + filelen = preprocess_include(maindata, filelen); + mainend = maindata + filelen - 1; /* we look for '{' and then back to 'struct' */ - count= 0; - overslaan= 0; - while (count 1) printf("\t|\t|-- detected struct %s\n", types[strct]); /* first lets make it all nice strings */ - md1= md+1; + md1 = md + 1; while (*md1 != '}') { - if (md1>mainend) break; + if (md1 > mainend) break; - if (*md1==',' || *md1==' ') *md1= 0; + if (*md1 == ',' || *md1 == ' ') *md1 = 0; md1++; } /* read types and names until first character that is not '}' */ - md1= md+1; - while ( *md1 != '}' ) { - if (md1>mainend) break; + md1 = md + 1; + while (*md1 != '}') { + if (md1 > mainend) break; /* skip when it says 'struct' or 'unsigned' or 'const' */ if (*md1) { - if ( strncmp(md1, "struct", 6)==0 ) md1+= 7; - if ( strncmp(md1, "unsigned", 8)==0 ) md1+= 9; - if ( strncmp(md1, "const", 5)==0 ) md1+= 6; + if (strncmp(md1, "struct", 6) == 0) md1 += 7; + if (strncmp(md1, "unsigned", 8) == 0) md1 += 9; + if (strncmp(md1, "const", 5) == 0) md1 += 6; /* we've got a type! */ - type= add_type(md1, 0); + type = add_type(md1, 0); if (type == -1) { printf("File '%s' contains struct we can't parse \"%s\"\n", filename, md1); return 1; @@ -624,48 +624,48 @@ static int convert_include(char *filename) if (debugSDNA > 1) printf("\t|\t|\tfound type %s (", md1); - md1+= strlen(md1); + md1 += strlen(md1); /* read until ';' */ - while ( *md1 != ';' ) { - if (md1>mainend) break; + while (*md1 != ';') { + if (md1 > mainend) break; if (*md1) { /* We've got a name. slen needs * correction for function * pointers! */ - slen= (int) strlen(md1); - if ( md1[slen-1]==';' ) { - md1[slen-1]= 0; + slen = (int) strlen(md1); + if (md1[slen - 1] == ';') { + md1[slen - 1] = 0; - name= add_name(md1); + name = add_name(md1); slen += additional_slen_offset; - sp[0]= type; - sp[1]= name; + sp[0] = type; + sp[1] = name; - if ((debugSDNA>1) && (names[name] != NULL)) printf("%s |", names[name]); + if ((debugSDNA > 1) && (names[name] != NULL)) printf("%s |", names[name]); structpoin[1]++; - sp+= 2; + sp += 2; - md1+= slen; + md1 += slen; break; } - name= add_name(md1); + name = add_name(md1); slen += additional_slen_offset; - sp[0]= type; - sp[1]= name; + sp[0] = type; + sp[1] = name; if ((debugSDNA > 1) && (names[name] != NULL)) printf("%s ||", names[name]); structpoin[1]++; - sp+= 2; + sp += 2; - md1+= slen; + md1 += slen; } md1++; } @@ -689,20 +689,20 @@ static int convert_include(char *filename) static int arraysize(char *astr, int len) { - int a, mul=1; - char str[100], *cp=NULL; + int a, mul = 1; + char str[100], *cp = NULL; - memcpy(str, astr, len+1); + memcpy(str, astr, len + 1); - for (a=0; a= firststruct) { - if (sizeof(void *)==8 && (len % 8) ) { + if (sizeof(void *) == 8 && (len % 8) ) { printf("Align struct error: %s %s\n", types[structtype], cp); dna_error = 1; } } /* 2-4 aligned/ */ - if (typelens[type]>3 && (len % 4) ) { - printf("Align 4 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len%4); + if (typelens[type] > 3 && (len % 4) ) { + printf("Align 4 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len % 4); dna_error = 1; } - else if (typelens[type]==2 && (len % 2) ) { - printf("Align 2 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len%2); + else if (typelens[type] == 2 && (len % 2) ) { + printf("Align 2 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len % 2); dna_error = 1; } - len += mul*typelens[type]; + len += mul * typelens[type]; alphalen += mul * alphalens[type]; } else { - len= 0; + len = 0; alphalen = 0; break; } } - if (len==0) { + if (len == 0) { unknown++; } else { - typelens[structtype]= len; - alphalens[structtype]= alphalen; + typelens[structtype] = len; + alphalens[structtype] = alphalen; // two ways to detect if a struct contains a pointer: // has_pointer is set or alphalen != len if (has_pointer || alphalen != len) { if (alphalen % 8) { - printf("Sizeerror 8 in struct: %s (add %d bytes)\n", types[structtype], alphalen%8); + printf("Sizeerror 8 in struct: %s (add %d bytes)\n", types[structtype], alphalen % 8); dna_error = 1; } } if (len % 4) { - printf("Sizeerror 4 in struct: %s (add %d bytes)\n", types[structtype], len%4); + printf("Sizeerror 4 in struct: %s (add %d bytes)\n", types[structtype], len % 4); dna_error = 1; } @@ -842,7 +842,7 @@ static int calculate_structlens(int firststruct) } } - if (unknown==lastunknown) break; + if (unknown == lastunknown) break; } if (unknown) { @@ -851,12 +851,12 @@ static int calculate_structlens(int firststruct) if (debugSDNA) { printf("*** Known structs :\n"); - for (a=0; a= MAX_DNA_LINE_LENGTH) { @@ -903,19 +903,19 @@ void dna_write(FILE *file, void *pntr, int size) void printStructLenghts(void) { - int a, unknown= nr_structs, structtype; + int a, unknown = nr_structs, structtype; /*int lastunknown;*/ /*UNUSED*/ short *structpoin; printf("\n\n*** All detected structs:\n"); while (unknown) { /*lastunknown= unknown;*/ /*UNUSED*/ - unknown= 0; + unknown = 0; /* check all structs... */ - for (a=0; a 1) { int a, b; -/* short *elem; */ +/* short *elem; */ short num_types; printf("nr_names %d nr_types %d nr_structs %d\n", nr_names, nr_types, nr_structs); - for (a=0; a -1) printf("Writing file ... "); - if (nr_names==0 || nr_structs==0); + if (nr_names == 0 || nr_structs == 0) ; else { strcpy(str, "SDNA"); dna_write(file, str, 4); @@ -1031,27 +1031,27 @@ static int make_structDNA(char *baseDirectory, FILE *file) /* write names */ strcpy(str, "NAME"); dna_write(file, str, 4); - len= nr_names; + len = nr_names; dna_write(file, &len, 4); /* calculate size of datablock with strings */ - cp= names[nr_names-1]; - cp+= strlen(names[nr_names-1]) + 1; /* +1: null-terminator */ - len= (intptr_t) (cp - (char*) names[0]); - len= (len+3) & ~3; + cp = names[nr_names - 1]; + cp += strlen(names[nr_names - 1]) + 1; /* +1: null-terminator */ + len = (intptr_t) (cp - (char *) names[0]); + len = (len + 3) & ~3; dna_write(file, names[0], len); /* write TYPES */ strcpy(str, "TYPE"); dna_write(file, str, 4); - len= nr_types; + len = nr_types; dna_write(file, &len, 4); /* calculate datablock size */ - cp= types[nr_types-1]; - cp+= strlen(types[nr_types-1]) + 1; /* +1: null-terminator */ - len= (intptr_t) (cp - (char*) types[0]); - len= (len+3) & ~3; + cp = types[nr_types - 1]; + cp += strlen(types[nr_types - 1]) + 1; /* +1: null-terminator */ + len = (intptr_t) (cp - (char *) types[0]); + len = (len + 3) & ~3; dna_write(file, types[0], len); @@ -1059,21 +1059,21 @@ static int make_structDNA(char *baseDirectory, FILE *file) strcpy(str, "TLEN"); dna_write(file, str, 4); - len= 2*nr_types; - if (nr_types & 1) len+= 2; + len = 2 * nr_types; + if (nr_types & 1) len += 2; dna_write(file, typelens, len); /* WRITE STRUCTS */ strcpy(str, "STRC"); dna_write(file, str, 4); - len= nr_structs; + len = nr_structs; dna_write(file, &len, 4); /* calc datablock size */ - sp= structs[nr_structs-1]; - sp+= 2+ 2*( sp[1] ); - len= (intptr_t) ((char*) sp - (char*) structs[0]); - len= (len+3) & ~3; + sp = structs[nr_structs - 1]; + sp += 2 + 2 * (sp[1]); + len = (intptr_t) ((char *) sp - (char *) structs[0]); + len = (len + 3) & ~3; dna_write(file, structs[0], len); @@ -1082,8 +1082,8 @@ static int make_structDNA(char *baseDirectory, FILE *file) FILE *fp; int a; - fp= fopen("padding.c", "w"); - if (fp==NULL); + fp = fopen("padding.c", "w"); + if (fp == NULL) ; else { // add all include files defined in the global array @@ -1094,7 +1094,7 @@ static int make_structDNA(char *baseDirectory, FILE *file) fprintf(fp, "main() {\n"); sp = typelens; sp += firststruct; - for (a=firststruct; a