griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

style cleanup: whitespace, bli & makesdna

Browse Source
This commit is contained in:
Campbell Barton
2012-05-12 15:02:10 +00:00
parent 23c0d49a7c
commit 2f2b15bbb2
24 changed files with 1856 additions and 1857 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
source/blender/blenlib/intern/BLI_args.c
View File

@@ -49,7 +49,7 @@ typedef struct bArgDoc {
const char *short_arg;
const char *long_arg;
const char *documentation;
int done;
int done;
} bArgDoc;
typedef struct bAKey {
@@ -68,24 +68,24 @@ typedef struct bArgument {
struct bArgs {
ListBase docs;
GHash *items;
int argc;
int argc;
const char **argv;
int *passes;
int *passes;
};
static unsigned int case_strhash(const void *ptr)
{
const char *s= ptr;
unsigned int i= 0;
const char *s = ptr;
unsigned int i = 0;
unsigned char c;
while ( (c= tolower(*s++)) )
i= i*37 + c;
while ( (c = tolower(*s++)) )
i = i * 37 + c;
return i;
}
static unsigned int keyhash(const void *ptr)
static unsigned int keyhash(const void *ptr)
{
const bAKey *k = ptr;
return case_strhash(k->arg); // ^ BLI_ghashutil_inthash((void*)k->pass);
@@ -102,7 +102,7 @@ static int keycmp(const void *a, const void *b)
return strcmp(ka->arg, kb->arg);
}
else {
return BLI_ghashutil_intcmp((const void*)ka->pass, (const void*)kb->pass);
return BLI_ghashutil_intcmp((const void *)ka->pass, (const void *)kb->pass);
}
}
@@ -182,8 +182,8 @@ static void internalAdd(struct bArgs *ba, const char *arg, int pass, int case_st
if (a) {
printf("WARNING: conflicting argument\n");
printf("\ttrying to add '%s' on pass %i, %scase sensitive\n", arg, pass, case_str == 1? "not ": "");
printf("\tconflict with '%s' on pass %i, %scase sensitive\n\n", a->key->arg, (int)a->key->pass, a->key->case_str == 1? "not ": "");
printf("\ttrying to add '%s' on pass %i, %scase sensitive\n", arg, pass, case_str == 1 ? "not " : "");
printf("\tconflict with '%s' on pass %i, %scase sensitive\n\n", a->key->arg, (int)a->key->pass, a->key->case_str == 1 ? "not " : "");
}
a = MEM_callocN(sizeof(bArgument), "bArgument");
@@ -259,9 +259,9 @@ void BLI_argsParse(struct bArgs *ba, int pass, BA_ArgCallback default_cb, void *
{
int i = 0;
for ( i = 1; i < ba->argc; i++) { /* skip argv[0] */
for (i = 1; i < ba->argc; i++) { /* skip argv[0] */
if (ba->passes[i] == 0) {
/* -1 signal what side of the comparison it is */
/* -1 signal what side of the comparison it is */
bArgument *a = lookUp(ba, ba->argv[i], pass, -1);
BA_ArgCallback func = NULL;
void *data = NULL;

88
source/blender/blenlib/intern/BLI_dynstr.c
View File

@@ -46,9 +46,9 @@
#ifndef va_copy
# ifdef __va_copy
# define va_copy(a,b) __va_copy(a,b)
# define va_copy(a, b) __va_copy(a, b)
# else /* !__va_copy */
# define va_copy(a,b) ((a)=(b))
# define va_copy(a, b) ((a) = (b))
# endif /* __va_copy */
#endif /* va_copy */
@@ -70,65 +70,65 @@ struct DynStr {
DynStr *BLI_dynstr_new(void)
{
DynStr *ds= MEM_mallocN(sizeof(*ds), "DynStr");
ds->elems= ds->last= NULL;
ds->curlen= 0;
DynStr *ds = MEM_mallocN(sizeof(*ds), "DynStr");
ds->elems = ds->last = NULL;
ds->curlen = 0;
return ds;
}
void BLI_dynstr_append(DynStr *ds, const char *cstr)
{
DynStrElem *dse= malloc(sizeof(*dse));
int cstrlen= strlen(cstr);
DynStrElem *dse = malloc(sizeof(*dse));
int cstrlen = strlen(cstr);
dse->str= malloc(cstrlen+1);
memcpy(dse->str, cstr, cstrlen+1);
dse->next= NULL;
dse->str = malloc(cstrlen + 1);
memcpy(dse->str, cstr, cstrlen + 1);
dse->next = NULL;
if (!ds->last)
ds->last= ds->elems= dse;
ds->last = ds->elems = dse;
else
ds->last= ds->last->next= dse;
ds->last = ds->last->next = dse;
ds->curlen+= cstrlen;
ds->curlen += cstrlen;
}
void BLI_dynstr_nappend(DynStr *ds, const char *cstr, int len)
{
DynStrElem *dse= malloc(sizeof(*dse));
int cstrlen= BLI_strnlen(cstr, len);
DynStrElem *dse = malloc(sizeof(*dse));
int cstrlen = BLI_strnlen(cstr, len);
dse->str= malloc(cstrlen+1);
dse->str = malloc(cstrlen + 1);
memcpy(dse->str, cstr, cstrlen);
dse->str[cstrlen] = '\0';
dse->next= NULL;
dse->next = NULL;
if (!ds->last)
ds->last= ds->elems= dse;
ds->last = ds->elems = dse;
else
ds->last= ds->last->next= dse;
ds->last = ds->last->next = dse;
ds->curlen+= cstrlen;
ds->curlen += cstrlen;
}
void BLI_dynstr_vappendf(DynStr *ds, const char *format, va_list args)
{
char *message, fixedmessage[256];
int len= sizeof(fixedmessage);
const int maxlen= 65536;
int len = sizeof(fixedmessage);
const int maxlen = 65536;
int retval;
while (1) {
va_list args_cpy;
if (len == sizeof(fixedmessage))
message= fixedmessage;
message = fixedmessage;
else
message= MEM_callocN(sizeof(char) * len, "BLI_dynstr_appendf");
message = MEM_callocN(sizeof(char) * len, "BLI_dynstr_appendf");
/* cant reuse the same args, so work on a copy */
va_copy(args_cpy, args);
retval= vsnprintf(message, len, format, args_cpy);
retval = vsnprintf(message, len, format, args_cpy);
va_end(args_cpy);
if (retval == -1) {
@@ -136,7 +136,7 @@ void BLI_dynstr_vappendf(DynStr *ds, const char *format, va_list args)
* there is a formatting error, so we impose a maximum length */
if (message != fixedmessage)
MEM_freeN(message);
message= NULL;
message = NULL;
len *= 2;
if (len > maxlen) {
@@ -148,10 +148,10 @@ void BLI_dynstr_vappendf(DynStr *ds, const char *format, va_list args)
/* in C99 the actual length required is returned */
if (message != fixedmessage)
MEM_freeN(message);
message= NULL;
message = NULL;
/* retval doesn't include \0 terminator */
len= retval + 1;
len = retval + 1;
}
else
break;
@@ -169,8 +169,8 @@ void BLI_dynstr_appendf(DynStr *ds, const char *format, ...)
{
va_list args;
char *message, fixedmessage[256];
int len= sizeof(fixedmessage);
const int maxlen= 65536;
int len = sizeof(fixedmessage);
const int maxlen = 65536;
int retval;
/* note that it's tempting to just call BLI_dynstr_vappendf here
@@ -179,12 +179,12 @@ void BLI_dynstr_appendf(DynStr *ds, const char *format, ...)
while (1) {
if (len == sizeof(fixedmessage))
message= fixedmessage;
message = fixedmessage;
else
message= MEM_callocN(sizeof(char)*(len), "BLI_dynstr_appendf");
message = MEM_callocN(sizeof(char) * (len), "BLI_dynstr_appendf");
va_start(args, format);
retval= vsnprintf(message, len, format, args);
retval = vsnprintf(message, len, format, args);
va_end(args);
if (retval == -1) {
@@ -192,7 +192,7 @@ void BLI_dynstr_appendf(DynStr *ds, const char *format, ...)
* there is a formatting error, so we impose a maximum length */
if (message != fixedmessage)
MEM_freeN(message);
message= NULL;
message = NULL;
len *= 2;
if (len > maxlen) {
@@ -204,10 +204,10 @@ void BLI_dynstr_appendf(DynStr *ds, const char *format, ...)
/* in C99 the actual length required is returned */
if (message != fixedmessage)
MEM_freeN(message);
message= NULL;
message = NULL;
/* retval doesn't include \0 terminator */
len= retval + 1;
len = retval + 1;
}
else
break;
@@ -231,19 +231,19 @@ void BLI_dynstr_get_cstring_ex(DynStr *ds, char *rets)
char *s;
DynStrElem *dse;
for (s= rets, dse= ds->elems; dse; dse= dse->next) {
int slen= strlen(dse->str);
for (s = rets, dse = ds->elems; dse; dse = dse->next) {
int slen = strlen(dse->str);
memcpy(s, dse->str, slen);
s+= slen;
s += slen;
}
rets[ds->curlen]= '\0';
rets[ds->curlen] = '\0';
}
char *BLI_dynstr_get_cstring(DynStr *ds)
{
char *rets= MEM_mallocN(ds->curlen+1, "dynstr_cstring");
char *rets = MEM_mallocN(ds->curlen + 1, "dynstr_cstring");
BLI_dynstr_get_cstring_ex(ds, rets);
return rets;
}
@@ -252,13 +252,13 @@ void BLI_dynstr_free(DynStr *ds)
{
DynStrElem *dse;
for (dse= ds->elems; dse; ) {
DynStrElem *n= dse->next;
for (dse = ds->elems; dse; ) {
DynStrElem *n = dse->next;
free(dse->str);
free(dse);
dse= n;
dse = n;
}
MEM_freeN(ds);

10
source/blender/blenlib/intern/BLI_ghash.c
View File

@@ -78,7 +78,7 @@ int BLI_ghash_size(GHash *gh)
void BLI_ghash_insert(GHash *gh, void *key, void *val)
{
unsigned int hash = gh->hashfp(key) % gh->nbuckets;
Entry *e = (Entry*)BLI_mempool_alloc(gh->entrypool);
Entry *e = (Entry *)BLI_mempool_alloc(gh->entrypool);
e->key = key;
e->val = val;
@@ -90,11 +90,11 @@ void BLI_ghash_insert(GHash *gh, void *key, void *val)
int i, nold = gh->nbuckets;
gh->nbuckets = hashsizes[++gh->cursize];
gh->buckets = (Entry**)MEM_mallocN(gh->nbuckets * sizeof(*gh->buckets), "buckets");
gh->buckets = (Entry **)MEM_mallocN(gh->nbuckets * sizeof(*gh->buckets), "buckets");
memset(gh->buckets, 0, gh->nbuckets * sizeof(*gh->buckets));
for (i = 0; i < nold; i++) {
for (e = old[i]; e;) {
for (e = old[i]; e; ) {
Entry *n = e->next;
hash = gh->hashfp(e->key) % gh->nbuckets;
@@ -174,7 +174,7 @@ void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreef
for (i = 0; i < gh->nbuckets; i++) {
Entry *e;
for (e = gh->buckets[i]; e;) {
for (e = gh->buckets[i]; e; ) {
Entry *n = e->next;
if (keyfreefp) keyfreefp(e->key);
@@ -333,6 +333,6 @@ int BLI_ghashutil_paircmp(const void *a, const void *b)
void BLI_ghashutil_pairfree(void *ptr)
{
MEM_freeN((void*)ptr);
MEM_freeN((void *)ptr);
}

2
source/blender/blenlib/intern/BLI_heap.c
View File

@@ -184,7 +184,7 @@ void *BLI_heap_popmin(Heap *heap)
if (heap->size == 1)
heap->size--;
else {
HEAP_SWAP(heap, 0, heap->size-1);
HEAP_SWAP(heap, 0, heap->size - 1);
heap->size--;
BLI_heap_down(heap, 0);

441
source/blender/blenlib/intern/BLI_kdopbvh.c
View File

@@ -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; i<depth; i++) printf(" ");
for (i = 0; i < depth; i++) printf(" ");
printf(" - %d (%ld): ", node->index, node - tree->nodearray);
for (i=2*tree->start_axis; i<2*tree->stop_axis; i++)
for (i = 2 * tree->start_axis; i < 2 * tree->stop_axis; i++)
printf("%.3f ", node->bv[i]);
printf("\n");
for (i=0; i<tree->tree_type; i++)
for (i = 0; i < tree->tree_type; i++)
if (node->children[i])
bvhtree_print_tree(tree, node->children[i], depth+1);
bvhtree_print_tree(tree, node->children[i], depth + 1);
}
static void bvhtree_info(BVHTree *tree)
@@ -508,15 +503,14 @@ static void bvhtree_info(BVHTree *tree)
printf("BVHTree info\n");
printf("tree_type = %d, axis = %d, epsilon = %f\n", tree->tree_type, tree->axis, tree->epsilon);
printf("nodes = %d, branches = %d, leafs = %d\n", tree->totbranch + tree->totleaf, tree->totbranch, tree->totleaf);
printf("Memory per node = %ldbytes\n", sizeof(BVHNode) + sizeof(BVHNode*)*tree->tree_type + sizeof(float)*tree->axis);
printf("Memory per node = %ldbytes\n", sizeof(BVHNode) + sizeof(BVHNode *) * tree->tree_type + sizeof(float) * tree->axis);
printf("BV memory = %dbytes\n", MEM_allocN_len(tree->nodebv));
printf("Total memory = %ldbytes\n", sizeof(BVHTree)
+ MEM_allocN_len(tree->nodes)
+ MEM_allocN_len(tree->nodearray)
+ MEM_allocN_len(tree->nodechild)
+ MEM_allocN_len(tree->nodebv)
);
printf("Total memory = %ldbytes\n", sizeof(BVHTree) +
MEM_allocN_len(tree->nodes) +
MEM_allocN_len(tree->nodearray) +
MEM_allocN_len(tree->nodechild) +
MEM_allocN_len(tree->nodebv));
// bvhtree_print_tree(tree, tree->nodes[tree->totleaf], 0);
}
@@ -532,10 +526,10 @@ static void verify_tree(BVHTree *tree)
// check the pointer list
for (i = 0; i < tree->totleaf; i++)
{
if (tree->nodes[i]->parent == NULL)
if (tree->nodes[i]->parent == NULL) {
printf("Leaf has no parent: %d\n", i);
else
{
}
else {
for (j = 0; j < tree->tree_type; j++)
{
if (tree->nodes[i]->parent->children[j] == tree->nodes[i])
@@ -552,10 +546,10 @@ static void verify_tree(BVHTree *tree)
// check the leaf list
for (i = 0; i < tree->totleaf; i++)
{
if (tree->nodearray[i].parent == NULL)
if (tree->nodearray[i].parent == NULL) {
printf("Leaf has no parent: %d\n", i);
else
{
}
else {
for (j = 0; j < tree->tree_type; j++)
{
if (tree->nodearray[i].parent->children[j] == &tree->nodearray[i])
@@ -575,15 +569,14 @@ static void verify_tree(BVHTree *tree)
//Helper data and structures to build a min-leaf generalized implicit tree
//This code can be easily reduced (basicly this is only method to calculate pow(k, n) in O(1).. and stuff like that)
typedef struct BVHBuildHelper
{
int tree_type; /* */
int totleafs; /* */
typedef struct BVHBuildHelper {
int tree_type; /* */
int totleafs; /* */
int leafs_per_child[32]; /* Min number of leafs that are archievable from a node at depth N */
int branches_on_level[32]; /* Number of nodes at depth N (tree_type^N) */
int leafs_per_child[32]; /* Min number of leafs that are archievable from a node at depth N */
int branches_on_level[32]; /* Number of nodes at depth N (tree_type^N) */
int remain_leafs; /* Number of leafs that are placed on the level that is not 100% filled */
int remain_leafs; /* Number of leafs that are placed on the level that is not 100% filled */
} BVHBuildHelper;
@@ -594,7 +587,7 @@ static void build_implicit_tree_helper(BVHTree *tree, BVHBuildHelper *data)
int nnodes;
data->totleafs = tree->totleaf;
data->tree_type= tree->tree_type;
data->tree_type = tree->tree_type;
//Calculate the smallest tree_type^n such that tree_type^n >= num_leafs
for (data->leafs_per_child[0] = 1;
@@ -608,8 +601,8 @@ static void build_implicit_tree_helper(BVHTree *tree, BVHBuildHelper *data)
//We could stop the loop first (but I am lazy to find out when)
for (depth = 1; depth < 32; depth++) {
data->branches_on_level[depth] = data->branches_on_level[depth-1] * data->tree_type;
data->leafs_per_child [depth] = data->leafs_per_child [depth-1] / data->tree_type;
data->branches_on_level[depth] = data->branches_on_level[depth - 1] * data->tree_type;
data->leafs_per_child[depth] = data->leafs_per_child[depth - 1] / data->tree_type;
}
remain = data->totleafs - data->leafs_per_child[1];
@@ -620,11 +613,11 @@ static void build_implicit_tree_helper(BVHTree *tree, BVHBuildHelper *data)
// return the min index of all the leafs archivable with the given branch
static int implicit_leafs_index(BVHBuildHelper *data, int depth, int child_index)
{
int min_leaf_index = child_index * data->leafs_per_child[depth-1];
int min_leaf_index = child_index * data->leafs_per_child[depth - 1];
if (min_leaf_index <= data->remain_leafs)
return min_leaf_index;
else if (data->leafs_per_child[depth])
return data->totleafs - (data->branches_on_level[depth-1] - child_index) * data->leafs_per_child[depth];
return data->totleafs - (data->branches_on_level[depth - 1] - child_index) * data->leafs_per_child[depth];
else
return data->remain_leafs;
}
@@ -660,7 +653,7 @@ static int implicit_leafs_index(BVHBuildHelper *data, int depth, int child_index
// This functions returns the number of branches needed to have the requested number of leafs.
static int implicit_needed_branches(int tree_type, int leafs)
{
return MAX2(1, (leafs + tree_type - 3) / (tree_type-1) );
return MAX2(1, (leafs + tree_type - 3) / (tree_type - 1) );
}
/*
@@ -678,11 +671,11 @@ static int implicit_needed_branches(int tree_type, int leafs)
static void split_leafs(BVHNode **leafs_array, int *nth, int partitions, int split_axis)
{
int i;
for (i=0; i < partitions-1; i++) {
for (i = 0; i < partitions - 1; i++) {
if (nth[i] >= nth[partitions])
break;
partition_nth_element(leafs_array, nth[i], nth[partitions], nth[i+1], split_axis);
partition_nth_element(leafs_array, nth[i], nth[partitions], nth[i + 1], split_axis);
}
}
@@ -708,19 +701,19 @@ static void non_recursive_bvh_div_nodes(BVHTree *tree, BVHNode *branches_array,
const int tree_type = tree->tree_type;
const int tree_offset = 2 - tree->tree_type; //this value is 0 (on binary trees) and negative on the others
const int num_branches= implicit_needed_branches(tree_type, num_leafs);
const int num_branches = implicit_needed_branches(tree_type, num_leafs);
BVHBuildHelper data;
int depth;
// set parent from root node to NULL
BVHNode *tmp = branches_array+0;
BVHNode *tmp = branches_array + 0;
tmp->parent = NULL;
//Most of bvhtree code relies on 1-leaf trees having at least one branch
//We handle that special case here
if (num_leafs == 1) {
BVHNode *root = branches_array+0;
BVHNode *root = branches_array + 0;
refit_kdop_hull(tree, root, 0, num_leafs);
root->main_axis = get_largest_axis(root->bv) / 2;
root->totnode = 1;
@@ -729,27 +722,27 @@ static void non_recursive_bvh_div_nodes(BVHTree *tree, BVHNode *branches_array,
return;
}
branches_array--; //Implicit trees use 1-based indexs
branches_array--; //Implicit trees use 1-based indexs
build_implicit_tree_helper(tree, &data);
//Loop tree levels (log N) loops
for (i=1, depth = 1; i <= num_branches; i = i*tree_type + tree_offset, depth++) {
const int first_of_next_level = i*tree_type + tree_offset;
const int end_j = MIN2(first_of_next_level, num_branches + 1); //index of last branch on this level
for (i = 1, depth = 1; i <= num_branches; i = i * tree_type + tree_offset, depth++) {
const int first_of_next_level = i * tree_type + tree_offset;
const int end_j = MIN2(first_of_next_level, num_branches + 1); //index of last branch on this level
int j;
//Loop all branches on this level
#pragma omp parallel for private(j) schedule(static)
for (j = i; j < end_j; j++) {
int k;
const int parent_level_index= j-i;
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;

246
source/blender/blenlib/intern/BLI_kdtree.c
View File

@@ -38,7 +38,7 @@
#include "BLI_kdtree.h"
#ifndef SWAP
#define SWAP(type, a, b) { type sw_ap; sw_ap=(a); (a)=(b); (b)=sw_ap; }
# define SWAP(type, a, b) { type sw_ap; sw_ap = (a); (a) = (b); (b) = sw_ap; }
#endif
typedef struct KDTreeNode {
@@ -58,9 +58,9 @@ KDTree *BLI_kdtree_new(int maxsize)
{
KDTree *tree;
tree= MEM_callocN(sizeof(KDTree), "KDTree");
tree->nodes= MEM_callocN(sizeof(KDTreeNode)*maxsize, "KDTreeNode");
tree->totnode= 0;
tree = MEM_callocN(sizeof(KDTree), "KDTree");
tree->nodes = MEM_callocN(sizeof(KDTreeNode) * maxsize, "KDTreeNode");
tree->totnode = 0;
return tree;
}
@@ -75,9 +75,9 @@ void BLI_kdtree_free(KDTree *tree)
void BLI_kdtree_insert(KDTree *tree, int index, float *co, float *nor)
{
KDTreeNode *node= &tree->nodes[tree->totnode++];
KDTreeNode *node = &tree->nodes[tree->totnode++];
node->index= index;
node->index = index;
copy_v3_v3(node->co, co);
if (nor) copy_v3_v3(node->nor, nor);
}
@@ -94,18 +94,18 @@ static KDTreeNode *kdtree_balance(KDTreeNode *nodes, int totnode, int axis)
return nodes;
/* quicksort style sorting around median */
left= 0;
right= totnode-1;
median= totnode/2;
left = 0;
right = totnode - 1;
median = totnode / 2;
while (right > left) {
co= nodes[right].co[axis];
i= left-1;
j= right;
co = nodes[right].co[axis];
i = left - 1;
j = right;
while (1) {
while (nodes[++i].co[axis] < co);
while (nodes[--j].co[axis] > co && j>left);
while (nodes[++i].co[axis] < co) ;
while (nodes[--j].co[axis] > co && j > left) ;
if (i >= j) break;
SWAP(KDTreeNode, nodes[i], nodes[j]);
@@ -113,32 +113,32 @@ static KDTreeNode *kdtree_balance(KDTreeNode *nodes, int totnode, int axis)
SWAP(KDTreeNode, nodes[i], nodes[right]);
if (i >= median)
right= i-1;
right = i - 1;
if (i <= median)
left= i+1;
left = i + 1;
}
/* set node and sort subnodes */
node= &nodes[median];
node->d= axis;
node->left= kdtree_balance(nodes, median, (axis+1)%3);
node->right= kdtree_balance(nodes+median+1, (totnode-(median+1)), (axis+1)%3);
node = &nodes[median];
node->d = axis;
node->left = kdtree_balance(nodes, median, (axis + 1) % 3);
node->right = kdtree_balance(nodes + median + 1, (totnode - (median + 1)), (axis + 1) % 3);
return node;
}
void BLI_kdtree_balance(KDTree *tree)
{
tree->root= kdtree_balance(tree->nodes, tree->totnode, 0);
tree->root = kdtree_balance(tree->nodes, tree->totnode, 0);
}
static float squared_distance(const float v2[3], const float v1[3], float *UNUSED(n1), float *n2)
{
float d[3], dist;
d[0]= v2[0]-v1[0];
d[1]= v2[1]-v1[1];
d[2]= v2[2]-v1[2];
d[0] = v2[0] - v1[0];
d[1] = v2[1] - v1[1];
d[2] = v2[2] - v1[2];
dist = dot_v3v3(d, d);
@@ -152,84 +152,84 @@ static float squared_distance(const float v2[3], const float v1[3], float *UNUSE
return dist;
}
int BLI_kdtree_find_nearest(KDTree *tree, float *co, float *nor, KDTreeNearest *nearest)
int BLI_kdtree_find_nearest(KDTree *tree, float *co, float *nor, KDTreeNearest *nearest)
{
KDTreeNode *root, *node, *min_node;
KDTreeNode **stack, *defaultstack[100];
float min_dist, cur_dist;
int totstack, cur=0;
int totstack, cur = 0;
if (!tree->root)
return -1;
stack= defaultstack;
totstack= 100;
stack = defaultstack;
totstack = 100;
root= tree->root;
min_node= root;
min_dist= squared_distance(root->co, co, root->nor, nor);
root = tree->root;
min_node = root;
min_dist = squared_distance(root->co, co, root->nor, nor);
if (co[root->d] < root->co[root->d]) {
if (root->right)
stack[cur++]=root->right;
stack[cur++] = root->right;
if (root->left)
stack[cur++]=root->left;
stack[cur++] = root->left;
}
else {
if (root->left)
stack[cur++]=root->left;
stack[cur++] = root->left;
if (root->right)
stack[cur++]=root->right;
stack[cur++] = root->right;
}
while (cur--) {
node=stack[cur];
node = stack[cur];
cur_dist = node->co[node->d] - co[node->d];
if (cur_dist<0.0f) {
cur_dist= -cur_dist*cur_dist;
if (cur_dist < 0.0f) {
cur_dist = -cur_dist * cur_dist;
if (-cur_dist<min_dist) {
cur_dist=squared_distance(node->co, co, node->nor, nor);
if (cur_dist<min_dist) {
min_dist=cur_dist;
min_node=node;
if (-cur_dist < min_dist) {
cur_dist = squared_distance(node->co, co, node->nor, nor);
if (cur_dist < min_dist) {
min_dist = cur_dist;
min_node = node;
}
if (node->left)
stack[cur++]=node->left;
stack[cur++] = node->left;
}
if (node->right)
stack[cur++]=node->right;
stack[cur++] = node->right;
}
else {
cur_dist= cur_dist*cur_dist;
cur_dist = cur_dist * cur_dist;
if (cur_dist<min_dist) {
cur_dist=squared_distance(node->co, co, node->nor, nor);
if (cur_dist<min_dist) {
min_dist=cur_dist;
min_node=node;
if (cur_dist < min_dist) {
cur_dist = squared_distance(node->co, co, node->nor, nor);
if (cur_dist < min_dist) {
min_dist = cur_dist;
min_node = node;
}
if (node->right)
stack[cur++]=node->right;
stack[cur++] = node->right;
}
if (node->left)
stack[cur++]=node->left;
stack[cur++] = node->left;
}
if (cur+3 > totstack) {
KDTreeNode **temp=MEM_callocN((totstack+100)*sizeof(KDTreeNode*), "psys_treestack");
memcpy(temp, stack, totstack*sizeof(KDTreeNode*));
if (cur + 3 > totstack) {
KDTreeNode **temp = MEM_callocN((totstack + 100) * sizeof(KDTreeNode *), "psys_treestack");
memcpy(temp, stack, totstack * sizeof(KDTreeNode *));
if (stack != defaultstack)
MEM_freeN(stack);
stack=temp;
totstack+=100;
stack = temp;
totstack += 100;
}
}
if (nearest) {
nearest->index= min_node->index;
nearest->dist= sqrt(min_dist);
nearest->index = min_node->index;
nearest->dist = sqrt(min_dist);
copy_v3_v3(nearest->co, min_node->co);
}
@@ -243,98 +243,98 @@ static void add_nearest(KDTreeNearest *ptn, int *found, int n, int index, float
{
int i;
if (*found<n) (*found)++;
if (*found < n) (*found)++;
for (i=*found-1; i>0; i--) {
if (dist >= ptn[i-1].dist)
for (i = *found - 1; i > 0; i--) {
if (dist >= ptn[i - 1].dist)
break;
else
ptn[i]= ptn[i-1];
ptn[i] = ptn[i - 1];
}
ptn[i].index= index;
ptn[i].dist= dist;
ptn[i].index = index;
ptn[i].dist = dist;
copy_v3_v3(ptn[i].co, co);
}
/* finds the nearest n entries in tree to specified coordinates */
int BLI_kdtree_find_n_nearest(KDTree *tree, int n, float *co, float *nor, KDTreeNearest *nearest)
int BLI_kdtree_find_n_nearest(KDTree *tree, int n, float *co, float *nor, KDTreeNearest *nearest)
{
KDTreeNode *root, *node= NULL;
KDTreeNode *root, *node = NULL;
KDTreeNode **stack, *defaultstack[100];
float cur_dist;
int i, totstack, cur=0, found=0;
int i, totstack, cur = 0, found = 0;
if (!tree->root)
return 0;
stack= defaultstack;
totstack= 100;
stack = defaultstack;
totstack = 100;
root= tree->root;
root = tree->root;
cur_dist= squared_distance(root->co, co, root->nor, nor);
cur_dist = squared_distance(root->co, co, root->nor, nor);
add_nearest(nearest, &found, n, root->index, cur_dist, root->co);
if (co[root->d] < root->co[root->d]) {
if (root->right)
stack[cur++]=root->right;
stack[cur++] = root->right;
if (root->left)
stack[cur++]=root->left;
stack[cur++] = root->left;
}
else {
if (root->left)
stack[cur++]=root->left;
stack[cur++] = root->left;
if (root->right)
stack[cur++]=root->right;
stack[cur++] = root->right;
}
while (cur--) {
node=stack[cur];
node = stack[cur];
cur_dist = node->co[node->d] - co[node->d];
if (cur_dist<0.0f) {
cur_dist= -cur_dist*cur_dist;
if (cur_dist < 0.0f) {
cur_dist = -cur_dist * cur_dist;
if (found<n || -cur_dist<nearest[found-1].dist) {
cur_dist=squared_distance(node->co, co, node->nor, nor);
if (found < n || -cur_dist < nearest[found - 1].dist) {
cur_dist = squared_distance(node->co, co, node->nor, nor);
if (found<n || cur_dist<nearest[found-1].dist)
if (found < n || cur_dist < nearest[found - 1].dist)
add_nearest(nearest, &found, n, node->index, cur_dist, node->co);
if (node->left)
stack[cur++]=node->left;
stack[cur++] = node->left;
}
if (node->right)
stack[cur++]=node->right;
stack[cur++] = node->right;
}
else {
cur_dist= cur_dist*cur_dist;
cur_dist = cur_dist * cur_dist;
if (found<n || cur_dist<nearest[found-1].dist) {
cur_dist=squared_distance(node->co, co, node->nor, nor);
if (found<n || cur_dist<nearest[found-1].dist)
if (found < n || cur_dist < nearest[found - 1].dist) {
cur_dist = squared_distance(node->co, co, node->nor, nor);
if (found < n || cur_dist < nearest[found - 1].dist)
add_nearest(nearest, &found, n, node->index, cur_dist, node->co);
if (node->right)
stack[cur++]=node->right;
stack[cur++] = node->right;
}
if (node->left)
stack[cur++]=node->left;
stack[cur++] = node->left;
}
if (cur+3 > totstack) {
KDTreeNode **temp=MEM_callocN((totstack+100)*sizeof(KDTreeNode*), "psys_treestack");
memcpy(temp, stack, totstack * sizeof(KDTreeNode*));
if (cur + 3 > totstack) {
KDTreeNode **temp = MEM_callocN((totstack + 100) * sizeof(KDTreeNode *), "psys_treestack");
memcpy(temp, stack, totstack * sizeof(KDTreeNode *));
if (stack != defaultstack)
MEM_freeN(stack);
stack=temp;
totstack+=100;
stack = temp;
totstack += 100;
}
}
for (i=0; i<found; i++)
nearest[i].dist= sqrt(nearest[i].dist);
for (i = 0; i < found; i++)
nearest[i].dist = sqrt(nearest[i].dist);
if (stack != defaultstack)
MEM_freeN(stack);
@@ -342,7 +342,7 @@ int BLI_kdtree_find_n_nearest(KDTree *tree, int n, float *co, float *nor, KDTree
return found;
}
static int range_compare(const void * a, const void * b)
static int range_compare(const void *a, const void *b)
{
const KDTreeNearest *kda = a;
const KDTreeNearest *kdb = b;
@@ -358,13 +358,13 @@ static void add_in_range(KDTreeNearest **ptn, int found, int *totfoundstack, int
{
KDTreeNearest *to;
if (found+1 > *totfoundstack) {
KDTreeNearest *temp=MEM_callocN((*totfoundstack+50)*sizeof(KDTreeNode), "psys_treefoundstack");
if (found + 1 > *totfoundstack) {
KDTreeNearest *temp = MEM_callocN((*totfoundstack + 50) * sizeof(KDTreeNode), "psys_treefoundstack");
memcpy(temp, *ptn, *totfoundstack * sizeof(KDTreeNearest));
if (*ptn)
MEM_freeN(*ptn);
*ptn = temp;
*totfoundstack+=50;
*totfoundstack += 50;
}
to = (*ptn) + found;
@@ -375,27 +375,27 @@ static void add_in_range(KDTreeNearest **ptn, int found, int *totfoundstack, int
}
int BLI_kdtree_range_search(KDTree *tree, float range, float *co, float *nor, KDTreeNearest **nearest)
{
KDTreeNode *root, *node= NULL;
KDTreeNode *root, *node = NULL;
KDTreeNode **stack, *defaultstack[100];
KDTreeNearest *foundstack=NULL;
float range2 = range*range, dist2;
int totstack, cur=0, found=0, totfoundstack=0;
KDTreeNearest *foundstack = NULL;
float range2 = range * range, dist2;
int totstack, cur = 0, found = 0, totfoundstack = 0;
if (!tree || !tree->root)
return 0;
stack= defaultstack;
totstack= 100;
stack = defaultstack;
totstack = 100;
root= tree->root;
root = tree->root;
if (co[root->d] + range < root->co[root->d]) {
if (root->left)
stack[cur++]=root->left;
stack[cur++] = root->left;
}
else if (co[root->d] - range > root->co[root->d]) {
if (root->right)
stack[cur++]=root->right;
stack[cur++] = root->right;
}
else {
dist2 = squared_distance(root->co, co, root->nor, nor);
@@ -403,21 +403,21 @@ int BLI_kdtree_range_search(KDTree *tree, float range, float *co, float *nor, KD
add_in_range(&foundstack, found++, &totfoundstack, root->index, dist2, root->co);
if (root->left)
stack[cur++]=root->left;
stack[cur++] = root->left;
if (root->right)
stack[cur++]=root->right;
stack[cur++] = root->right;
}
while (cur--) {
node=stack[cur];
node = stack[cur];
if (co[node->d] + range < node->co[node->d]) {
if (node->left)
stack[cur++]=node->left;
stack[cur++] = node->left;
}
else if (co[node->d] - range > node->co[node->d]) {
if (node->right)
stack[cur++]=node->right;
stack[cur++] = node->right;
}
else {
dist2 = squared_distance(node->co, co, node->nor, nor);
@@ -425,18 +425,18 @@ int BLI_kdtree_range_search(KDTree *tree, float range, float *co, float *nor, KD
add_in_range(&foundstack, found++, &totfoundstack, node->index, dist2, node->co);
if (node->left)
stack[cur++]=node->left;
stack[cur++] = node->left;
if (node->right)
stack[cur++]=node->right;
stack[cur++] = node->right;
}
if (cur+3 > totstack) {
KDTreeNode **temp=MEM_callocN((totstack+100)*sizeof(KDTreeNode*), "psys_treestack");
memcpy(temp, stack, totstack*sizeof(KDTreeNode*));
if (cur + 3 > totstack) {
KDTreeNode **temp = MEM_callocN((totstack + 100) * sizeof(KDTreeNode *), "psys_treestack");
memcpy(temp, stack, totstack * sizeof(KDTreeNode *));
if (stack != defaultstack)
MEM_freeN(stack);
stack=temp;
totstack+=100;
stack = temp;
totstack += 100;
}
}

46
source/blender/blenlib/intern/BLI_linklist.c
View File

@@ -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);
}

8
source/blender/blenlib/intern/BLI_memarena.c
View File

@@ -74,12 +74,12 @@ void BLI_memarena_use_align(struct MemArena *ma, int align)
void BLI_memarena_free(MemArena *ma)
{
BLI_linklist_free(ma->bufs, (void(*)(void *))MEM_freeN);
BLI_linklist_free(ma->bufs, (void (*)(void *))MEM_freeN);
MEM_freeN(ma);
}
/* amt must be power of two */
#define PADUP(num, amt) ((num + (amt - 1)) &~ (amt-1))
#define PADUP(num, amt) ((num + (amt - 1)) & ~(amt - 1))
void *BLI_memarena_alloc(MemArena *ma, int size)
{
@@ -93,7 +93,7 @@ void *BLI_memarena_alloc(MemArena *ma, int size)
unsigned char *tmp;
if (size > ma->bufsize - (ma->align - 1)) {
ma->cursize = PADUP(size+1, ma->align);
ma->cursize = PADUP(size + 1, ma->align);
}
else
ma->cursize = ma->bufsize;
@@ -106,7 +106,7 @@ void *BLI_memarena_alloc(MemArena *ma, int size)
BLI_linklist_prepend(&ma->bufs, ma->curbuf);
/* align alloc'ed memory (needed if align > 8) */
tmp = (unsigned char*)PADUP( (intptr_t) ma->curbuf, ma->align);
tmp = (unsigned char *)PADUP( (intptr_t) ma->curbuf, ma->align);
ma->cursize -= (tmp - ma->curbuf);
ma->curbuf = tmp;
}

188
source/blender/blenlib/intern/DLRB_tree.c
View File

@@ -37,7 +37,7 @@
/* Tree API */
/* Create a new tree, and initialize as necessary */
DLRBT_Tree *BLI_dlrbTree_new (void)
DLRBT_Tree *BLI_dlrbTree_new(void)
{
/* just allocate for now */
return MEM_callocN(sizeof(DLRBT_Tree), "DLRBT_Tree");
@@ -49,11 +49,11 @@ void BLI_dlrbTree_init(DLRBT_Tree *tree)
if (tree == NULL)
return;
tree->first= tree->last= tree->root= NULL;
tree->first = tree->last = tree->root = NULL;
}
/* Helper for traversing tree and freeing sub-nodes */
static void recursive_tree_free_nodes (DLRBT_Node *node)
static void recursive_tree_free_nodes(DLRBT_Node *node)
{
/* sanity check */
if (node == NULL)
@@ -86,13 +86,13 @@ void BLI_dlrbTree_free(DLRBT_Tree *tree)
}
/* clear pointers */
tree->first= tree->last= tree->root= NULL;
tree->first = tree->last = tree->root = NULL;
}
/* ------- */
/* Helper function - used for traversing down the tree from the root to add nodes in order */
static void linkedlist_sync_add_node (DLRBT_Tree *tree, DLRBT_Node *node)
static void linkedlist_sync_add_node(DLRBT_Tree *tree, DLRBT_Node *node)
{
/* sanity checks */
if ((tree == NULL) || (node == NULL))
@@ -105,7 +105,7 @@ static void linkedlist_sync_add_node (DLRBT_Tree *tree, DLRBT_Node *node)
* - must remove detach from other links first
* (for now, only clear own pointers)
*/
node->prev= node->next= NULL;
node->prev = node->next = NULL;
BLI_addtail((ListBase *)tree, (Link *)node);
/* finally, add right node (and its subtree) */
@@ -120,7 +120,7 @@ void BLI_dlrbTree_linkedlist_sync(DLRBT_Tree *tree)
return;
/* clear list-base pointers so that the new list can be added properly */
tree->first= tree->last= NULL;
tree->first = tree->last = NULL;
/* start adding items from the root */
linkedlist_sync_add_node(tree, tree->root);
@@ -130,10 +130,10 @@ void BLI_dlrbTree_linkedlist_sync(DLRBT_Tree *tree)
/* Tree Search Utilities */
/* Find the node which matches or is the closest to the requested node */
DLRBT_Node *BLI_dlrbTree_search (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
DLRBT_Node *BLI_dlrbTree_search(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
{
DLRBT_Node *node = (tree) ? tree->root : NULL;
short found= 0;
short found = 0;
/* check that there is a comparator to use */
// TODO: if no comparator is supplied, try using the one supplied with the tree...
@@ -146,22 +146,22 @@ DLRBT_Node *BLI_dlrbTree_search (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, v
* NOTE: it is assumed that the values will be unit values only
*/
switch (cmp_cb(node, search_data)) {
case -1: /* data less than node */
case -1: /* data less than node */
if (node->left)
node= node->left;
node = node->left;
else
found= 1;
found = 1;
break;
case 1: /* data greater than node */
case 1: /* data greater than node */
if (node->right)
node= node->right;
node = node->right;
else
found= 1;
found = 1;
break;
default: /* data equals node */
found= 1;
default: /* data equals node */
found = 1;
break;
}
}
@@ -171,10 +171,10 @@ DLRBT_Node *BLI_dlrbTree_search (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, v
}
/* Find the node which exactly matches the required data */
DLRBT_Node *BLI_dlrbTree_search_exact (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
DLRBT_Node *BLI_dlrbTree_search_exact(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
{
DLRBT_Node *node = (tree) ? tree->root : NULL;
short found= 0;
short found = 0;
/* check that there is a comparator to use */
// TODO: if no comparator is supplied, try using the one supplied with the tree...
@@ -182,27 +182,27 @@ DLRBT_Node *BLI_dlrbTree_search_exact (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp
return NULL;
/* iteratively perform this search */
while (node && found==0) {
while (node && found == 0) {
/* check if traverse further or not
* NOTE: it is assumed that the values will be unit values only
*/
switch (cmp_cb(node, search_data)) {
case -1: /* data less than node */
case -1: /* data less than node */
if (node->left)
node= node->left;
node = node->left;
else
found= -1;
found = -1;
break;
case 1: /* data greater than node */
case 1: /* data greater than node */
if (node->right)
node= node->right;
node = node->right;
else
found= -1;
found = -1;
break;
default: /* data equals node */
found= 1;
default: /* data equals node */
found = 1;
break;
}
}
@@ -212,7 +212,7 @@ DLRBT_Node *BLI_dlrbTree_search_exact (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp
}
/* Find the node which occurs immediately before the best matching node */
DLRBT_Node *BLI_dlrbTree_search_prev (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
DLRBT_Node *BLI_dlrbTree_search_prev(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
{
DLRBT_Node *node;
@@ -222,7 +222,7 @@ DLRBT_Node *BLI_dlrbTree_search_prev (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_
return NULL;
/* get the node which best matches this description */
node= BLI_dlrbTree_search(tree, cmp_cb, search_data);
node = BLI_dlrbTree_search(tree, cmp_cb, search_data);
if (node) {
/* if the item we're searching for is greater than the node found, we've found the match */
@@ -239,7 +239,7 @@ DLRBT_Node *BLI_dlrbTree_search_prev (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_
}
/* Find the node which occurs immediately after the best matching node */
DLRBT_Node *BLI_dlrbTree_search_next (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
DLRBT_Node *BLI_dlrbTree_search_next(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *search_data)
{
DLRBT_Node *node;
@@ -249,7 +249,7 @@ DLRBT_Node *BLI_dlrbTree_search_next (DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_
return NULL;
/* get the node which best matches this description */
node= BLI_dlrbTree_search(tree, cmp_cb, search_data);
node = BLI_dlrbTree_search(tree, cmp_cb, search_data);
if (node) {
/* if the item we're searching for is less than the node found, we've found the match */
@@ -277,7 +277,7 @@ short BLI_dlrbTree_contains(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb, void *
/* Tree Relationships Utilities */
/* get the 'grandparent' - the parent of the parent - of the given node */
static DLRBT_Node *get_grandparent (DLRBT_Node *node)
static DLRBT_Node *get_grandparent(DLRBT_Node *node)
{
if (node && node->parent)
return node->parent->parent;
@@ -300,7 +300,7 @@ static DLRBT_Node *get_sibling(DLRBT_Node *node)
}
/* get the 'uncle' - the sibling of the parent - of the given node */
static DLRBT_Node *get_uncle (DLRBT_Node *node)
static DLRBT_Node *get_uncle(DLRBT_Node *node)
{
if (node)
/* return the child of the grandparent which isn't the node's parent */
@@ -314,71 +314,71 @@ static DLRBT_Node *get_uncle (DLRBT_Node *node)
/* Tree Rotation Utilities */
/* make right child of 'root' the new root */
static void rotate_left (DLRBT_Tree *tree, DLRBT_Node *root)
static void rotate_left(DLRBT_Tree *tree, DLRBT_Node *root)
{
DLRBT_Node **root_slot, *pivot;
/* pivot is simply the root's right child, to become the root's parent */
pivot= root->right;
pivot = root->right;
if (pivot == NULL)
return;
if (root->parent) {
if (root == root->parent->left)
root_slot= &root->parent->left;
root_slot = &root->parent->left;
else
root_slot= &root->parent->right;
root_slot = &root->parent->right;
}
else
root_slot= ((DLRBT_Node**)&tree->root);//&((DLRBT_Node*)tree->root);
root_slot = ((DLRBT_Node **)&tree->root); //&((DLRBT_Node*)tree->root);
/* - pivot's left child becomes root's right child
* - root now becomes pivot's left child
*/
root->right= pivot->left;
if (pivot->left) pivot->left->parent= root;
root->right = pivot->left;
if (pivot->left) pivot->left->parent = root;
pivot->left= root;
pivot->parent= root->parent;
root->parent= pivot;
pivot->left = root;
pivot->parent = root->parent;
root->parent = pivot;
/* make the pivot the new root */
if (root_slot)
*root_slot= pivot;
*root_slot = pivot;
}
/* make the left child of the 'root' the new root */
static void rotate_right (DLRBT_Tree *tree, DLRBT_Node *root)
static void rotate_right(DLRBT_Tree *tree, DLRBT_Node *root)
{
DLRBT_Node **root_slot, *pivot;
/* pivot is simply the root's left child, to become the root's parent */
pivot= root->left;
pivot = root->left;
if (pivot == NULL)
return;
if (root->parent) {
if (root == root->parent->left)
root_slot= &root->parent->left;
root_slot = &root->parent->left;
else
root_slot= &root->parent->right;
root_slot = &root->parent->right;
}
else
root_slot= ((DLRBT_Node**)&tree->root);//&((DLRBT_Node*)tree->root);
root_slot = ((DLRBT_Node **)&tree->root); //&((DLRBT_Node*)tree->root);
/* - pivot's right child becomes root's left child
* - root now becomes pivot's right child
*/
root->left= pivot->right;
if (pivot->right) pivot->right->parent= root;
root->left = pivot->right;
if (pivot->right) pivot->right->parent = root;
pivot->right= root;
pivot->parent= root->parent;
root->parent= pivot;
pivot->right = root;
pivot->parent = root->parent;
root->parent = pivot;
/* make the pivot the new root */
if (root_slot)
*root_slot= pivot;
*root_slot = pivot;
}
/* *********************************************** */
@@ -392,41 +392,41 @@ static void insert_check_3(DLRBT_Tree *tree, DLRBT_Node *node);
/* ----- */
/* W. 1) Root must be black (so that the 2nd-generation can have a black parent) */
static void insert_check_1 (DLRBT_Tree *tree, DLRBT_Node *node)
static void insert_check_1(DLRBT_Tree *tree, DLRBT_Node *node)
{
if (node) {
/* if this is the root, just ensure that it is black */
if (node->parent == NULL)
node->tree_col= DLRBT_BLACK;
node->tree_col = DLRBT_BLACK;
else
insert_check_2(tree, node);
}
}
/* W. 2+3) Parent of node must be black, otherwise recolor and flush */
static void insert_check_2 (DLRBT_Tree *tree, DLRBT_Node *node)
static void insert_check_2(DLRBT_Tree *tree, DLRBT_Node *node)
{
/* if the parent is not black, we need to change that... */
if (node && node->parent && node->parent->tree_col) {
DLRBT_Node *unc= get_uncle(node);
DLRBT_Node *unc = get_uncle(node);
/* if uncle and parent are both red, need to change them to black and make
* the parent black in order to satisfy the criteria of each node having the
* same number of black nodes to its leaves
*/
if (unc && unc->tree_col) {
DLRBT_Node *gp= get_grandparent(node);
DLRBT_Node *gp = get_grandparent(node);
/* make the n-1 generation nodes black */
node->parent->tree_col= unc->tree_col= DLRBT_BLACK;
node->parent->tree_col = unc->tree_col = DLRBT_BLACK;
/* - make the grandparent red, so that we maintain alternating red/black property
* (it must exist, so no need to check for NULL here),
* - as the grandparent may now cause inconsistencies with the rest of the tree,
* we must flush up the tree and perform checks/rebalancing/repainting, using the
* grandparent as the node of interest
* grandparent as the node of interest
*/
gp->tree_col= DLRBT_RED;
gp->tree_col = DLRBT_RED;
insert_check_1(tree, gp);
}
else {
@@ -439,9 +439,9 @@ static void insert_check_2 (DLRBT_Tree *tree, DLRBT_Node *node)
}
/* W. 4+5) Perform rotation on sub-tree containing the 'new' node, then do any */
static void insert_check_3 (DLRBT_Tree *tree, DLRBT_Node *node)
static void insert_check_3(DLRBT_Tree *tree, DLRBT_Node *node)
{
DLRBT_Node *gp= get_grandparent(node);
DLRBT_Node *gp = get_grandparent(node);
/* check that grandparent and node->parent exist (jut in case... really shouldn't happen on a good tree) */
if (node && node->parent && gp) {
@@ -451,11 +451,11 @@ static void insert_check_3 (DLRBT_Tree *tree, DLRBT_Node *node)
*/
if ((node == node->parent->right) && (node->parent == gp->left)) {
rotate_left(tree, node);
node= node->left;
node = node->left;
}
else if ((node == node->parent->left) && (node->parent == gp->right)) {
rotate_right(tree, node);
node= node->right;
node = node->right;
}
/* fix old parent's color-tagging, and perform rotation on the old parent in the
@@ -464,11 +464,11 @@ static void insert_check_3 (DLRBT_Tree *tree, DLRBT_Node *node)
*/
if (node) {
/* get 'new' grandparent (i.e. grandparent for old-parent (node)) */
gp= get_grandparent(node);
gp = get_grandparent(node);
/* modify the coloring of the grandparent and parent so that they still satisfy the constraints */
node->parent->tree_col= DLRBT_BLACK;
gp->tree_col= DLRBT_RED;
node->parent->tree_col = DLRBT_BLACK;
gp->tree_col = DLRBT_RED;
/* if there are several nodes that all form a left chain, do a right rotation to correct this
* (or a rotation in the opposite direction if they all form a right chain)
@@ -493,7 +493,7 @@ void BLI_dlrbTree_insert(DLRBT_Tree *tree, DLRBT_Node *node)
return;
/* firstly, the node we just added should be red by default */
node->tree_col= DLRBT_RED;
node->tree_col = DLRBT_RED;
/* start from case 1, an trek through the tail-recursive insertion checks */
insert_check_1(tree, node);
@@ -504,9 +504,9 @@ void BLI_dlrbTree_insert(DLRBT_Tree *tree, DLRBT_Node *node)
/* Add the given data to the tree, and return the node added */
// NOTE: for duplicates, the update_cb is called (if available), and the existing node is returned
DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
DLRBT_NAlloc_FP new_cb, DLRBT_NUpdate_FP update_cb, void *data)
DLRBT_NAlloc_FP new_cb, DLRBT_NUpdate_FP update_cb, void *data)
{
DLRBT_Node *parNode, *node=NULL;
DLRBT_Node *parNode, *node = NULL;
short new_node = 0;
/* sanity checks */
@@ -522,7 +522,7 @@ DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
// TODO: if no updater is supplied, try using the one supplied with the tree...
/* try to find the nearest node to this one */
parNode= BLI_dlrbTree_search(tree, cmp_cb, data);
parNode = BLI_dlrbTree_search(tree, cmp_cb, data);
/* add new node to the BST in the 'standard way' as appropriate
* NOTE: we do not support duplicates in our tree...
@@ -532,49 +532,49 @@ DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
* NOTE: it is assumed that the values will be unit values only
*/
switch (cmp_cb(parNode, data)) {
case -1: /* add new node as left child */
case -1: /* add new node as left child */
{
node= new_cb(data);
new_node= 1;
node = new_cb(data);
new_node = 1;
parNode->left= node;
node->parent= parNode;
parNode->left = node;
node->parent = parNode;
}
break;
break;
case 1: /* add new node as right child */
case 1: /* add new node as right child */
{
node= new_cb(data);
new_node= 1;
node = new_cb(data);
new_node = 1;
parNode->right= node;
node->parent= parNode;
parNode->right = node;
node->parent = parNode;
}
break;
break;
default: /* update the duplicate node as appropriate */
default: /* update the duplicate node as appropriate */
{
if (update_cb)
update_cb(parNode, data);
}
break;
break;
}
}
else {
/* no nodes in the tree yet... add a new node as the root */
node= new_cb(data);
new_node= 1;
node = new_cb(data);
new_node = 1;
tree->root= node;
tree->root = node;
}
/* if a new node was added, it should be tagged as red, and then balanced as appropriate */
if (new_node) {
/* tag this new node as being 'red' */
node->tree_col= DLRBT_RED;
node->tree_col = DLRBT_RED;
/* perform BST balancing steps:
* start from case 1, an trek through the tail-recursive insertion checks
* start from case 1, an trek through the tail-recursive insertion checks
*/
insert_check_1(tree, node);
}

150
source/blender/blenlib/intern/bpath.c
View File

@@ -221,7 +221,7 @@ static int findFileRecursive(char *filename_new,
return found;
if (*filesize == -1)
*filesize = 0; /* dir opened fine */
*filesize = 0; /* dir opened fine */
while ((de = readdir(dir)) != NULL) {
@@ -231,7 +231,7 @@ static int findFileRecursive(char *filename_new,
BLI_join_dirfile(path, sizeof(path), dirname, de->d_name);
if (stat(path, &status) != 0)
continue; /* cant stat, don't bother with this file, could print debug info here */
continue; /* cant stat, don't bother with this file, could print debug info here */
if (S_ISREG(status.st_mode)) { /* is file */
if (strncmp(filename, de->d_name, FILE_MAX) == 0) { /* name matches */
@@ -388,29 +388,29 @@ void BLI_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
}
switch (GS(id->name)) {
case ID_IM:
ima= (Image *)id;
if (ima->packedfile == NULL || (flag & BLI_BPATH_TRAVERSE_SKIP_PACKED) == 0) {
if (ELEM3(ima->source, IMA_SRC_FILE, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
rewrite_path_fixed(ima->name, visit_cb, absbase, bpath_user_data);
case ID_IM:
ima = (Image *)id;
if (ima->packedfile == NULL || (flag & BLI_BPATH_TRAVERSE_SKIP_PACKED) == 0) {
if (ELEM3(ima->source, IMA_SRC_FILE, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
rewrite_path_fixed(ima->name, visit_cb, absbase, bpath_user_data);
}
}
}
break;
case ID_BR:
break;
case ID_BR:
{
Brush *brush= (Brush *)id;
Brush *brush = (Brush *)id;
if (brush->icon_filepath[0]) {
rewrite_path_fixed(brush->icon_filepath, visit_cb, absbase, bpath_user_data);
}
}
break;
case ID_OB:
case ID_OB:
#define BPATH_TRAVERSE_POINTCACHE(ptcaches) \
{ \
PointCache *cache; \
for (cache= (ptcaches).first; cache; cache= cache->next) { \
if (cache->flag & PTCACHE_DISK_CACHE) { \
for (cache = (ptcaches).first; cache; cache = cache->next) { \
if (cache->flag & PTCACHE_DISK_CACHE) { \
rewrite_path_fixed(cache->path, \
visit_cb, \
absbase, \
@@ -420,69 +420,69 @@ void BLI_bpath_traverse_id(Main *bmain, ID *id, BPathVisitor visit_cb, const int
} \
{
Object *ob= (Object *)id;
ModifierData *md;
ParticleSystem *psys;
{
Object *ob = (Object *)id;
ModifierData *md;
ParticleSystem *psys;
/* do via modifiers instead */
/* do via modifiers instead */
#if 0
if (ob->fluidsimSettings) {
rewrite_path_fixed(ob->fluidsimSettings->surfdataPath, visit_cb, absbase, bpath_user_data);
}
if (ob->fluidsimSettings) {
rewrite_path_fixed(ob->fluidsimSettings->surfdataPath, visit_cb, absbase, bpath_user_data);
}
#endif
for (md= ob->modifiers.first; md; md= md->next) {
if (md->type == eModifierType_Fluidsim) {
FluidsimModifierData *fluidmd= (FluidsimModifierData *)md;
if (fluidmd->fss) {
rewrite_path_fixed(fluidmd->fss->surfdataPath, visit_cb, absbase, bpath_user_data);
for (md = ob->modifiers.first; md; md = md->next) {
if (md->type == eModifierType_Fluidsim) {
FluidsimModifierData *fluidmd = (FluidsimModifierData *)md;
if (fluidmd->fss) {
rewrite_path_fixed(fluidmd->fss->surfdataPath, visit_cb, absbase, bpath_user_data);
}
}
else if (md->type == eModifierType_Smoke) {
SmokeModifierData *smd = (SmokeModifierData *)md;
if (smd->type & MOD_SMOKE_TYPE_DOMAIN) {
BPATH_TRAVERSE_POINTCACHE(smd->domain->ptcaches[0]);
}
}
else if (md->type == eModifierType_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_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);
}
}
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;
}
}

18
source/blender/blenlib/intern/edgehash.c
View File

@@ -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; i<eh->nbuckets; i++) {
for (i = 0; i < eh->nbuckets; i++) {
EdgeEntry *e;
for (e = eh->buckets[i]; e; ) {
@@ -231,7 +231,7 @@ void BLI_edgehashIterator_getKey(EdgeHashIterator *ehi, unsigned int *v0_r, unsi
}
void *BLI_edgehashIterator_getValue(EdgeHashIterator *ehi)
{
return ehi->curEntry?ehi->curEntry->val:NULL;
return ehi->curEntry ? ehi->curEntry->val : NULL;
}
void BLI_edgehashIterator_setValue(EdgeHashIterator *ehi, void *val)

90
source/blender/blenlib/intern/fileops.c
View File

@@ -74,7 +74,7 @@ int BLI_file_gzip(const char *from, const char *to)
char buffer[10240];
int file;
int readsize = 0;
int rval= 0, err;
int rval = 0, err;
gzFile gzfile;
/* level 1 is very close to 3 (the default) in terms of file size,
@@ -82,7 +82,7 @@ int BLI_file_gzip(const char *from, const char *to)
gzfile = BLI_gzopen(to, "wb1");
if (gzfile == NULL)
return -1;
file = BLI_open(from, O_BINARY|O_RDONLY, 0);
file = BLI_open(from, O_BINARY | O_RDONLY, 0);
if (file < 0)
return -2;
@@ -90,15 +90,15 @@ int BLI_file_gzip(const char *from, const char *to)
readsize = read(file, buffer, sizeof(buffer));
if (readsize < 0) {
rval= -2; /* error happened in reading */
rval = -2; /* error happened in reading */
fprintf(stderr, "Error reading file %s: %s.\n", from, strerror(errno));
break;
}
else if (readsize == 0)
break; /* done reading */
break; /* done reading */
if (gzwrite(gzfile, buffer, readsize) <= 0) {
rval= -1; /* error happened in writing */
rval = -1; /* error happened in writing */
fprintf(stderr, "Error writing gz file %s: %s.\n", to, gzerror(gzfile, &err));
break;
}
@@ -116,38 +116,38 @@ int BLI_file_gzip(const char *from, const char *to)
char *BLI_file_ungzip_to_mem(const char *from_file, int *size_r)
{
gzFile gzfile;
int readsize, size, alloc_size=0;
char *mem= NULL;
const int chunk_size= 512*1024;
int readsize, size, alloc_size = 0;
char *mem = NULL;
const int chunk_size = 512 * 1024;
size= 0;
size = 0;
gzfile = BLI_gzopen( from_file, "rb" );
for (;;) {
if (mem==NULL) {
mem= MEM_callocN(chunk_size, "BLI_ungzip_to_mem");
alloc_size= chunk_size;
gzfile = BLI_gzopen(from_file, "rb");
for (;; ) {
if (mem == NULL) {
mem = MEM_callocN(chunk_size, "BLI_ungzip_to_mem");
alloc_size = chunk_size;
}
else {
mem= MEM_reallocN(mem, size+chunk_size);
alloc_size+= chunk_size;
mem = MEM_reallocN(mem, size + chunk_size);
alloc_size += chunk_size;
}
readsize= gzread(gzfile, mem+size, chunk_size);
if (readsize>0) {
size+= readsize;
readsize = gzread(gzfile, mem + size, chunk_size);
if (readsize > 0) {
size += readsize;
}
else break;
}
if (size==0) {
if (size == 0) {
MEM_freeN(mem);
mem= NULL;
mem = NULL;
}
else if (alloc_size!=size)
mem= MEM_reallocN(mem, size);
else if (alloc_size != size)
mem = MEM_reallocN(mem, size);
*size_r= size;
*size_r = size;
return mem;
}
@@ -254,14 +254,14 @@ int BLI_delete(const char *file, int dir, int recursive)
if (recursive) {
callLocalErrorCallBack("Recursive delete is unsupported on Windows");
err= 1;
err = 1;
}
else if (dir) {
err= !RemoveDirectoryW(file_16);
if (err) printf ("Unable to remove directory");
err = !RemoveDirectoryW(file_16);
if (err) printf("Unable to remove directory");
}
else {
err= !DeleteFileW(file_16);
err = !DeleteFileW(file_16);
if (err) callLocalErrorCallBack("Unable to delete file");
}
@@ -288,7 +288,7 @@ int BLI_move(const char *file, const char *to)
UTF16_ENCODE(file);
UTF16_ENCODE(str);
err= !MoveFileW(file_16, str_16);
err = !MoveFileW(file_16, str_16);
UTF16_UN_ENCODE(str);
UTF16_UN_ENCODE(file);
@@ -350,7 +350,7 @@ void BLI_dir_create_recursive(const char *dirname)
* blah1/blah2 (without slash) */
BLI_strncpy(tmp, dirname, sizeof(tmp));
lslash= BLI_last_slash(tmp);
lslash = BLI_last_slash(tmp);
if (lslash == tmp + strlen(tmp) - 1) {
*lslash = 0;
@@ -358,7 +358,7 @@ void BLI_dir_create_recursive(const char *dirname)
if (BLI_exists(tmp)) return;
lslash= BLI_last_slash(tmp);
lslash = BLI_last_slash(tmp);
if (lslash) {
/* Split about the last slash and recurse */
*lslash = 0;
@@ -366,7 +366,7 @@ void BLI_dir_create_recursive(const char *dirname)
}
if (dirname[0]) /* patch, this recursive loop tries to create a nameless directory */
if (umkdir(dirname)==-1)
if (umkdir(dirname) == -1)
printf("Unable to create directory %s\n", dirname);
}
@@ -394,7 +394,7 @@ enum {
recursiveOp_Callback_Error = 2
} recuresiveOp_Callback_Result;
typedef int (*recursiveOp_Callback) (const char *from, const char *to);
typedef int (*recursiveOp_Callback)(const char *from, const char *to);
/* appending of filename to dir (ensures for buffer size before appending) */
static void join_dirfile_alloc(char **dst, size_t *alloc_len, const char *dir, const char *file)
@@ -680,11 +680,11 @@ static int copy_single_file(const char *from, const char *to)
need_free = 0;
}
else {
link_buffer = MEM_callocN(st.st_size+2, "copy_single_file link_buffer");
link_buffer = MEM_callocN(st.st_size + 2, "copy_single_file link_buffer");
need_free = 1;
}
link_len = readlink(from, link_buffer, st.st_size+1);
link_len = readlink(from, link_buffer, st.st_size + 1);
if (link_len < 0) {
perror("readlink");
@@ -706,10 +706,10 @@ static int copy_single_file(const char *from, const char *to)
return recursiveOp_Callback_OK;
}
else if (S_ISCHR (st.st_mode) ||
S_ISBLK (st.st_mode) ||
S_ISFIFO (st.st_mode) ||
S_ISSOCK (st.st_mode))
else if (S_ISCHR(st.st_mode) ||
S_ISBLK(st.st_mode) ||
S_ISFIFO(st.st_mode) ||
S_ISSOCK(st.st_mode))
{
/* copy special type of file */
if (mknod(to, st.st_mode, st.st_rdev)) {
@@ -798,7 +798,7 @@ static char *check_destination(const char *file, const char *to)
if (!filename) {
MEM_freeN(str);
return (char*)to;
return (char *)to;
}
/* skip slash */
@@ -814,7 +814,7 @@ static char *check_destination(const char *file, const char *to)
}
}
return (char*)to;
return (char *)to;
}
int BLI_copy(const char *file, const char *to)
@@ -824,7 +824,7 @@ int BLI_copy(const char *file, const char *to)
ret = recursive_operation(file, actual_to, copy_callback_pre, copy_single_file, NULL);
if (actual_to!=to)
if (actual_to != to)
MEM_freeN(actual_to);
return ret;
@@ -852,16 +852,16 @@ void BLI_dir_create_recursive(const char *dirname)
tmp = static_buf;
needs_free = 0;
#else
size = strlen(dirname)+1;
size = strlen(dirname) + 1;
tmp = MEM_callocN(size, "BLI_dir_create_recursive tmp");
needs_free = 1;
#endif
BLI_strncpy(tmp, dirname, size);
lslash= BLI_last_slash(tmp);
lslash = BLI_last_slash(tmp);
if (lslash) {
/* Split about the last slash and recurse */
/* Split about the last slash and recurse */
*lslash = 0;
BLI_dir_create_recursive(tmp);
}

104
source/blender/blenlib/intern/jitter.c
View File

@@ -43,41 +43,41 @@ void BLI_jitterate1(float *jit1, float *jit2, int num, float rad1)
int i, j, k;
float vecx, vecy, dvecx, dvecy, x, y, len;
for (i = 2*num-2; i>=0 ; i-=2) {
for (i = 2 * num - 2; i >= 0; i -= 2) {
dvecx = dvecy = 0.0;
x = jit1[i];
y = jit1[i+1];
for (j = 2*num-2; j>=0 ; j-=2) {
y = jit1[i + 1];
for (j = 2 * num - 2; j >= 0; j -= 2) {
if (i != j) {
vecx = jit1[j] - x - 1.0f;
vecy = jit1[j+1] - y - 1.0f;
for (k = 3; k>0 ; k--) {
if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
len= sqrt(vecx*vecx + vecy*vecy);
if (len>0 && len<rad1) {
len= len/rad1;
dvecx += vecx/len;
dvecy += vecy/len;
vecy = jit1[j + 1] - y - 1.0f;
for (k = 3; k > 0; k--) {
if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
len = sqrt(vecx * vecx + vecy * vecy);
if (len > 0 && len < rad1) {
len = len / rad1;
dvecx += vecx / len;
dvecy += vecy / len;
}
}
vecx += 1.0f;
if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
len= sqrt(vecx*vecx + vecy*vecy);
if (len>0 && len<rad1) {
len= len/rad1;
dvecx += vecx/len;
dvecy += vecy/len;
if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
len = sqrt(vecx * vecx + vecy * vecy);
if (len > 0 && len < rad1) {
len = len / rad1;
dvecx += vecx / len;
dvecy += vecy / len;
}
}
vecx += 1.0f;
if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
len= sqrt(vecx*vecx + vecy*vecy);
if (len>0 && len<rad1) {
len= len/rad1;
dvecx += vecx/len;
dvecy += vecy/len;
if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
len = sqrt(vecx * vecx + vecy * vecy);
if (len > 0 && len < rad1) {
len = len / rad1;
dvecx += vecx / len;
dvecy += vecy / len;
}
}
vecx -= 2.0f;
@@ -86,12 +86,12 @@ void BLI_jitterate1(float *jit1, float *jit2, int num, float rad1)
}
}
x -= dvecx/18.0f;
y -= dvecy/18.0f;
x -= dvecx / 18.0f;
y -= dvecy / 18.0f;
x -= floorf(x);
y -= floorf(y);
jit2[i] = x;
jit2[i+1] = y;
jit2[i + 1] = y;
}
memcpy(jit1, jit2, 2 * num * sizeof(float));
}
@@ -101,36 +101,36 @@ void BLI_jitterate2(float *jit1, float *jit2, int num, float rad2)
int i, j;
float vecx, vecy, dvecx, dvecy, x, y;
for (i=2*num -2; i>= 0 ; i-=2) {
for (i = 2 * num - 2; i >= 0; i -= 2) {
dvecx = dvecy = 0.0;
x = jit1[i];
y = jit1[i+1];
for (j =2*num -2; j>= 0 ; j-=2) {
y = jit1[i + 1];
for (j = 2 * num - 2; j >= 0; j -= 2) {
if (i != j) {
vecx = jit1[j] - x - 1.0f;
vecy = jit1[j+1] - y - 1.0f;
vecy = jit1[j + 1] - y - 1.0f;
if ( fabsf(vecx)<rad2) dvecx+= vecx*rad2;
if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
vecx += 1.0f;
if ( fabsf(vecx)<rad2) dvecx+= vecx*rad2;
if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
vecx += 1.0f;
if ( fabsf(vecx)<rad2) dvecx+= vecx*rad2;
if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
if ( fabsf(vecy)<rad2) dvecy+= vecy*rad2;
if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
vecy += 1.0f;
if ( fabsf(vecy)<rad2) dvecy+= vecy*rad2;
if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
vecy += 1.0f;
if ( fabsf(vecy)<rad2) dvecy+= vecy*rad2;
if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
}
}
x -= dvecx/2.0f;
y -= dvecy/2.0f;
x -= dvecx / 2.0f;
y -= dvecy / 2.0f;
x -= floorf(x);
y -= floorf(y);
jit2[i] = x;
jit2[i+1] = y;
jit2[i + 1] = y;
}
memcpy(jit1, jit2, 2 * num * sizeof(float));
}
@@ -141,23 +141,23 @@ void BLI_jitter_init(float *jitarr, int num)
float *jit2, x, rad1, rad2, rad3;
int i;
if (num==0) return;
if (num == 0) return;
jit2= MEM_mallocN(12 + 2*sizeof(float)*num, "initjit");
rad1= 1.0f/sqrtf((float)num);
rad2= 1.0f/((float)num);
rad3= sqrtf((float)num)/((float)num);
jit2 = MEM_mallocN(12 + 2 * sizeof(float) * num, "initjit");
rad1 = 1.0f / sqrtf((float)num);
rad2 = 1.0f / ((float)num);
rad3 = sqrtf((float)num) / ((float)num);
BLI_srand(31415926 + num);
x= 0;
for (i=0; i<2*num; i+=2) {
jitarr[i]= x+ rad1*(float)(0.5-BLI_drand());
jitarr[i+1]= ((float)i/2)/num +rad1*(float)(0.5-BLI_drand());
x+= rad3;
x = 0;
for (i = 0; i < 2 * num; i += 2) {
jitarr[i] = x + rad1 * (float)(0.5 - BLI_drand());
jitarr[i + 1] = ((float)i / 2) / num + rad1 * (float)(0.5 - BLI_drand());
x += rad3;
x -= floorf(x);
}
for (i=0 ; i<24 ; i++) {
for (i = 0; i < 24; i++) {
BLI_jitterate1(jitarr, jit2, num, rad1);
BLI_jitterate1(jitarr, jit2, num, rad1);
BLI_jitterate2(jitarr, jit2, num, rad2);
@@ -166,9 +166,9 @@ void BLI_jitter_init(float *jitarr, int num)
MEM_freeN(jit2);
/* finally, move jittertab to be centered around (0,0) */
for (i=0; i<2*num; i+=2) {
for (i = 0; i < 2 * num; i += 2) {
jitarr[i] -= 0.5f;
jitarr[i+1] -= 0.5f;
jitarr[i + 1] -= 0.5f;
}
}

38
source/blender/blenlib/intern/math_geom.c
View File

@@ -429,23 +429,23 @@ int isect_line_sphere_v3(const float l1[3], const float l2[3],
*/
const float ldir[3] = {
l2[0] - l1[0],
l2[1] - l1[1],
l2[2] - l1[2]
l2[0] - l1[0],
l2[1] - l1[1],
l2[2] - l1[2]
};
const float a = dot_v3v3(ldir, ldir);
const float b = 2.0f *
(ldir[0] * (l1[0] - sp[0]) +
ldir[1] * (l1[1] - sp[1]) +
ldir[2] * (l1[2] - sp[2]));
(ldir[0] * (l1[0] - sp[0]) +
ldir[1] * (l1[1] - sp[1]) +
ldir[2] * (l1[2] - sp[2]));
const float c =
dot_v3v3(sp, sp) +
dot_v3v3(l1, l1) -
(2.0f * dot_v3v3(sp, l1)) -
(r * r);
dot_v3v3(sp, sp) +
dot_v3v3(l1, l1) -
(2.0f * dot_v3v3(sp, l1)) -
(r * r);
const float i = b * b - 4.0f * a * c;
@@ -490,14 +490,14 @@ int isect_line_sphere_v2(const float l1[2], const float l2[2],
const float a = dot_v2v2(ldir, ldir);
const float b = 2.0f *
(ldir[0] * (l1[0] - sp[0]) +
ldir[1] * (l1[1] - sp[1]));
(ldir[0] * (l1[0] - sp[0]) +
ldir[1] * (l1[1] - sp[1]));
const float c =
dot_v2v2(sp, sp) +
dot_v2v2(l1, l1) -
(2.0f * dot_v2v2(sp, l1)) -
(r * r);
dot_v2v2(sp, sp) +
dot_v2v2(l1, l1) -
(2.0f * dot_v2v2(sp, l1)) -
(r * r);
const float i = b * b - 4.0f * a * c;
@@ -1738,9 +1738,9 @@ void axis_dominant_v3(int *axis_a, int *axis_b, const float axis[3])
const float yn = fabsf(axis[1]);
const float zn = fabsf(axis[2]);
if (zn >= xn && zn >= yn) { *axis_a= 0; *axis_b = 1; }
else if (yn >= xn && yn >= zn) { *axis_a= 0; *axis_b = 2; }
else { *axis_a= 1; *axis_b = 2; }
if (zn >= xn && zn >= yn) { *axis_a = 0; *axis_b = 1; }
else if (yn >= xn && yn >= zn) { *axis_a = 0; *axis_b = 2; }
else { *axis_a = 1; *axis_b = 2; }
}
static float tri_signed_area(const float v1[3], const float v2[3], const float v3[3], const int i, const int j)

13
source/blender/blenlib/intern/math_rotation.c
View File

@@ -1691,12 +1691,13 @@ void quat_apply_track(float quat[4], short axis, short upflag)
{
/* rotations are hard coded to match vec_to_quat */
const float quat_track[][4] = {
{0.70710676908493, 0.0, -0.70710676908493, 0.0}, /* pos-y90 */
{0.5, 0.5, 0.5, 0.5}, /* Quaternion((1,0,0), radians(90)) * Quaternion((0,1,0), radians(90)) */
{0.70710676908493, 0.0, 0.0, 0.70710676908493}, /* pos-z90 */
{0.70710676908493, 0.0, 0.70710676908493, 0.0}, /* neg-y90 */
{0.5, -0.5, -0.5, 0.5}, /* Quaternion((1,0,0), radians(-90)) * Quaternion((0,1,0), radians(-90)) */
{-3.0908619663705394e-08, 0.70710676908493, 0.70710676908493, 3.0908619663705394e-08}}; /* no rotation */
{0.70710676908493, 0.0, -0.70710676908493, 0.0}, /* pos-y90 */
{0.5, 0.5, 0.5, 0.5}, /* Quaternion((1,0,0), radians(90)) * Quaternion((0,1,0), radians(90)) */
{0.70710676908493, 0.0, 0.0, 0.70710676908493}, /* pos-z90 */
{0.70710676908493, 0.0, 0.70710676908493, 0.0}, /* neg-y90 */
{0.5, -0.5, -0.5, 0.5}, /* Quaternion((1,0,0), radians(-90)) * Quaternion((0,1,0), radians(-90)) */
{-3.0908619663705394e-08, 0.70710676908493, 0.70710676908493, 3.0908619663705394e-08} /* no rotation */
};
assert(axis >= 0 && axis <= 5);
assert(upflag >= 0 && upflag <= 2);

429
source/blender/blenlib/intern/noise.c
View File

@@ -45,10 +45,10 @@ static float noise3_perlin(float vec[3]);
//static float turbulence_perlin(float *point, float lofreq, float hifreq);
//static float turbulencep(float noisesize, float x, float y, float z, int nr);
#define HASHVEC(x, y, z) hashvectf + 3 * hash[ (hash[ (hash[(z) & 255] + (y)) & 255] + (x)) & 255]
#define HASHVEC(x, y, z) hashvectf + 3 * hash[(hash[(hash[(z) & 255] + (y)) & 255] + (x)) & 255]
/* needed for voronoi */
#define HASHPNT(x, y, z) hashpntf + 3 * hash[ (hash[ (hash[(z) & 255] + (y)) & 255] + (x)) & 255]
#define HASHPNT(x, y, z) hashpntf + 3 * hash[(hash[(hash[(z) & 255] + (y)) & 255] + (x)) & 255]
static float hashpntf[768] = {
0.536902, 0.020915, 0.501445, 0.216316, 0.517036, 0.822466, 0.965315,
0.377313, 0.678764, 0.744545, 0.097731, 0.396357, 0.247202, 0.520897,
@@ -162,7 +162,7 @@ static float hashpntf[768] = {
0.114246, 0.905043, 0.713870, 0.555261, 0.951333
};
unsigned char hash[512]= {
unsigned char hash[512] = {
0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0, 0xDE, 0x95, 0x2E, 0xDC,
0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC, 0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8, 0x8B, 0x63,
0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80,
@@ -193,7 +193,7 @@ unsigned char hash[512]= {
};
float hashvectf[768]= {
float hashvectf[768] = {
0.33783, 0.715698, -0.611206, -0.944031, -0.326599, -0.045624, -0.101074, -0.416443, -0.903503, 0.799286, 0.49411,
-0.341949, -0.854645, 0.518036, 0.033936, 0.42514, -0.437866, -0.792114, -0.358948, 0.597046, 0.717377, -0.985413,
0.144714, 0.089294, -0.601776, -0.33728, -0.723907, -0.449921, 0.594513, 0.666382, 0.208313, -0.10791, 0.972076,
@@ -263,7 +263,7 @@ float hashvectf[768]= {
0.196045, -0.982941, 0.164307, -0.082245, 0.233734, -0.97226, -0.005005, -0.747253, -0.611328, 0.260437, 0.645599,
0.592773, 0.481384, 0.117706, -0.949524, -0.29068, -0.535004, -0.791901, -0.294312, -0.627167, -0.214447, 0.748718,
-0.047974, -0.813477, -0.57959, -0.175537, 0.477264, -0.860992, 0.738556, -0.414246, -0.53183, 0.562561, -0.704071,
0.433289, -0.754944, 0.64801, -0.100586, 0.114716, 0.044525, -0.992371, 0.966003, 0.244873, -0.082764,
0.433289, -0.754944, 0.64801, -0.100586, 0.114716, 0.044525, -0.992371, 0.966003, 0.244873, -0.082764,
};
/**************************/
@@ -272,28 +272,28 @@ float hashvectf[768]= {
static float lerp(float t, float a, float b)
{
return (a+t*(b-a));
return (a + t * (b - a));
}
static float npfade(float t)
{
return (t*t*t*(t*(t*6.0f-15.0f)+10.0f));
return (t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f));
}
static float grad(int hash, float x, float y, float z)
{
int h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE
float u = h<8 ? x : y, // INTO 12 GRADIENT DIRECTIONS.
v = h<4 ? y : h==12||h==14 ? x : z;
return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
float u = h < 8 ? x : y, // INTO 12 GRADIENT DIRECTIONS.
v = h < 4 ? y : h == 12 || h == 14 ? x : z;
return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
}
/* instead of adding another permutation array, just use hash table defined above */
static float newPerlin(float x, float y, float z)
{
int A, AA, AB, B, BA, BB;
float u=floor(x), v=floor(y), w=floor(z);
int X=((int)u) & 255, Y=((int)v) & 255, Z=((int)w) & 255; // FIND UNIT CUBE THAT CONTAINS POINT
float u = floor(x), v = floor(y), w = floor(z);
int X = ((int)u) & 255, Y = ((int)v) & 255, Z = ((int)w) & 255; // FIND UNIT CUBE THAT CONTAINS POINT
x -= u; // FIND RELATIVE X,Y,Z
y -= v; // OF POINT IN CUBE.
z -= w;
@@ -315,7 +315,7 @@ static float newPerlin(float x, float y, float z)
/* for use with BLI_gNoise()/BLI_gTurbulence(), returns unsigned improved perlin noise */
static float newPerlinU(float x, float y, float z)
{
return (0.5f+0.5f*newPerlin(x, y, z));
return (0.5f + 0.5f * newPerlin(x, y, z));
}
@@ -328,92 +328,92 @@ static float orgBlenderNoise(float x, float y, float z)
{
register float cn1, cn2, cn3, cn4, cn5, cn6, i, *h;
float fx, fy, fz, ox, oy, oz, jx, jy, jz;
float n= 0.5;
float n = 0.5;
int ix, iy, iz, b00, b01, b10, b11, b20, b21;
fx= floor(x);
fy= floor(y);
fz= floor(z);
fx = floor(x);
fy = floor(y);
fz = floor(z);
ox= x- fx;
oy= y- fy;
oz= z- fz;
ox = x - fx;
oy = y - fy;
oz = z - fz;
ix= (int)fx;
iy= (int)fy;
iz= (int)fz;
ix = (int)fx;
iy = (int)fy;
iz = (int)fz;
jx= ox-1;
jy= oy-1;
jz= oz-1;
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 = 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;
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)];
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;
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);
/* 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;
if (n < 0.0f) n = 0.0f; else if (n > 1.0f) n = 1.0f;
return n;
}
/* as orgBlenderNoise(), returning signed noise */
static float orgBlenderNoiseS(float x, float y, float z)
{
return (2.0f*orgBlenderNoise(x, y, z)-1.0f);
return (2.0f * orgBlenderNoise(x, y, z) - 1.0f);
}
/* separated from orgBlenderNoise above, with scaling */
float BLI_hnoise(float noisesize, float x, float y, float z)
{
if (noisesize==0.0f) return 0.0f;
x= (1.0f+x)/noisesize;
y= (1.0f+y)/noisesize;
z= (1.0f+z)/noisesize;
if (noisesize == 0.0f) return 0.0f;
x = (1.0f + x) / noisesize;
y = (1.0f + y) / noisesize;
z = (1.0f + z) / noisesize;
return orgBlenderNoise(x, y, z);
}
@@ -421,53 +421,54 @@ float BLI_hnoise(float noisesize, float x, float y, float z)
/* original turbulence functions */
float BLI_turbulence(float noisesize, float x, float y, float z, int nr)
{
float s, d= 0.5, div=1.0;
float s, d = 0.5, div = 1.0;
s= BLI_hnoise(noisesize, x, y, z);
s = BLI_hnoise(noisesize, x, y, z);
while (nr>0) {
while (nr > 0) {
s+= d*BLI_hnoise(noisesize*d, x, y, z);
div+= d;
d*= 0.5f;
s += d * BLI_hnoise(noisesize * d, x, y, z);
div += d;
d *= 0.5f;
nr--;
}
return s/div;
return s / div;
}
float BLI_turbulence1(float noisesize, float x, float y, float z, int nr)
{
float s, d= 0.5, div=1.0;
float s, d = 0.5, div = 1.0;
s= fabsf((-1.0f + 2.0f * BLI_hnoise(noisesize, x, y, z)));
s = fabsf((-1.0f + 2.0f * BLI_hnoise(noisesize, x, y, z)));
while (nr>0) {
while (nr > 0) {
s+= fabsf(d* (-1.0f+2.0f*BLI_hnoise(noisesize*d, x, y, z)));
div+= d;
d*= 0.5f;
s += fabsf(d * (-1.0f + 2.0f * BLI_hnoise(noisesize * d, x, y, z)));
div += d;
d *= 0.5f;
nr--;
}
return s/div;
return s / div;
}
/* ********************* FROM PERLIN HIMSELF: ******************** */
static char p[512+2]= {
0xA2,0xA0,0x19,0x3B,0xF8,0xEB,0xAA,0xEE,0xF3,0x1C,0x67,0x28,0x1D,0xED,0x0,0xDE,0x95,0x2E,0xDC,0x3F,0x3A,0x82,0x35,0x4D,0x6C,0xBA,0x36,0xD0,0xF6,0xC,0x79,0x32,0xD1,0x59,0xF4,0x8,0x8B,0x63,0x89,0x2F,0xB8,0xB4,0x97,0x83,0xF2,0x8F,0x18,0xC7,0x51,0x14,0x65,0x87,0x48,0x20,0x42,0xA8,0x80,0xB5,0x40,0x13,0xB2,0x22,0x7E,0x57,
0xBC,0x7F,0x6B,0x9D,0x86,0x4C,0xC8,0xDB,0x7C,0xD5,0x25,0x4E,0x5A,0x55,0x74,0x50,0xCD,0xB3,0x7A,0xBB,0xC3,0xCB,0xB6,0xE2,0xE4,0xEC,0xFD,0x98,0xB,0x96,0xD3,0x9E,0x5C,0xA1,0x64,0xF1,0x81,0x61,0xE1,0xC4,0x24,0x72,0x49,0x8C,0x90,0x4B,0x84,0x34,0x38,0xAB,0x78,0xCA,0x1F,0x1,0xD7,0x93,0x11,0xC1,0x58,0xA9,0x31,0xF9,0x44,0x6D,
0xBF,0x33,0x9C,0x5F,0x9,0x94,0xA3,0x85,0x6,0xC6,0x9A,0x1E,0x7B,0x46,0x15,0x30,0x27,0x2B,0x1B,0x71,0x3C,0x5B,0xD6,0x6F,0x62,0xAC,0x4F,0xC2,0xC0,0xE,0xB1,0x23,0xA7,0xDF,0x47,0xB0,0x77,0x69,0x5,0xE9,0xE6,0xE7,0x76,0x73,0xF,0xFE,0x6E,0x9B,0x56,0xEF,0x12,0xA5,0x37,0xFC,0xAE,0xD9,0x3,0x8E,0xDD,0x10,0xB9,0xCE,0xC9,0x8D,
0xDA,0x2A,0xBD,0x68,0x17,0x9F,0xBE,0xD4,0xA,0xCC,0xD2,0xE8,0x43,0x3D,0x70,0xB7,0x2,0x7D,0x99,0xD8,0xD,0x60,0x8A,0x4,0x2C,0x3E,0x92,0xE5,0xAF,0x53,0x7,0xE0,0x29,0xA6,0xC5,0xE3,0xF5,0xF7,0x4A,0x41,0x26,0x6A,0x16,0x5E,0x52,0x2D,0x21,0xAD,0xF0,0x91,0xFF,0xEA,0x54,0xFA,0x66,0x1A,0x45,0x39,0xCF,0x75,0xA4,0x88,0xFB,0x5D,
0xA2,0xA0,0x19,0x3B,0xF8,0xEB,0xAA,0xEE,0xF3,0x1C,0x67,0x28,0x1D,0xED,0x0,0xDE,0x95,0x2E,0xDC,0x3F,0x3A,0x82,0x35,0x4D,0x6C,0xBA,0x36,0xD0,0xF6,0xC,0x79,0x32,0xD1,0x59,0xF4,0x8,0x8B,0x63,0x89,0x2F,0xB8,0xB4,0x97,0x83,0xF2,0x8F,0x18,0xC7,0x51,0x14,0x65,0x87,0x48,0x20,0x42,0xA8,0x80,0xB5,0x40,0x13,0xB2,0x22,0x7E,0x57,
0xBC,0x7F,0x6B,0x9D,0x86,0x4C,0xC8,0xDB,0x7C,0xD5,0x25,0x4E,0x5A,0x55,0x74,0x50,0xCD,0xB3,0x7A,0xBB,0xC3,0xCB,0xB6,0xE2,0xE4,0xEC,0xFD,0x98,0xB,0x96,0xD3,0x9E,0x5C,0xA1,0x64,0xF1,0x81,0x61,0xE1,0xC4,0x24,0x72,0x49,0x8C,0x90,0x4B,0x84,0x34,0x38,0xAB,0x78,0xCA,0x1F,0x1,0xD7,0x93,0x11,0xC1,0x58,0xA9,0x31,0xF9,0x44,0x6D,
0xBF,0x33,0x9C,0x5F,0x9,0x94,0xA3,0x85,0x6,0xC6,0x9A,0x1E,0x7B,0x46,0x15,0x30,0x27,0x2B,0x1B,0x71,0x3C,0x5B,0xD6,0x6F,0x62,0xAC,0x4F,0xC2,0xC0,0xE,0xB1,0x23,0xA7,0xDF,0x47,0xB0,0x77,0x69,0x5,0xE9,0xE6,0xE7,0x76,0x73,0xF,0xFE,0x6E,0x9B,0x56,0xEF,0x12,0xA5,0x37,0xFC,0xAE,0xD9,0x3,0x8E,0xDD,0x10,0xB9,0xCE,0xC9,0x8D,
0xDA,0x2A,0xBD,0x68,0x17,0x9F,0xBE,0xD4,0xA,0xCC,0xD2,0xE8,0x43,0x3D,0x70,0xB7,0x2,0x7D,0x99,0xD8,0xD,0x60,0x8A,0x4,0x2C,0x3E,0x92,0xE5,0xAF,0x53,0x7,0xE0,0x29,0xA6,0xC5,0xE3,0xF5,0xF7,0x4A,0x41,0x26,0x6A,0x16,0x5E,0x52,0x2D,0x21,0xAD,0xF0,0x91,0xFF,0xEA,0x54,0xFA,0x66,0x1A,0x45,0x39,0xCF,0x75,0xA4,0x88,0xFB,0x5D,
0xA2,0xA0};
static char p[512 + 2] = {
0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0, 0xDE, 0x95, 0x2E, 0xDC, 0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC, 0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8, 0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57,
0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB, 0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1, 0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D,
0xBF, 0x33, 0x9C, 0x5F, 0x9, 0x94, 0xA3, 0x85, 0x6, 0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE, 0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5, 0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF, 0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3, 0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D,
0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA, 0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2, 0x7D, 0x99, 0xD8, 0xD, 0x60, 0x8A, 0x4, 0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7, 0xE0, 0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D,
0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0, 0xDE, 0x95, 0x2E, 0xDC, 0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC, 0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8, 0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57,
0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB, 0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1, 0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D,
0xBF, 0x33, 0x9C, 0x5F, 0x9, 0x94, 0xA3, 0x85, 0x6, 0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE, 0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5, 0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF, 0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3, 0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D,
0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA, 0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2, 0x7D, 0x99, 0xD8, 0xD, 0x60, 0x8A, 0x4, 0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7, 0xE0, 0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D,
0xA2, 0xA0
};
static float g[512+2][3]= {
static float g[512 + 2][3] = {
{0.33783, 0.715698, -0.611206},
{-0.944031, -0.326599, -0.045624},
{-0.101074, -0.416443, -0.903503},
@@ -1005,15 +1006,15 @@ static float noise3_perlin(float vec[3])
SETUP(vec[1], by0, by1, ry0, ry1);
SETUP(vec[2], bz0, bz1, rz0, rz1);
i = p[ bx0 ];
j = p[ bx1 ];
i = p[bx0];
j = p[bx1];
b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
#define VALUE_AT(rx,ry,rz) (rx * q[0] + ry * q[1] + rz * q[2])
#define VALUE_AT(rx, ry, rz) (rx * q[0] + ry * q[1] + rz * q[2])
#define SURVE(t) (t * t * (3.0f - 2.0f * t))
/* lerp moved to improved perlin above */
@@ -1023,30 +1024,30 @@ static float noise3_perlin(float vec[3])
sz = SURVE(rz0);
q = g[ b00 + bz0 ];
u = VALUE_AT(rx0,ry0,rz0);
q = g[ b10 + bz0 ];
v = VALUE_AT(rx1,ry0,rz0);
q = g[b00 + bz0];
u = VALUE_AT(rx0, ry0, rz0);
q = g[b10 + bz0];
v = VALUE_AT(rx1, ry0, rz0);
a = lerp(sx, u, v);
q = g[ b01 + bz0 ];
u = VALUE_AT(rx0,ry1,rz0);
q = g[ b11 + bz0 ];
v = VALUE_AT(rx1,ry1,rz0);
q = g[b01 + bz0];
u = VALUE_AT(rx0, ry1, rz0);
q = g[b11 + bz0];
v = VALUE_AT(rx1, ry1, rz0);
b = lerp(sx, u, v);
c = lerp(sy, a, b); /* interpolate in y at lo x */
q = g[ b00 + bz1 ];
u = VALUE_AT(rx0,ry0,rz1);
q = g[ b10 + bz1 ];
v = VALUE_AT(rx1,ry0,rz1);
q = g[b00 + bz1];
u = VALUE_AT(rx0, ry0, rz1);
q = g[b10 + bz1];
v = VALUE_AT(rx1, ry0, rz1);
a = lerp(sx, u, v);
q = g[ b01 + bz1 ];
u = VALUE_AT(rx0,ry1,rz1);
q = g[ b11 + bz1 ];
v = VALUE_AT(rx1,ry1,rz1);
q = g[b01 + bz1];
u = VALUE_AT(rx0, ry1, rz1);
q = g[b11 + bz1];
v = VALUE_AT(rx1, ry1, rz1);
b = lerp(sx, u, v);
d = lerp(sy, a, b); /* interpolate in y at hi x */
@@ -1067,7 +1068,7 @@ static float turbulence_perlin(float *point, float lofreq, float hifreq)
p[2] = point[2];
t = 0;
for (freq = lofreq ; freq < hifreq ; freq *= 2.0) {
for (freq = lofreq; freq < hifreq; freq *= 2.0) {
t += fabsf(noise3_perlin(p)) / freq;
p[0] *= 2.0f;
p[1] *= 2.0f;
@@ -1096,7 +1097,7 @@ static float orgPerlinNoiseU(float x, float y, float z)
v[0] = x;
v[1] = y;
v[2] = z;
return (0.5f+0.5f*noise3_perlin(v));
return (0.5f + 0.5f * noise3_perlin(v));
}
/* *************** CALL AS: *************** */
@@ -1105,9 +1106,9 @@ float BLI_hnoisep(float noisesize, float x, float y, float z)
{
float vec[3];
vec[0]= x/noisesize;
vec[1]= y/noisesize;
vec[2]= z/noisesize;
vec[0] = x / noisesize;
vec[1] = y / noisesize;
vec[2] = z / noisesize;
return noise3_perlin(vec);
}
@@ -1117,11 +1118,11 @@ static float turbulencep(float noisesize, float x, float y, float z, int nr)
{
float vec[3];
vec[0]= x/noisesize;
vec[1]= y/noisesize;
vec[2]= z/noisesize;
vec[0] = x / noisesize;
vec[1] = y / noisesize;
vec[2] = z / noisesize;
nr++;
return turbulence_perlin(vec, 1.0, (float)(1<<nr));
return turbulence_perlin(vec, 1.0, (float)(1 << nr));
}
#endif
@@ -1133,11 +1134,17 @@ static float turbulencep(float noisesize, float x, float y, float z, int nr)
/* Camberra omitted, didn't seem useful */
/* distance squared */
static float dist_Squared(float x, float y, float z, float e) { (void)e; return (x*x + y*y + z*z); }
static float dist_Squared(float x, float y, float z, float e) {
(void)e; return (x * x + y * y + z * z);
}
/* real distance */
static float dist_Real(float x, float y, float z, float e) { (void)e; return sqrtf(x*x + y*y + z*z); }
static float dist_Real(float x, float y, float z, float e) {
(void)e; return sqrtf(x * x + y * y + z * z);
}
/* manhattan/taxicab/cityblock distance */
static float dist_Manhattan(float x, float y, float z, float e) { (void)e; return (fabsf(x) + fabsf(y) + fabsf(z)); }
static float dist_Manhattan(float x, float y, float z, float e) {
(void)e; return (fabsf(x) + fabsf(y) + fabsf(z));
}
/* Chebychev */
static float dist_Chebychev(float x, float y, float z, float e)
{
@@ -1147,8 +1154,8 @@ static float dist_Chebychev(float x, float y, float z, float e)
x = fabsf(x);
y = fabsf(y);
z = fabsf(z);
t = (x>y)?x:y;
return ((z>t)?z:t);
t = (x > y) ? x : y;
return ((z > t) ? z : t);
}
/* minkovsky preset exponent 0.5 */
@@ -1156,7 +1163,7 @@ static float dist_MinkovskyH(float x, float y, float z, float e)
{
float d = sqrtf(fabsf(x)) + sqrtf(fabsf(y)) + sqrtf(fabsf(z));
(void)e;
return (d*d);
return (d * d);
}
/* minkovsky preset exponent 4 */
@@ -1166,19 +1173,19 @@ static float dist_Minkovsky4(float x, float y, float z, float e)
x *= x;
y *= y;
z *= z;
return sqrtf(sqrtf(x*x + y*y + z*z));
return sqrtf(sqrtf(x * x + y * y + z * z));
}
/* Minkovsky, general case, slow, maybe too slow to be useful */
static float dist_Minkovsky(float x, float y, float z, float e)
{
return powf(powf(fabsf(x), e) + powf(fabsf(y), e) + powf(fabsf(z), e), 1.0f/e);
return powf(powf(fabsf(x), e) + powf(fabsf(y), e) + powf(fabsf(z), e), 1.0f / e);
}
/* Not 'pure' Worley, but the results are virtually the same.
* Returns distances in da and point coords in pa */
void voronoi(float x, float y, float z, float* da, float* pa, float me, int dtype)
void voronoi(float x, float y, float z, float *da, float *pa, float me, int dtype)
{
int xx, yy, zz, xi, yi, zi;
float xd, yd, zd, d, *p;
@@ -1212,35 +1219,35 @@ void voronoi(float x, float y, float z, float* da, float* pa, float me, int dtyp
yi = (int)(floor(y));
zi = (int)(floor(z));
da[0] = da[1] = da[2] = da[3] = 1e10f;
for (xx=xi-1;xx<=xi+1;xx++) {
for (yy=yi-1;yy<=yi+1;yy++) {
for (zz=zi-1;zz<=zi+1;zz++) {
for (xx = xi - 1; xx <= xi + 1; xx++) {
for (yy = yi - 1; yy <= yi + 1; yy++) {
for (zz = zi - 1; zz <= zi + 1; zz++) {
p = HASHPNT(xx, yy, zz);
xd = x - (p[0] + xx);
yd = y - (p[1] + yy);
zd = z - (p[2] + zz);
d = distfunc(xd, yd, zd, me);
if (d<da[0]) {
da[3]=da[2]; da[2]=da[1]; da[1]=da[0]; da[0]=d;
pa[9]=pa[6]; pa[10]=pa[7]; pa[11]=pa[8];
pa[6]=pa[3]; pa[7]=pa[4]; pa[8]=pa[5];
pa[3]=pa[0]; pa[4]=pa[1]; pa[5]=pa[2];
pa[0]=p[0]+xx; pa[1]=p[1]+yy; pa[2]=p[2]+zz;
if (d < da[0]) {
da[3] = da[2]; da[2] = da[1]; da[1] = da[0]; da[0] = d;
pa[9] = pa[6]; pa[10] = pa[7]; pa[11] = pa[8];
pa[6] = pa[3]; pa[7] = pa[4]; pa[8] = pa[5];
pa[3] = pa[0]; pa[4] = pa[1]; pa[5] = pa[2];
pa[0] = p[0] + xx; pa[1] = p[1] + yy; pa[2] = p[2] + zz;
}
else if (d<da[1]) {
da[3]=da[2]; da[2]=da[1]; da[1]=d;
pa[9]=pa[6]; pa[10]=pa[7]; pa[11]=pa[8];
pa[6]=pa[3]; pa[7]=pa[4]; pa[8]=pa[5];
pa[3]=p[0]+xx; pa[4]=p[1]+yy; pa[5]=p[2]+zz;
else if (d < da[1]) {
da[3] = da[2]; da[2] = da[1]; da[1] = d;
pa[9] = pa[6]; pa[10] = pa[7]; pa[11] = pa[8];
pa[6] = pa[3]; pa[7] = pa[4]; pa[8] = pa[5];
pa[3] = p[0] + xx; pa[4] = p[1] + yy; pa[5] = p[2] + zz;
}
else if (d<da[2]) {
da[3]=da[2]; da[2]=d;
pa[9]=pa[6]; pa[10]=pa[7]; pa[11]=pa[8];
pa[6]=p[0]+xx; pa[7]=p[1]+yy; pa[8]=p[2]+zz;
else if (d < da[2]) {
da[3] = da[2]; da[2] = d;
pa[9] = pa[6]; pa[10] = pa[7]; pa[11] = pa[8];
pa[6] = p[0] + xx; pa[7] = p[1] + yy; pa[8] = p[2] + zz;
}
else if (d<da[3]) {
da[3]=d;
pa[9]=p[0]+xx; pa[10]=p[1]+yy; pa[11]=p[2]+zz;
else if (d < da[3]) {
da[3] = d;
pa[9] = p[0] + xx; pa[10] = p[1] + yy; pa[11] = p[2] + zz;
}
}
}
@@ -1280,14 +1287,14 @@ static float voronoi_F1F2(float x, float y, float z)
{
float da[4], pa[12];
voronoi(x, y, z, da, pa, 1, 0);
return (da[1]-da[0]);
return (da[1] - da[0]);
}
/* Crackle type pattern, just a scale/clamp of F2-F1 */
static float voronoi_Cr(float x, float y, float z)
{
float t = 10*voronoi_F1F2(x, y, z);
if (t>1.f) return 1.f;
float t = 10 * voronoi_F1F2(x, y, z);
if (t > 1.f) return 1.f;
return t;
}
@@ -1298,43 +1305,43 @@ static float voronoi_F1S(float x, float y, float z)
{
float da[4], pa[12];
voronoi(x, y, z, da, pa, 1, 0);
return (2.0f*da[0]-1.0f);
return (2.0f * da[0] - 1.0f);
}
static float voronoi_F2S(float x, float y, float z)
{
float da[4], pa[12];
voronoi(x, y, z, da, pa, 1, 0);
return (2.0f*da[1]-1.0f);
return (2.0f * da[1] - 1.0f);
}
static float voronoi_F3S(float x, float y, float z)
{
float da[4], pa[12];
voronoi(x, y, z, da, pa, 1, 0);
return (2.0f*da[2]-1.0f);
return (2.0f * da[2] - 1.0f);
}
static float voronoi_F4S(float x, float y, float z)
{
float da[4], pa[12];
voronoi(x, y, z, da, pa, 1, 0);
return (2.0f*da[3]-1.0f);
return (2.0f * da[3] - 1.0f);
}
static float voronoi_F1F2S(float x, float y, float z)
{
float da[4], pa[12];
voronoi(x, y, z, da, pa, 1, 0);
return (2.0f*(da[1]-da[0])-1.0f);
return (2.0f * (da[1] - da[0]) - 1.0f);
}
/* Crackle type pattern, just a scale/clamp of F2-F1 */
static float voronoi_CrS(float x, float y, float z)
{
float t = 10*voronoi_F1F2(x, y, z);
if (t>1.f) return 1.f;
return (2.0f*t-1.0f);
float t = 10 * voronoi_F1F2(x, y, z);
if (t > 1.f) return 1.f;
return (2.0f * t - 1.0f);
}
@@ -1352,15 +1359,15 @@ static float cellNoiseU(float x, float y, float z)
int xi = (int)(floor(x));
int yi = (int)(floor(y));
int zi = (int)(floor(z));
unsigned int n = xi + yi*1301 + zi*314159;
n ^= (n<<13);
return ((float)(n*(n*n*15731 + 789221) + 1376312589) / 4294967296.0f);
unsigned int n = xi + yi * 1301 + zi * 314159;
n ^= (n << 13);
return ((float)(n * (n * n * 15731 + 789221) + 1376312589) / 4294967296.0f);
}
/* idem, signed */
float cellNoise(float x, float y, float z)
{
return (2.0f*cellNoiseU(x, y, z)-1.0f);
return (2.0f * cellNoiseU(x, y, z) - 1.0f);
}
/* returns a vector/point/color in ca, using point hasharray directly */
@@ -1423,14 +1430,14 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
}
}
if (noisesize!=0.0f) {
noisesize = 1.0f/noisesize;
if (noisesize != 0.0f) {
noisesize = 1.0f / noisesize;
x *= noisesize;
y *= noisesize;
z *= noisesize;
}
if (hard) return fabsf(2.0f*noisefunc(x, y, z)-1.0f);
if (hard) return fabsf(2.0f * noisefunc(x, y, z) - 1.0f);
return noisefunc(x, y, z);
}
@@ -1438,7 +1445,7 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int hard, int noisebasis)
{
float (*noisefunc)(float, float, float);
float sum, t, amp=1, fscale=1;
float sum, t, amp = 1, fscale = 1;
int i;
switch (noisebasis) {
@@ -1477,21 +1484,21 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
z += 1;
}
if (noisesize!=0.0f) {
noisesize = 1.0f/noisesize;
if (noisesize != 0.0f) {
noisesize = 1.0f / noisesize;
x *= noisesize;
y *= noisesize;
z *= noisesize;
}
sum = 0;
for (i=0;i<=oct;i++, amp*=0.5f, fscale*=2.0f) {
t = noisefunc(fscale*x, fscale*y, fscale*z);
if (hard) t = fabsf(2.0f*t-1.0f);
for (i = 0; i <= oct; i++, amp *= 0.5f, fscale *= 2.0f) {
t = noisefunc(fscale * x, fscale * y, fscale * z);
if (hard) t = fabsf(2.0f * t - 1.0f);
sum += t * amp;
}
sum *= ((float)(1<<oct)/(float)((1<<(oct+1))-1));
sum *= ((float)(1 << oct) / (float)((1 << (oct + 1)) - 1));
return sum;
@@ -1513,8 +1520,8 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
*/
float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves, int noisebasis)
{
float rmd, value=0.0, pwr=1.0, pwHL=powf(lacunarity, -H);
int i;
float rmd, value = 0.0, pwr = 1.0, pwHL = powf(lacunarity, -H);
int i;
float (*noisefunc)(float, float, float);
switch (noisebasis) {
@@ -1551,7 +1558,7 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
}
}
for (i=0; i<(int)octaves; i++) {
for (i = 0; i < (int)octaves; i++) {
value += noisefunc(x, y, z) * pwr;
pwr *= pwHL;
x *= lacunarity;
@@ -1560,7 +1567,7 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
}
rmd = octaves - floorf(octaves);
if (rmd!=0.f) value += rmd * noisefunc(x, y, z) * pwr;
if (rmd != 0.f) value += rmd * noisefunc(x, y, z) * pwr;
return value;
@@ -1583,7 +1590,7 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
* I modified it to something that made sense to me, so it might be wrong... */
float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, int noisebasis)
{
float rmd, value=1.0, pwr=1.0, pwHL=powf(lacunarity, -H);
float rmd, value = 1.0, pwr = 1.0, pwHL = powf(lacunarity, -H);
int i;
float (*noisefunc)(float, float, float);
@@ -1621,7 +1628,7 @@ float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, floa
}
}
for (i=0; i<(int)octaves; i++) {
for (i = 0; i < (int)octaves; i++) {
value *= (pwr * noisefunc(x, y, z) + 1.0f);
pwr *= pwHL;
x *= lacunarity;
@@ -1629,7 +1636,7 @@ float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, floa
z *= lacunarity;
}
rmd = octaves - floorf(octaves);
if (rmd!=0.0f) value *= (rmd * noisefunc(x, y, z) * pwr + 1.0f);
if (rmd != 0.0f) value *= (rmd * noisefunc(x, y, z) * pwr + 1.0f);
return value;
@@ -1647,10 +1654,10 @@ float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, floa
*/
float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, float octaves, float offset, int noisebasis)
{
float value, increment, rmd;
float value, increment, rmd;
int i;
float pwHL = powf(lacunarity, -H);
float pwr = pwHL; /* starts with i=1 instead of 0 */
float pwr = pwHL; /* starts with i=1 instead of 0 */
float (*noisefunc)(float, float, float);
switch (noisebasis) {
@@ -1693,7 +1700,7 @@ float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, flo
y *= lacunarity;
z *= lacunarity;
for (i=1; i<(int)octaves; i++) {
for (i = 1; i < (int)octaves; i++) {
increment = (noisefunc(x, y, z) + offset) * pwr * value;
value += increment;
pwr *= pwHL;
@@ -1703,7 +1710,7 @@ float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, flo
}
rmd = octaves - floorf(octaves);
if (rmd!=0.0f) {
if (rmd != 0.0f) {
increment = (noisefunc(x, y, z) + offset) * pwr * value;
value += rmd * increment;
}
@@ -1723,7 +1730,7 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
float result, signal, weight, rmd;
int i;
float pwHL = powf(lacunarity, -H);
float pwr = pwHL; /* starts with i=1 instead of 0 */
float pwr = pwHL; /* starts with i=1 instead of 0 */
float (*noisefunc)(float, float, float);
switch (noisebasis) {
@@ -1766,8 +1773,8 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
y *= lacunarity;
z *= lacunarity;
for (i=1; (weight>0.001f) && (i<(int)octaves); i++) {
if (weight>1.0f) weight=1.0f;
for (i = 1; (weight > 0.001f) && (i < (int)octaves); i++) {
if (weight > 1.0f) weight = 1.0f;
signal = (noisefunc(x, y, z) + offset) * pwr;
pwr *= pwHL;
result += weight * signal;
@@ -1778,7 +1785,7 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
}
rmd = octaves - floorf(octaves);
if (rmd!=0.f) result += rmd * ((noisefunc(x, y, z) + offset) * pwr);
if (rmd != 0.f) result += rmd * ((noisefunc(x, y, z) + offset) * pwr);
return result;
@@ -1796,9 +1803,9 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, float offset, float gain, int noisebasis)
{
float result, signal, weight;
int i;
int i;
float pwHL = powf(lacunarity, -H);
float pwr = pwHL; /* starts with i=1 instead of 0 */
float pwr = pwHL; /* starts with i=1 instead of 0 */
float (*noisefunc)(float, float, float);
switch (noisebasis) {
@@ -1840,12 +1847,12 @@ float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity
result = signal;
for ( i=1; i<(int)octaves; i++ ) {
for (i = 1; i < (int)octaves; i++) {
x *= lacunarity;
y *= lacunarity;
z *= lacunarity;
weight = signal * gain;
if (weight>1.0f) weight=1.0f; else if (weight<0.0f) weight=0.0f;
if (weight > 1.0f) weight = 1.0f; else if (weight < 0.0f) weight = 0.0f;
signal = offset - fabsf(noisefunc(x, y, z));
signal *= signal;
signal *= weight;
@@ -1934,10 +1941,10 @@ float mg_VLNoise(float x, float y, float z, float distortion, int nbas1, int nba
}
/* get a random vector and scale the randomization */
rv[0] = noisefunc1(x+13.5f, y+13.5f, z+13.5f) * distortion;
rv[0] = noisefunc1(x + 13.5f, y + 13.5f, z + 13.5f) * distortion;
rv[1] = noisefunc1(x, y, z) * distortion;
rv[2] = noisefunc1(x-13.5f, y-13.5f, z-13.5f) * distortion;
return noisefunc2(x+rv[0], y+rv[1], z+rv[2]); /* distorted-domain noise */
rv[2] = noisefunc1(x - 13.5f, y - 13.5f, z - 13.5f) * distortion;
return noisefunc2(x + rv[0], y + rv[1], z + rv[2]); /* distorted-domain noise */
}
/****************/

58
source/blender/blenlib/intern/rand.c
View File

@@ -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<n; i++)
for (i = 0; i < n; i++)
rng_getInt(rng);
}
@@ -177,10 +177,10 @@ float BLI_frand(void)
void BLI_fillrand(void *addr, int len)
{
RNG rng;
unsigned char *p= addr;
unsigned char *p = addr;
rng_seed(&rng, (unsigned int) (PIL_check_seconds_timer()*0x7FFFFFFF));
while (len--) *p++= rng_getInt(&rng)&0xFF;
rng_seed(&rng, (unsigned int) (PIL_check_seconds_timer() * 0x7FFFFFFF));
while (len--) *p++ = rng_getInt(&rng) & 0xFF;
}
void BLI_array_randomize(void *data, int elemSize, int numElems, unsigned int seed)
@@ -198,12 +198,12 @@ static RNG rng_tab[BLENDER_MAX_THREADS];
void BLI_thread_srandom(int thread, unsigned int seed)
{
if (thread >= BLENDER_MAX_THREADS)
thread= 0;
thread = 0;
rng_seed(&rng_tab[thread], seed + hash[seed & 255]);
seed= rng_getInt(&rng_tab[thread]);
seed = rng_getInt(&rng_tab[thread]);
rng_seed(&rng_tab[thread], seed + hash[seed & 255]);
seed= rng_getInt(&rng_tab[thread]);
seed = rng_getInt(&rng_tab[thread]);
rng_seed(&rng_tab[thread], seed + hash[seed & 255]);
}

22
source/blender/blenlib/intern/smallhash.c
View File

@@ -40,8 +40,8 @@
*
* note: these have the SMHASH suffix because we may want to make them public.
*/
#define SMHASH_CELL_UNUSED ((void *)0x7FFFFFFF)
#define SMHASH_CELL_FREE ((void *)0x7FFFFFFD)
#define SMHASH_CELL_UNUSED ((void *)0x7FFFFFFF)
#define SMHASH_CELL_FREE ((void *)0x7FFFFFFD)
#define SMHASH_NONZERO(n) ((n) + !(n))
#define SMHASH_NEXT(h, hoff) ABS(((h) + ((hoff = SMHASH_NONZERO(hoff * 2) + 1), hoff)))
@@ -80,7 +80,7 @@ void BLI_smallhash_release(SmallHash *hash)
void BLI_smallhash_insert(SmallHash *hash, uintptr_t key, void *item)
{
int h, hoff=1;
int h, hoff = 1;
if (hash->size < hash->used * 3) {
int newsize = hashsizes[++hash->curhash];
@@ -103,7 +103,7 @@ void BLI_smallhash_insert(SmallHash *hash, uintptr_t key, void *item)
hash->table[i].val = SMHASH_CELL_FREE;
}
for (i = 0; i<hashsizes[hash->curhash - 1]; i++) {
for (i = 0; i < hashsizes[hash->curhash - 1]; i++) {
if (ELEM(tmp[i].val, SMHASH_CELL_UNUSED, SMHASH_CELL_FREE)) {
continue;
}
@@ -141,7 +141,7 @@ void BLI_smallhash_insert(SmallHash *hash, uintptr_t key, void *item)
void BLI_smallhash_remove(SmallHash *hash, uintptr_t key)
{
int h, hoff=1;
int h, hoff = 1;
h = ABS((int)key);
@@ -162,7 +162,7 @@ void BLI_smallhash_remove(SmallHash *hash, uintptr_t key)
void *BLI_smallhash_lookup(SmallHash *hash, uintptr_t key)
{
int h, hoff=1;
int h, hoff = 1;
void *v;
h = ABS((int)key);
@@ -193,7 +193,7 @@ void *BLI_smallhash_lookup(SmallHash *hash, uintptr_t key)
int BLI_smallhash_haskey(SmallHash *hash, uintptr_t key)
{
int h = ABS((int)key);
int hoff =1;
int hoff = 1;
if (hash->table == NULL) {
return 0;
@@ -251,21 +251,21 @@ void *BLI_smallhash_iternew(SmallHash *hash, SmallHashIter *iter, uintptr_t *key
#if 0
void BLI_smallhash_print(SmallHash *hash)
{
int i, linecol=79, c=0;
int i, linecol = 79, c = 0;
printf("{");
for (i=0; i<hash->size; i++) {
for (i = 0; i < hash->size; i++) {
if (hash->table[i].val == SMHASH_CELL_UNUSED) {
printf("--u-");
}
else if (hash->table[i].val == SMHASH_CELL_FREE) {
printf("--f-");
}
else {
else {
printf("%2x", (unsigned int)hash->table[i].key);
}
if (i != hash->size-1)
if (i != hash->size - 1)
printf(", ");
c += 6;

156
source/blender/blenlib/intern/storage.c
View File

@@ -43,13 +43,13 @@
#include <time.h>
#include <sys/stat.h>
#if defined (__sun__) || defined (__sun) || defined (__NetBSD__)
#if defined(__sun__) || defined(__sun) || defined(__NetBSD__)
#include <sys/statvfs.h> /* Other modern unix os's should probably use this also */
#elif !defined(__FreeBSD__) && !defined(linux) && (defined(__sparc) || defined(__sparc__))
#include <sys/statfs.h>
#endif
#if defined (__FreeBSD__) || defined (__OpenBSD__)
#if defined(__FreeBSD__) || defined(__OpenBSD__)
#include <sys/param.h>
#include <sys/mount.h>
#endif
@@ -66,7 +66,7 @@
#include <fcntl.h>
#include <string.h> /* strcpy etc.. */
#include <string.h> /* strcpy etc.. */
#ifdef WIN32
# include <io.h>
@@ -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, &sectorspc, &bytesps, &freec, &clusters);
return (double) (freec*bytesps*sectorspc);
return (double) (freec * bytesps * sectorspc);
#else
#if defined (__sun__) || defined (__sun) || defined (__NetBSD__)
#if defined(__sun__) || defined(__sun) || defined(__NetBSD__)
struct statvfs disk;
#else
struct statfs disk;
@@ -185,11 +185,11 @@ double BLI_dir_free_space(const char *dir)
}
else strcpy(name, "/");
#if defined (__FreeBSD__) || defined (linux) || defined (__OpenBSD__) || defined (__APPLE__) || defined(__GNU__) || defined(__GLIBC__)
#if defined(__FreeBSD__) || defined(linux) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__GNU__) || defined(__GLIBC__)
if (statfs(name, &disk)) return(-1);
#endif
#if defined (__sun__) || defined (__sun) || defined (__NetBSD__)
#if defined(__sun__) || defined(__sun) || defined(__NetBSD__)
if (statvfs(name, &disk)) return(-1);
#elif !defined(__FreeBSD__) && !defined(linux) && (defined(__sparc) || defined(__sparc__))
/* WARNING - This may not be supported by geeneric unix os's - Campbell */
@@ -209,10 +209,10 @@ static void bli_builddir(const char *dirname, const char *relname)
DIR *dir;
BLI_strncpy(buf, relname, sizeof(buf));
rellen=strlen(relname);
rellen = strlen(relname);
if (rellen) {
buf[rellen]='/';
buf[rellen] = '/';
rellen++;
}
#ifndef WIN32
@@ -231,7 +231,7 @@ static void bli_builddir(const char *dirname, const char *relname)
#endif
if ((dir = (DIR *)opendir("."))) {
while ((fname = (struct dirent*) readdir(dir)) != NULL) {
while ((fname = (struct dirent *) readdir(dir)) != NULL) {
dlink = (struct dirlink *)malloc(sizeof(struct dirlink));
if (dlink) {
BLI_strncpy(buf + rellen, fname->d_name, sizeof(buf) - rellen);
@@ -244,7 +244,7 @@ static void bli_builddir(const char *dirname, const char *relname)
if (newnum) {
if (files) {
void *tmp = realloc(files, (totnum+newnum) * sizeof(struct direntry));
void *tmp = realloc(files, (totnum + newnum) * sizeof(struct direntry));
if (tmp) {
files = (struct direntry *)tmp;
}
@@ -254,8 +254,8 @@ static void bli_builddir(const char *dirname, const char *relname)
}
}
if (files==NULL)
files=(struct direntry *)malloc(newnum * sizeof(struct direntry));
if (files == NULL)
files = (struct direntry *)malloc(newnum * sizeof(struct direntry));
if (files) {
dlink = (struct dirlink *) dirbase->first;
@@ -266,18 +266,20 @@ static void bli_builddir(const char *dirname, const char *relname)
// use 64 bit file size, only needed for WIN32 and WIN64.
// Excluding other than current MSVC compiler until able to test
#ifdef WIN32
{wchar_t * name_16 = alloc_utf16_from_8(dlink->name, 0);
#if (defined(WIN32) || defined(WIN64)) && (_MSC_VER>=1500)
_wstat64(name_16, &files[actnum].s);
{
wchar_t *name_16 = alloc_utf16_from_8(dlink->name, 0);
#if (defined(WIN32) || defined(WIN64)) && (_MSC_VER >= 1500)
_wstat64(name_16, &files[actnum].s);
#elif defined(__MINGW32__)
_stati64(dlink->name, &files[actnum].s);
_stati64(dlink->name, &files[actnum].s);
#endif
free(name_16);};
free(name_16);
}
#else
stat(dlink->name, &files[actnum].s);
#endif
files[actnum].type=files[actnum].s.st_mode;
files[actnum].type = files[actnum].s.st_mode;
files[actnum].flags = 0;
totnum++;
actnum++;
@@ -290,7 +292,7 @@ static void bli_builddir(const char *dirname, const char *relname)
}
BLI_freelist(dirbase);
if (files) qsort(files, actnum, sizeof(struct direntry), (int (*)(const void *, const void*))bli_compare);
if (files) qsort(files, actnum, sizeof(struct direntry), (int (*)(const void *, const void *))bli_compare);
}
else {
printf("%s empty directory\n", dirname);
@@ -308,7 +310,7 @@ static void bli_adddirstrings(void)
char datum[100];
char buf[512];
char size[250];
static const char * types[8] = {"---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"};
static const char *types[8] = {"---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"};
int num, mode;
#ifdef WIN32
__int64 st_size;
@@ -316,11 +318,11 @@ static void bli_adddirstrings(void)
off_t st_size;
#endif
struct direntry * file;
struct direntry *file;
struct tm *tm;
time_t zero= 0;
time_t zero = 0;
for (num=0, file= files; num<actnum; num++, file++) {
for (num = 0, file = files; num < actnum; num++, file++) {
#ifdef WIN32
mode = 0;
BLI_strncpy(file->mode1, types[0], sizeof(file->mode1));
@@ -333,13 +335,13 @@ static void bli_adddirstrings(void)
BLI_strncpy(file->mode2, types[(mode & 0070) >> 3], sizeof(file->mode2));
BLI_strncpy(file->mode3, types[(mode & 0007)], sizeof(file->mode3));
if (((mode & S_ISGID) == S_ISGID) && (file->mode2[2]=='-'))file->mode2[2]='l';
if (((mode & S_ISGID) == S_ISGID) && (file->mode2[2] == '-')) file->mode2[2] = 'l';
if (mode & (S_ISUID | S_ISGID)) {
if (file->mode1[2]=='x') file->mode1[2]='s';
else file->mode1[2]='S';
if (file->mode1[2] == 'x') file->mode1[2] = 's';
else file->mode1[2] = 'S';
if (file->mode2[2]=='x')file->mode2[2]='s';
if (file->mode2[2] == 'x') file->mode2[2] = 's';
}
if (mode & S_ISVTX) {
@@ -354,7 +356,7 @@ static void bli_adddirstrings(void)
{
struct passwd *pwuser;
pwuser = getpwuid(file->s.st_uid);
if ( pwuser ) {
if (pwuser) {
BLI_strncpy(file->owner, pwuser->pw_name, sizeof(file->owner));
}
else {
@@ -363,9 +365,9 @@ static void bli_adddirstrings(void)
}
#endif
tm= localtime(&file->s.st_mtime);
tm = localtime(&file->s.st_mtime);
// prevent impossible dates in windows
if (tm==NULL) tm= localtime(&zero);
if (tm == NULL) tm = localtime(&zero);
strftime(file->time, sizeof(file->time), "%H:%M", tm);
strftime(file->date, sizeof(file->date), "%d-%b-%y", tm);
@@ -374,16 +376,16 @@ static void bli_adddirstrings(void)
* will buy us some time until files get bigger than 4GB or until
* everyone starts using __USE_FILE_OFFSET64 or equivalent.
*/
st_size= file->s.st_size;
st_size = file->s.st_size;
if (st_size > 1024*1024*1024) {
BLI_snprintf(file->size, sizeof(file->size), "%.2f GB", ((double)st_size)/(1024*1024*1024));
if (st_size > 1024 * 1024 * 1024) {
BLI_snprintf(file->size, sizeof(file->size), "%.2f GB", ((double)st_size) / (1024 * 1024 * 1024));
}
else if (st_size > 1024*1024) {
BLI_snprintf(file->size, sizeof(file->size), "%.1f MB", ((double)st_size)/(1024*1024));
else if (st_size > 1024 * 1024) {
BLI_snprintf(file->size, sizeof(file->size), "%.1f MB", ((double)st_size) / (1024 * 1024));
}
else if (st_size > 1024) {
BLI_snprintf(file->size, sizeof(file->size), "%d KB", (int)(st_size/1024));
BLI_snprintf(file->size, sizeof(file->size), "%d KB", (int)(st_size / 1024));
}
else {
BLI_snprintf(file->size, sizeof(file->size), "%d B", (int)st_size);
@@ -401,7 +403,7 @@ static void bli_adddirstrings(void)
}
else if (st_size < 100 * 1000 * 1000) {
BLI_snprintf(size, sizeof(size), "%2d %03d %03d",
(int) (st_size / (1000 * 1000)), (int) ((st_size / 1000) % 1000), (int) ( st_size % 1000));
(int) (st_size / (1000 * 1000)), (int) ((st_size / 1000) % 1000), (int) (st_size % 1000));
}
else {
/* XXX, whats going on here?. 2x calls - campbell */
@@ -447,13 +449,13 @@ size_t BLI_file_descriptor_size(int file)
struct stat buf;
if (file <= 0) return (-1);
fstat(file, &buf);//CHANGE
fstat(file, &buf); /* CHANGE */
return (buf.st_size);
}
size_t BLI_file_size(const char *path)
{
int size, file = BLI_open(path, O_BINARY|O_RDONLY, 0);
int size, file = BLI_open(path, O_BINARY | O_RDONLY, 0);
if (file == -1)
return -1;
@@ -475,10 +477,10 @@ int BLI_exists(const char *name)
/* in Windows stat doesn't recognize dir ending on a slash
* To not break code where the ending slash is expected we
* don't mess with the argument name directly here - elubie */
wchar_t * tmp_16 = alloc_utf16_from_8(name, 0);
wchar_t *tmp_16 = alloc_utf16_from_8(name, 0);
int len, res;
len = wcslen(tmp_16);
if (len > 3 && ( tmp_16[len-1]==L'\\' || tmp_16[len-1]==L'/') ) tmp_16[len-1] = '\0';
if (len > 3 && (tmp_16[len - 1] == L'\\' || tmp_16[len - 1] == L'/') ) tmp_16[len - 1] = '\0';
#ifndef __MINGW32__
res = _wstat(tmp_16, &st);
#else
@@ -499,7 +501,7 @@ int BLI_stat(const char *path, struct stat *buffer)
{
int r;
UTF16_ENCODE(path);
r=_wstat(path_16,buffer);
r = _wstat(path_16, buffer);
UTF16_UN_ENCODE(path);
return r;
}
@@ -518,39 +520,39 @@ int BLI_is_dir(const char *file)
int BLI_is_file(const char *path)
{
int mode= BLI_exists(path);
int mode = BLI_exists(path);
return (mode && !S_ISDIR(mode));
}
LinkNode *BLI_file_read_as_lines(const char *name)
{
FILE *fp= BLI_fopen(name, "r");
LinkNode *lines= NULL;
FILE *fp = BLI_fopen(name, "r");
LinkNode *lines = NULL;
char *buf;
size_t size;
if (!fp) return NULL;
fseek(fp, 0, SEEK_END);
size= (size_t)ftell(fp);
size = (size_t)ftell(fp);
fseek(fp, 0, SEEK_SET);
buf= MEM_mallocN(size, "file_as_lines");
buf = MEM_mallocN(size, "file_as_lines");
if (buf) {
size_t i, last= 0;
size_t i, last = 0;
/*
* size = because on win32 reading
* all the bytes in the file will return
* less bytes because of crnl changes.
*/
size= fread(buf, 1, size, fp);
for (i=0; i<=size; i++) {
if (i==size || buf[i]=='\n') {
char *line= BLI_strdupn(&buf[last], i-last);
/*
* size = because on win32 reading
* all the bytes in the file will return
* less bytes because of crnl changes.
*/
size = fread(buf, 1, size, fp);
for (i = 0; i <= size; i++) {
if (i == size || buf[i] == '\n') {
char *line = BLI_strdupn(&buf[last], i - last);
BLI_linklist_prepend(&lines, line);
last= i+1;
last = i + 1;
}
}
@@ -565,7 +567,7 @@ LinkNode *BLI_file_read_as_lines(const char *name)
void BLI_file_free_lines(LinkNode *lines)
{
BLI_linklist_free(lines, (void(*)(void*)) MEM_freeN);
BLI_linklist_free(lines, (void (*)(void *))MEM_freeN);
}
/** is file1 older then file2 */

128
source/blender/blenlib/intern/threads.c
View File

@@ -114,7 +114,7 @@ static pthread_mutex_t _opengl_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t _nodes_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t _movieclip_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_t mainid;
static int thread_levels= 0; /* threads can be invoked inside threads */
static int thread_levels = 0; /* threads can be invoked inside threads */
/* just a max for security reasons */
#define RE_MAX_THREAD BLENDER_MAX_THREADS
@@ -151,16 +151,16 @@ void BLI_init_threads(ListBase *threadbase, void *(*do_thread)(void *), int tot)
int a;
if (threadbase != NULL && tot > 0) {
threadbase->first= threadbase->last= NULL;
threadbase->first = threadbase->last = NULL;
if (tot>RE_MAX_THREAD) tot= RE_MAX_THREAD;
else if (tot<1) tot= 1;
if (tot > RE_MAX_THREAD) tot = RE_MAX_THREAD;
else if (tot < 1) tot = 1;
for (a=0; a<tot; a++) {
ThreadSlot *tslot= MEM_callocN(sizeof(ThreadSlot), "threadslot");
for (a = 0; a < tot; a++) {
ThreadSlot *tslot = MEM_callocN(sizeof(ThreadSlot), "threadslot");
BLI_addtail(threadbase, tslot);
tslot->do_thread= do_thread;
tslot->avail= 1;
tslot->do_thread = do_thread;
tslot->avail = 1;
}
}
@@ -182,9 +182,9 @@ void BLI_init_threads(ListBase *threadbase, void *(*do_thread)(void *), int tot)
int BLI_available_threads(ListBase *threadbase)
{
ThreadSlot *tslot;
int counter=0;
int counter = 0;
for (tslot= threadbase->first; tslot; tslot= tslot->next) {
for (tslot = threadbase->first; tslot; tslot = tslot->next) {
if (tslot->avail)
counter++;
}
@@ -195,9 +195,9 @@ int BLI_available_threads(ListBase *threadbase)
int BLI_available_thread_index(ListBase *threadbase)
{
ThreadSlot *tslot;
int counter=0;
int counter = 0;
for (tslot= threadbase->first; tslot; tslot= tslot->next, counter++) {
for (tslot = threadbase->first; tslot; tslot = tslot->next, counter++) {
if (tslot->avail)
return counter;
}
@@ -206,12 +206,12 @@ int BLI_available_thread_index(ListBase *threadbase)
static void *tslot_thread_start(void *tslot_p)
{
ThreadSlot *tslot= (ThreadSlot*)tslot_p;
ThreadSlot *tslot = (ThreadSlot *)tslot_p;
#if defined(__APPLE__) && (PARALLEL == 1) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
/* workaround for Apple gcc 4.2.1 omp vs background thread bug,
* set gomp thread local storage pointer which was copied beforehand */
pthread_setspecific (gomp_tls_key, thread_tls_data);
pthread_setspecific(gomp_tls_key, thread_tls_data);
#endif
return tslot->do_thread(tslot->callerdata);
@@ -226,10 +226,10 @@ void BLI_insert_thread(ListBase *threadbase, void *callerdata)
{
ThreadSlot *tslot;
for (tslot= threadbase->first; tslot; tslot= tslot->next) {
for (tslot = threadbase->first; tslot; tslot = tslot->next) {
if (tslot->avail) {
tslot->avail= 0;
tslot->callerdata= callerdata;
tslot->avail = 0;
tslot->callerdata = callerdata;
pthread_create(&tslot->pthread, NULL, tslot_thread_start, tslot);
return;
}
@@ -241,11 +241,11 @@ void BLI_remove_thread(ListBase *threadbase, void *callerdata)
{
ThreadSlot *tslot;
for (tslot= threadbase->first; tslot; tslot= tslot->next) {
if (tslot->callerdata==callerdata) {
for (tslot = threadbase->first; tslot; tslot = tslot->next) {
if (tslot->callerdata == callerdata) {
pthread_join(tslot->pthread, NULL);
tslot->callerdata= NULL;
tslot->avail= 1;
tslot->callerdata = NULL;
tslot->avail = 1;
}
}
}
@@ -253,7 +253,7 @@ void BLI_remove_thread(ListBase *threadbase, void *callerdata)
void BLI_remove_thread_index(ListBase *threadbase, int index)
{
ThreadSlot *tslot;
int counter=0;
int counter = 0;
for (tslot = threadbase->first; tslot; tslot = tslot->next, counter++) {
if (counter == index && tslot->avail == 0) {
@@ -286,8 +286,8 @@ void BLI_end_threads(ListBase *threadbase)
* this way we don't end up decrementing thread_levels on an empty threadbase
* */
if (threadbase && threadbase->first != NULL) {
for (tslot= threadbase->first; tslot; tslot= tslot->next) {
if (tslot->avail==0) {
for (tslot = threadbase->first; tslot; tslot = tslot->next) {
if (tslot->avail == 0) {
pthread_join(tslot->pthread, NULL);
}
}
@@ -295,7 +295,7 @@ void BLI_end_threads(ListBase *threadbase)
}
thread_levels--;
if (thread_levels==0)
if (thread_levels == 0)
MEM_set_lock_callback(NULL, NULL);
}
@@ -310,7 +310,7 @@ int BLI_system_thread_count(void)
GetSystemInfo(&info);
t = (int) info.dwNumberOfProcessors;
#else
# ifdef __APPLE__
# ifdef __APPLE__
int mib[2];
size_t len;
@@ -318,14 +318,14 @@ int BLI_system_thread_count(void)
mib[1] = HW_NCPU;
len = sizeof(t);
sysctl(mib, 2, &t, &len, NULL, 0);
# else
# else
t = (int)sysconf(_SC_NPROCESSORS_ONLN);
# endif
# endif
#endif
if (t>RE_MAX_THREAD)
if (t > RE_MAX_THREAD)
return RE_MAX_THREAD;
if (t<1)
if (t < 1)
return 1;
return t;
@@ -335,41 +335,41 @@ int BLI_system_thread_count(void)
void BLI_lock_thread(int type)
{
if (type==LOCK_IMAGE)
if (type == LOCK_IMAGE)
pthread_mutex_lock(&_image_lock);
else if (type==LOCK_PREVIEW)
else if (type == LOCK_PREVIEW)
pthread_mutex_lock(&_preview_lock);
else if (type==LOCK_VIEWER)
else if (type == LOCK_VIEWER)
pthread_mutex_lock(&_viewer_lock);
else if (type==LOCK_CUSTOM1)
else if (type == LOCK_CUSTOM1)
pthread_mutex_lock(&_custom1_lock);
else if (type==LOCK_RCACHE)
else if (type == LOCK_RCACHE)
pthread_mutex_lock(&_rcache_lock);
else if (type==LOCK_OPENGL)
else if (type == LOCK_OPENGL)
pthread_mutex_lock(&_opengl_lock);
else if (type==LOCK_NODES)
else if (type == LOCK_NODES)
pthread_mutex_lock(&_nodes_lock);
else if (type==LOCK_MOVIECLIP)
else if (type == LOCK_MOVIECLIP)
pthread_mutex_lock(&_movieclip_lock);
}
void BLI_unlock_thread(int type)
{
if (type==LOCK_IMAGE)
if (type == LOCK_IMAGE)
pthread_mutex_unlock(&_image_lock);
else if (type==LOCK_PREVIEW)
else if (type == LOCK_PREVIEW)
pthread_mutex_unlock(&_preview_lock);
else if (type==LOCK_VIEWER)
else if (type == LOCK_VIEWER)
pthread_mutex_unlock(&_viewer_lock);
else if (type==LOCK_CUSTOM1)
else if (type == LOCK_CUSTOM1)
pthread_mutex_unlock(&_custom1_lock);
else if (type==LOCK_RCACHE)
else if (type == LOCK_RCACHE)
pthread_mutex_unlock(&_rcache_lock);
else if (type==LOCK_OPENGL)
else if (type == LOCK_OPENGL)
pthread_mutex_unlock(&_opengl_lock);
else if (type==LOCK_NODES)
else if (type == LOCK_NODES)
pthread_mutex_unlock(&_nodes_lock);
else if (type==LOCK_MOVIECLIP)
else if (type == LOCK_MOVIECLIP)
pthread_mutex_unlock(&_movieclip_lock);
}
@@ -425,20 +425,20 @@ void BLI_rw_mutex_end(ThreadRWMutex *mutex)
typedef struct ThreadedWorker {
ListBase threadbase;
void *(*work_fnct)(void *);
char busy[RE_MAX_THREAD];
int total;
int sleep_time;
char busy[RE_MAX_THREAD];
int total;
int sleep_time;
} ThreadedWorker;
typedef struct WorkParam {
ThreadedWorker *worker;
void *param;
int index;
int index;
} WorkParam;
static void *exec_work_fnct(void *v_param)
{
WorkParam *p = (WorkParam*)v_param;
WorkParam *p = (WorkParam *)v_param;
void *value;
value = p->worker->work_fnct(p->param);
@@ -461,7 +461,7 @@ ThreadedWorker *BLI_create_worker(void *(*do_thread)(void *), int tot, int sleep
tot = RE_MAX_THREAD;
}
else if (tot < 1) {
tot= 1;
tot = 1;
}
worker->total = tot;
@@ -528,8 +528,8 @@ ThreadQueue *BLI_thread_queue_init(void)
{
ThreadQueue *queue;
queue= MEM_callocN(sizeof(ThreadQueue), "ThreadQueue");
queue->queue= BLI_gsqueue_new(sizeof(void*));
queue = MEM_callocN(sizeof(ThreadQueue), "ThreadQueue");
queue->queue = BLI_gsqueue_new(sizeof(void *));
pthread_mutex_init(&queue->mutex, NULL);
pthread_cond_init(&queue->cond, NULL);
@@ -560,7 +560,7 @@ void BLI_thread_queue_push(ThreadQueue *queue, void *work)
void *BLI_thread_queue_pop(ThreadQueue *queue)
{
void *work= NULL;
void *work = NULL;
/* wait until there is work */
pthread_mutex_lock(&queue->mutex);
@@ -586,7 +586,7 @@ static void wait_timeout(struct timespec *timeout, int ms)
struct _timeb now;
_ftime(&now);
sec = now.time;
usec = now.millitm*1000; /* microsecond precision would be better */
usec = now.millitm * 1000; /* microsecond precision would be better */
}
#else
{
@@ -601,23 +601,23 @@ static void wait_timeout(struct timespec *timeout, int ms)
div_result = ldiv(ms, 1000);
timeout->tv_sec = sec + div_result.quot;
x = usec + (div_result.rem*1000);
x = usec + (div_result.rem * 1000);
if (x >= 1000000) {
timeout->tv_sec++;
x -= 1000000;
}
timeout->tv_nsec = x*1000;
timeout->tv_nsec = x * 1000;
}
void *BLI_thread_queue_pop_timeout(ThreadQueue *queue, int ms)
{
double t;
void *work= NULL;
void *work = NULL;
struct timespec timeout;
t= PIL_check_seconds_timer();
t = PIL_check_seconds_timer();
wait_timeout(&timeout, ms);
/* wait until there is work */
@@ -625,7 +625,7 @@ void *BLI_thread_queue_pop_timeout(ThreadQueue *queue, int ms)
while (BLI_gsqueue_is_empty(queue->queue) && !queue->nowait) {
if (pthread_cond_timedwait(&queue->cond, &queue->mutex, &timeout) == ETIMEDOUT)
break;
else if (PIL_check_seconds_timer() - t >= ms*0.001)
else if (PIL_check_seconds_timer() - t >= ms * 0.001)
break;
}
@@ -643,7 +643,7 @@ int BLI_thread_queue_size(ThreadQueue *queue)
int size;
pthread_mutex_lock(&queue->mutex);
size= BLI_gsqueue_size(queue->queue);
size = BLI_gsqueue_size(queue->queue);
pthread_mutex_unlock(&queue->mutex);
return size;
@@ -653,7 +653,7 @@ void BLI_thread_queue_nowait(ThreadQueue *queue)
{
pthread_mutex_lock(&queue->mutex);
queue->nowait= 1;
queue->nowait = 1;
/* signal threads waiting to pop */
pthread_cond_signal(&queue->cond);
@@ -671,6 +671,6 @@ void BLI_begin_threaded_malloc(void)
void BLI_end_threaded_malloc(void)
{
thread_levels--;
if (thread_levels==0)
if (thread_levels == 0)
MEM_set_lock_callback(NULL, NULL);
}

126
source/blender/blenloader/intern/readblenentry.c
View File

@@ -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);

44
source/blender/blenloader/intern/undofile.c
View File

@@ -56,11 +56,11 @@ void BLO_free_memfile(MemFile *memfile)
MemFileChunk *chunk;
while ( (chunk = (memfile->chunks.first) ) ) {
if (chunk->ident==0) MEM_freeN(chunk->buf);
if (chunk->ident == 0) MEM_freeN(chunk->buf);
BLI_remlink(&memfile->chunks, chunk);
MEM_freeN(chunk);
}
memfile->size= 0;
memfile->size = 0;
}
/* to keep list of memfiles consistent, 'first' is always first in list */
@@ -69,17 +69,17 @@ void BLO_merge_memfile(MemFile *first, MemFile *second)
{
MemFileChunk *fc, *sc;
fc= first->chunks.first;
sc= second->chunks.first;
fc = first->chunks.first;
sc = second->chunks.first;
while (fc || sc) {
if (fc && sc) {
if (sc->ident) {
sc->ident= 0;
fc->ident= 1;
sc->ident = 0;
fc->ident = 1;
}
}
if (fc) fc= fc->next;
if (sc) sc= sc->next;
if (fc) fc = fc->next;
if (sc) sc = sc->next;
}
BLO_free_memfile(first);
@@ -92,7 +92,7 @@ static int my_memcmp(const int *mem1, const int *mem2, const int len)
register const int *memb = mem2;
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(&current->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;
}

790
source/blender/makesdna/intern/dna_genfile.c
View File

@@ -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; a<len; a++) {
if ( str[a]== '[' ) {
cp= &(str[a+1]);
for (a = 0; a < len; a++) {
if (str[a] == '[') {
cp = &(str[a + 1]);
}
else if ( str[a]==']' && cp) {
str[a]= 0;
mul*= atoi(cp);
else if (str[a] == ']' && cp) {
str[a] = 0;
mul *= atoi(cp);
}
}
@@ -210,7 +210,7 @@ void DNA_sdna_free(SDNA *sdna)
static int ispointer(const char *name)
{
/* check if pointer or function pointer */
return (name[0]=='*' || (name[0]=='(' && name[1]=='*'));
return (name[0] == '*' || (name[0] == '(' && name[1] == '*'));
}
static int elementsize(SDNA *sdna, short type, short name)
@@ -219,24 +219,24 @@ static int elementsize(SDNA *sdna, short type, short name)
int mul, namelen, len;
const char *cp;
cp= sdna->names[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; a<sdna->nr_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->lastfind<sdna->nr_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; a<sdna->nr_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 (nr<sdna->nr_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 (nr<sdna->nr_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 (nr<sdna->nr_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; nr<sdna->nr_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; 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] ];
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; a<sdna->nr_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; a<sdna->nr_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; a<sdna->nr_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; 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;
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; a<elemcount; a++, old+=2) {
otype= oldsdna->types[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; a<elemcount; a++, spc+=2) {
type= newsdna->types[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; a<elemcount; a++, spc+=2) {
type= oldsdna->types[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; a<blocks; a++) {
cur = MEM_callocN(blocks * curlen, "reconstruct");
cpc = cur;
cpo = data;
for (a = 0; a < blocks; a++) {
reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc);
cpc+= curlen;
cpo+= oldlen;
cpc += curlen;
cpo += oldlen;
}
return cur;
@@ -1153,9 +1153,9 @@ void *DNA_struct_reconstruct(SDNA *newsdna, SDNA *oldsdna, char *compflags, int
int DNA_elem_offset(SDNA *sdna, const char *stype, const char *vartype, const char *name)
{
int SDNAnr= DNA_struct_find_nr(sdna, stype);
short *spo= sdna->structs[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);
}

492
source/blender/makesdna/intern/makesdna.c
View File

@@ -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<nr_types; nr++) {
if (strcmp(str, types[nr])==0) {
for (nr = 0; nr < nr_types; nr++) {
if (strcmp(str, types[nr]) == 0) {
if (len) {
typelens[nr]= len;
typelens[nr] = len;
alphalens[nr] = len;
}
return nr;
@@ -249,22 +249,22 @@ static int add_type(const char *str, int len)
}
/* append new type */
if (nr_types==0) cp= typedata;
if (nr_types == 0) cp = typedata;
else {
cp= types[nr_types-1]+strlen(types[nr_types-1])+1;
cp = types[nr_types - 1] + strlen(types[nr_types - 1]) + 1;
}
strcpy(cp, str);
types[nr_types]= cp;
typelens[nr_types]= len;
alphalens[nr_types]= len;
types[nr_types] = cp;
typelens[nr_types] = len;
alphalens[nr_types] = len;
if (nr_types>=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<nr_names; nr++) {
if (strcmp(name, names[nr])==0) {
for (nr = 0; nr < nr_names; nr++) {
if (strcmp(name, names[nr]) == 0) {
return nr;
}
}
/* append new type */
if (nr_names==0) cp= namedata;
if (nr_names == 0) cp = namedata;
else {
cp= names[nr_names-1]+strlen(names[nr_names-1])+1;
cp = names[nr_names - 1] + strlen(names[nr_names - 1]) + 1;
}
strcpy(cp, name);
names[nr_names]= cp;
names[nr_names] = cp;
if (nr_names>=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<filelen) {
count = 0;
overslaan = 0;
while (count < filelen) {
/* code for skipping a struct: two hashes on 2 lines. (preprocess added a space) */
if (md[0]=='#' && md[1]==' ' && md[2]=='#') {
overslaan= 1;
if (md[0] == '#' && md[1] == ' ' && md[2] == '#') {
overslaan = 1;
}
if (md[0]=='{') {
md[0]= 0;
if (md[0] == '{') {
md[0] = 0;
if (overslaan) {
overslaan= 0;
overslaan = 0;
}
else {
if (md[-1]==' ') md[-1]= 0;
md1= md-2;
while ( *md1!=32) md1--; /* to beginning of word */
if (md[-1] == ' ') md[-1] = 0;
md1 = md - 2;
while (*md1 != 32) md1--; /* to beginning of word */
md1++;
/* we've got a struct name when... */
if ( strncmp(md1-7, "struct", 6)==0 ) {
if (strncmp(md1 - 7, "struct", 6) == 0) {
strct = add_type(md1, 0);
if (strct == -1) {
@@ -590,33 +590,33 @@ static int convert_include(char *filename)
return 1;
}
structpoin= add_struct(strct);
sp= structpoin+2;
structpoin = add_struct(strct);
sp = structpoin + 2;
if (debugSDNA > 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<len; a++) {
if ( str[a]== '[' ) {
cp= &(str[a+1]);
for (a = 0; a < len; a++) {
if (str[a] == '[') {
cp = &(str[a + 1]);
}
else if ( str[a]==']' && cp) {
str[a]= 0;
else if (str[a] == ']' && cp) {
str[a] = 0;
/* if 'cp' is a preprocessor definition, it will evaluate to 0,
* the caller needs to check for this case and throw an error */
mul*= atoi(cp);
* the caller needs to check for this case and throw an error */
mul *= atoi(cp);
}
}
@@ -711,40 +711,40 @@ static int arraysize(char *astr, int len)
static int calculate_structlens(int firststruct)
{
int a, b, len, alphalen, unknown= nr_structs, lastunknown, structtype, type, mul, namelen;
int a, b, len, alphalen, unknown = nr_structs, lastunknown, structtype, type, mul, namelen;
short *sp, *structpoin;
char *cp;
int has_pointer, dna_error = 0;
while (unknown) {
lastunknown= unknown;
unknown= 0;
lastunknown = unknown;
unknown = 0;
/* check all structs... */
for (a=0; a<nr_structs; a++) {
structpoin= structs[a];
structtype= structpoin[0];
for (a = 0; a < nr_structs; a++) {
structpoin = structs[a];
structtype = structpoin[0];
/* when length is not known... */
if (typelens[structtype]==0) {
if (typelens[structtype] == 0) {
sp= structpoin+2;
len= 0;
sp = structpoin + 2;
len = 0;
alphalen = 0;
has_pointer = 0;
/* check all elements in struct */
for (b=0; b<structpoin[1]; b++, sp+=2) {
type= sp[0];
cp= names[sp[1]];
for (b = 0; b < structpoin[1]; b++, sp += 2) {
type = sp[0];
cp = names[sp[1]];
namelen= (int) strlen(cp);
namelen = (int) strlen(cp);
/* is it a pointer or function pointer? */
if (cp[0]=='*' || cp[1]=='*') {
if (cp[0] == '*' || cp[1] == '*') {
has_pointer = 1;
/* has the name an extra length? (array) */
mul= 1;
if ( cp[namelen-1]==']') mul= arraysize(cp, namelen);
mul = 1;
if (cp[namelen - 1] == ']') mul = arraysize(cp, namelen);
if (mul == 0) {
printf("Zero array size found or could not parse %s: '%.*s'\n", types[structtype], namelen + 1, cp);
@@ -774,15 +774,15 @@ static int calculate_structlens(int firststruct)
alphalen += 8 * mul;
}
else if (cp[0]=='[') {
else if (cp[0] == '[') {
/* parsing can cause names "var" and "[3]" to be found for "float var [3]" ... */
printf("Parse error in struct, invalid member name: %s %s\n", types[structtype], cp);
dna_error = 1;
}
else if ( typelens[type] ) {
else if (typelens[type]) {
/* has the name an extra length? (array) */
mul= 1;
if ( cp[namelen-1]==']') mul= arraysize(cp, namelen);
mul = 1;
if (cp[namelen - 1] == ']') mul = arraysize(cp, namelen);
if (mul == 0) {
printf("Zero array size found or could not parse %s: '%.*s'\n", types[structtype], namelen + 1, cp);
@@ -791,50 +791,50 @@ static int calculate_structlens(int firststruct)
/* struct alignment */
if (type >= 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<nr_structs; a++) {
structpoin= structs[a];
structtype= structpoin[0];
for (a = 0; a < nr_structs; a++) {
structpoin = structs[a];
structtype = structpoin[0];
/* length unknown */
if (typelens[structtype]!=0) {
if (typelens[structtype] != 0) {
printf(" %s\n", types[structtype]);
}
}
@@ -865,12 +865,12 @@ static int calculate_structlens(int firststruct)
printf("*** Unknown structs :\n");
for (a=0; a<nr_structs; a++) {
structpoin= structs[a];
structtype= structpoin[0];
for (a = 0; a < nr_structs; a++) {
structpoin = structs[a];
structtype = structpoin[0];
/* length unknown yet */
if (typelens[structtype]==0) {
if (typelens[structtype] == 0) {
printf(" %s\n", types[structtype]);
}
}
@@ -891,7 +891,7 @@ void dna_write(FILE *file, void *pntr, int size)
data = (char *) pntr;
for (i = 0 ; i < size ; i++) {
for (i = 0; i < size; i++) {
fprintf(file, "%d, ", data[i]);
linelength++;
if (linelength >= 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<nr_structs; a++) {
structpoin= structs[a];
structtype= structpoin[0];
for (a = 0; a < nr_structs; a++) {
structpoin = structs[a];
structtype = structpoin[0];
printf("\t%s\t:%d\n", types[structtype], typelens[structtype]);
}
}
@@ -940,32 +940,32 @@ static int make_structDNA(char *baseDirectory, FILE *file)
}
/* the longest known struct is 50k, so we assume 100k is sufficent! */
namedata= MEM_callocN(maxdata, "namedata");
typedata= MEM_callocN(maxdata, "typedata");
structdata= MEM_callocN(maxdata, "structdata");
namedata = MEM_callocN(maxdata, "namedata");
typedata = MEM_callocN(maxdata, "typedata");
structdata = MEM_callocN(maxdata, "structdata");
/* a maximum of 5000 variables, must be sufficient? */
names= MEM_callocN(sizeof(char *)*maxnr, "names");
types= MEM_callocN(sizeof(char *)*maxnr, "types");
typelens= MEM_callocN(sizeof(short)*maxnr, "typelens");
alphalens= MEM_callocN(sizeof(short)*maxnr, "alphalens");
structs= MEM_callocN(sizeof(short)*maxnr, "structs");
names = MEM_callocN(sizeof(char *) * maxnr, "names");
types = MEM_callocN(sizeof(char *) * maxnr, "types");
typelens = MEM_callocN(sizeof(short) * maxnr, "typelens");
alphalens = MEM_callocN(sizeof(short) * maxnr, "alphalens");
structs = MEM_callocN(sizeof(short) * maxnr, "structs");
/* insertion of all known types */
/* watch it: uint is not allowed! use in structs an unsigned int */
/* watch it: sizes must match DNA_elem_type_size() */
add_type("char", 1); /* SDNA_TYPE_CHAR */
add_type("uchar", 1); /* SDNA_TYPE_UCHAR */
add_type("short", 2); /* SDNA_TYPE_SHORT */
add_type("ushort", 2); /* SDNA_TYPE_USHORT */
add_type("int", 4); /* SDNA_TYPE_INT */
add_type("long", 4); /* SDNA_TYPE_LONG */ /* should it be 8 on 64 bits? */
add_type("ulong", 4); /* SDNA_TYPE_ULONG */
add_type("float", 4); /* SDNA_TYPE_FLOAT */
add_type("double", 8); /* SDNA_TYPE_DOUBLE */
add_type("int64_t", 8); /* SDNA_TYPE_INT64 */
add_type("char", 1); /* SDNA_TYPE_CHAR */
add_type("uchar", 1); /* SDNA_TYPE_UCHAR */
add_type("short", 2); /* SDNA_TYPE_SHORT */
add_type("ushort", 2); /* SDNA_TYPE_USHORT */
add_type("int", 4); /* SDNA_TYPE_INT */
add_type("long", 4); /* SDNA_TYPE_LONG */ /* should it be 8 on 64 bits? */
add_type("ulong", 4); /* SDNA_TYPE_ULONG */
add_type("float", 4); /* SDNA_TYPE_FLOAT */
add_type("double", 8); /* SDNA_TYPE_DOUBLE */
add_type("int64_t", 8); /* SDNA_TYPE_INT64 */
add_type("uint64_t", 8); /* SDNA_TYPE_UINT64 */
add_type("void", 0); /* SDNA_TYPE_VOID */
add_type("void", 0); /* SDNA_TYPE_VOID */
// the defines above shouldn't be output in the padding file...
firststruct = nr_types;
@@ -977,7 +977,7 @@ static int make_structDNA(char *baseDirectory, FILE *file)
if (debugSDNA) printf("\tStart of header scan:\n");
for (i = 0; strlen(includefiles[i]); i++) {
sprintf(str, "%s%s", baseDirectory, includefiles[i]);
if (debugSDNA) printf("\t|-- Converting %s\n", str);
if (debugSDNA) printf("\t|-- Converting %s\n", str);
if (convert_include(str)) {
return (1);
}
@@ -992,28 +992,28 @@ static int make_structDNA(char *baseDirectory, FILE *file)
/* FOR DEBUG */
if (debugSDNA > 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<nr_names; a++) {
for (a = 0; a < nr_names; a++) {
printf(" %s\n", names[a]);
}
printf("\n");
sp= typelens;
for (a=0; a<nr_types; a++, sp++) {
sp = typelens;
for (a = 0; a < nr_types; a++, sp++) {
printf(" %s %d\n", types[a], *sp);
}
printf("\n");
for (a=0; a<nr_structs; a++) {
sp= structs[a];
for (a = 0; a < nr_structs; a++) {
sp = structs[a];
printf(" struct %s elems: %d size: %d\n", types[sp[0]], sp[1], typelens[sp[0]]);
num_types = sp[1];
sp+= 2;
sp += 2;
/* ? num_types was elem? */
for (b=0; b< num_types; b++, sp+= 2) {
for (b = 0; b < num_types; b++, sp += 2) {
printf(" %s %s\n", types[sp[0]], names[sp[1]]);
}
}
@@ -1023,7 +1023,7 @@ static int make_structDNA(char *baseDirectory, FILE *file)
if (debugSDNA > -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<nr_types; a++, sp++) {
for (a = firststruct; a < nr_types; a++, sp++) {
if (*sp) {
fprintf(fp, "\tif (sizeof(struct %s) - %d) printf(\"ALIGN ERROR:", types[a], *sp);
fprintf(fp, "%%d %s %d ", types[a], *sp);
@@ -1127,7 +1127,7 @@ static int make_structDNA(char *baseDirectory, FILE *file)
static void make_bad_file(const char *file, int line)
{
FILE *fp= fopen(file, "w");
FILE *fp = fopen(file, "w");
fprintf(fp, "#error \"Error! can't make correct DNA.c file from %s:%d, STUPID!\"\n", __FILE__, line);
fclose(fp);
}
@@ -1136,32 +1136,32 @@ static void make_bad_file(const char *file, int line)
#define BASE_HEADER "../"
#endif
int main(int argc, char ** argv)
int main(int argc, char **argv)
{
FILE *file;
int return_status = 0;
if (argc!=2 && argc!=3) {
if (argc != 2 && argc != 3) {
printf("Usage: %s outfile.c [base directory]\n", argv[0]);
return_status = 1;
}
else {
file = fopen(argv[1], "w");
if (!file) {
printf ("Unable to open file: %s\n", argv[1]);
printf("Unable to open file: %s\n", argv[1]);
return_status = 1;
}
else {
char baseDirectory[256];
if (argc==3) {
if (argc == 3) {
strcpy(baseDirectory, argv[2]);
}
else {
strcpy(baseDirectory, BASE_HEADER);
}
fprintf (file, "unsigned char DNAstr[]= {\n");
fprintf(file, "unsigned char DNAstr[]= {\n");
if (make_structDNA(baseDirectory, file)) {
// error
fclose(file);