diff options
Diffstat (limited to 'source/blender/blenkernel/intern/CCGSubSurf.c')
| -rw-r--r-- | source/blender/blenkernel/intern/CCGSubSurf.c | 1507 |
1 files changed, 860 insertions, 647 deletions
diff --git a/source/blender/blenkernel/intern/CCGSubSurf.c b/source/blender/blenkernel/intern/CCGSubSurf.c index 3ab52a7c17b..8f0d5e2e79c 100644 --- a/source/blender/blenkernel/intern/CCGSubSurf.c +++ b/source/blender/blenkernel/intern/CCGSubSurf.c @@ -13,9 +13,9 @@ #include "BLO_sys_types.h" // for intptr_t support #ifdef _MSC_VER -#define CCG_INLINE __inline +# define CCG_INLINE __inline #else -#define CCG_INLINE inline +# define CCG_INLINE inline #endif /* copied from BKE_utildefines.h ugh */ @@ -59,22 +59,24 @@ typedef struct _EHash { #define EHASH_hash(eh, item) (((uintptr_t) (item))%((unsigned int) (eh)->curSize)) -static EHash *_ehash_new(int estimatedNumEntries, CCGAllocatorIFC *allocatorIFC, CCGAllocatorHDL allocator) { +static EHash *_ehash_new(int estimatedNumEntries, CCGAllocatorIFC *allocatorIFC, CCGAllocatorHDL allocator) +{ EHash *eh = allocatorIFC->alloc(allocator, sizeof(*eh)); eh->allocatorIFC = *allocatorIFC; eh->allocator = allocator; eh->numEntries = 0; eh->curSizeIdx = 0; - while (kHashSizes[eh->curSizeIdx]<estimatedNumEntries) + while (kHashSizes[eh->curSizeIdx] < estimatedNumEntries) eh->curSizeIdx++; eh->curSize = kHashSizes[eh->curSizeIdx]; - eh->buckets = EHASH_alloc(eh, eh->curSize*sizeof(*eh->buckets)); - memset(eh->buckets, 0, eh->curSize*sizeof(*eh->buckets)); + eh->buckets = EHASH_alloc(eh, eh->curSize * sizeof(*eh->buckets)); + memset(eh->buckets, 0, eh->curSize * sizeof(*eh->buckets)); return eh; } typedef void (*EHEntryFreeFP)(EHEntry *, void *); -static void _ehash_free(EHash *eh, EHEntryFreeFP freeEntry, void *userData) { +static void _ehash_free(EHash *eh, EHEntryFreeFP freeEntry, void *userData) +{ int numBuckets = eh->curSize; while (numBuckets--) { @@ -93,19 +95,20 @@ static void _ehash_free(EHash *eh, EHEntryFreeFP freeEntry, void *userData) { EHASH_free(eh, eh); } -static void _ehash_insert(EHash *eh, EHEntry *entry) { +static void _ehash_insert(EHash *eh, EHEntry *entry) +{ int numBuckets = eh->curSize; int hash = EHASH_hash(eh, entry->key); entry->next = eh->buckets[hash]; eh->buckets[hash] = entry; eh->numEntries++; - if (eh->numEntries > (numBuckets*3)) { + if (eh->numEntries > (numBuckets * 3)) { EHEntry **oldBuckets = eh->buckets; eh->curSize = kHashSizes[++eh->curSizeIdx]; - eh->buckets = EHASH_alloc(eh, eh->curSize*sizeof(*eh->buckets)); - memset(eh->buckets, 0, eh->curSize*sizeof(*eh->buckets)); + eh->buckets = EHASH_alloc(eh, eh->curSize * sizeof(*eh->buckets)); + memset(eh->buckets, 0, eh->curSize * sizeof(*eh->buckets)); while (numBuckets--) { for (entry = oldBuckets[numBuckets]; entry;) { @@ -123,13 +126,14 @@ static void _ehash_insert(EHash *eh, EHEntry *entry) { } } -static void *_ehash_lookupWithPrev(EHash *eh, void *key, void ***prevp_r) { +static void *_ehash_lookupWithPrev(EHash *eh, void *key, void ***prevp_r) +{ int hash = EHASH_hash(eh, key); void **prevp = (void**) &eh->buckets[hash]; EHEntry *entry; for (; (entry = *prevp); prevp = (void**) &entry->next) { - if (entry->key==key) { + if (entry->key == key) { *prevp_r = (void**) prevp; return entry; } @@ -138,12 +142,13 @@ static void *_ehash_lookupWithPrev(EHash *eh, void *key, void ***prevp_r) { return NULL; } -static void *_ehash_lookup(EHash *eh, void *key) { +static void *_ehash_lookup(EHash *eh, void *key) +{ int hash = EHASH_hash(eh, key); EHEntry *entry; for (entry = eh->buckets[hash]; entry; entry = entry->next) - if (entry->key==key) + if (entry->key == key) break; return entry; @@ -157,55 +162,64 @@ typedef struct _EHashIterator { EHEntry *curEntry; } EHashIterator; -static EHashIterator *_ehashIterator_new(EHash *eh) { +static EHashIterator *_ehashIterator_new(EHash *eh) +{ EHashIterator *ehi = EHASH_alloc(eh, sizeof(*ehi)); ehi->eh = eh; ehi->curEntry = NULL; ehi->curBucket = -1; while (!ehi->curEntry) { ehi->curBucket++; - if (ehi->curBucket==ehi->eh->curSize) + if (ehi->curBucket == ehi->eh->curSize) break; ehi->curEntry = ehi->eh->buckets[ehi->curBucket]; } return ehi; } -static void _ehashIterator_free(EHashIterator *ehi) { +static void _ehashIterator_free(EHashIterator *ehi) +{ EHASH_free(ehi->eh, ehi); } -static void *_ehashIterator_getCurrent(EHashIterator *ehi) { +static void *_ehashIterator_getCurrent(EHashIterator *ehi) +{ return ehi->curEntry; } -static void _ehashIterator_next(EHashIterator *ehi) { +static void _ehashIterator_next(EHashIterator *ehi) +{ if (ehi->curEntry) { ehi->curEntry = ehi->curEntry->next; while (!ehi->curEntry) { ehi->curBucket++; - if (ehi->curBucket==ehi->eh->curSize) + if (ehi->curBucket == ehi->eh->curSize) break; ehi->curEntry = ehi->eh->buckets[ehi->curBucket]; } } } -static int _ehashIterator_isStopped(EHashIterator *ehi) { +static int _ehashIterator_isStopped(EHashIterator *ehi) +{ return !ehi->curEntry; } /***/ -static void *_stdAllocator_alloc(CCGAllocatorHDL UNUSED(a), int numBytes) { +static void *_stdAllocator_alloc(CCGAllocatorHDL UNUSED(a), int numBytes) +{ return malloc(numBytes); } -static void *_stdAllocator_realloc(CCGAllocatorHDL UNUSED(a), void *ptr, int newSize, int UNUSED(oldSize)) { +static void *_stdAllocator_realloc(CCGAllocatorHDL UNUSED(a), void *ptr, int newSize, int UNUSED(oldSize)) +{ return realloc(ptr, newSize); } -static void _stdAllocator_free(CCGAllocatorHDL UNUSED(a), void *ptr) { +static void _stdAllocator_free(CCGAllocatorHDL UNUSED(a), void *ptr) +{ free(ptr); } -static CCGAllocatorIFC *_getStandardAllocatorIFC(void) { +static CCGAllocatorIFC *_getStandardAllocatorIFC(void) +{ static CCGAllocatorIFC ifc; ifc.alloc = _stdAllocator_alloc; @@ -218,24 +232,25 @@ static CCGAllocatorIFC *_getStandardAllocatorIFC(void) { /***/ -static int VertDataEqual(const float *a, const float *b) { - return a[0]==b[0] && a[1]==b[1] && a[2]==b[2]; +static int VertDataEqual(const float *a, const float *b) +{ + return a[0] == b[0] && a[1] == b[1] && a[2] == b[2]; } -#define VertDataZero(av) { float *_a = (float*) av; _a[0] = _a[1] = _a[2] = 0.0f; } -#define VertDataCopy(av, bv) { float *_a = (float*) av, *_b = (float*) bv; _a[0] =_b[0]; _a[1] =_b[1]; _a[2] =_b[2]; } -#define VertDataAdd(av, bv) { float *_a = (float*) av, *_b = (float*) bv; _a[0]+=_b[0]; _a[1]+=_b[1]; _a[2]+=_b[2]; } -#define VertDataSub(av, bv) { float *_a = (float*) av, *_b = (float*) bv; _a[0]-=_b[0]; _a[1]-=_b[1]; _a[2]-=_b[2]; } -#define VertDataMulN(av, n) { float *_a = (float*) av; _a[0]*=n; _a[1]*=n; _a[2]*=n; } +#define VertDataZero(av) { float *_a = (float *)av; _a[0] = _a[1] = _a[2] = 0.0f; } +#define VertDataCopy(av, bv) { float *_a = (float *)av, *_b = (float *) bv; _a[0] = _b[0]; _a[1] = _b[1]; _a[2] = _b[2]; } +#define VertDataAdd(av, bv) { float *_a = (float *)av, *_b = (float *) bv; _a[0] += _b[0]; _a[1] += _b[1]; _a[2] += _b[2]; } +#define VertDataSub(av, bv) { float *_a = (float *)av, *_b = (float *) bv; _a[0] -= _b[0]; _a[1] -= _b[1]; _a[2] -= _b[2]; } +#define VertDataMulN(av, n) { float *_a = (float *)av; _a[0]*=n; _a[1]*=n; _a[2] *=n; } #define VertDataAvg4(tv, av, bv, cv, dv) \ { \ - float *_t = (float*) tv, *_a = (float*) av, *_b = (float*) bv, *_c = (float*) cv, *_d = (float*) dv; \ - _t[0] = (_a[0]+_b[0]+_c[0]+_d[0])*.25f; \ - _t[1] = (_a[1]+_b[1]+_c[1]+_d[1])*.25f; \ - _t[2] = (_a[2]+_b[2]+_c[2]+_d[2])*.25f; \ + float *_t = (float *) tv, *_a = (float *) av, *_b = (float *) bv, *_c = (float *) cv, *_d = (float *) dv; \ + _t[0] = (_a[0] + _b[0] + _c[0] + _d[0]) * 0.25f; \ + _t[1] = (_a[1] + _b[1] + _c[1] + _d[1]) * 0.25f; \ + _t[2] = (_a[2] + _b[2] + _c[2] + _d[2]) * 0.25f; \ } -#define NormZero(av) { float *_a = (float*) av; _a[0] = _a[1] = _a[2] = 0.0f; } -#define NormCopy(av, bv) { float *_a = (float*) av, *_b = (float*) bv; _a[0] =_b[0]; _a[1] =_b[1]; _a[2] =_b[2]; } -#define NormAdd(av, bv) { float *_a = (float*) av, *_b = (float*) bv; _a[0]+=_b[0]; _a[1]+=_b[1]; _a[2]+=_b[2]; } +#define NormZero(av) { float *_a = (float *) av; _a[0] = _a[1] = _a[2] = 0.0f; } +#define NormCopy(av, bv) { float *_a = (float *) av, *_b = (float *) bv; _a[0] = _b[0]; _a[1] = _b[1]; _a[2] = _b[2]; } +#define NormAdd(av, bv) { float *_a = (float *) av, *_b = (float *) bv; _a[0] += _b[0]; _a[1] += _b[1]; _a[2] += _b[2]; } static int _edge_isBoundary(const CCGEdge *e); @@ -243,15 +258,15 @@ static int _edge_isBoundary(const CCGEdge *e); /***/ enum { - Vert_eEffected= (1<<0), - Vert_eChanged= (1<<1), - Vert_eSeam= (1<<2), + Vert_eEffected = (1 << 0), + Vert_eChanged = (1 << 1), + Vert_eSeam = (1 << 2) } /*VertFlags*/; enum { - Edge_eEffected= (1<<0), + Edge_eEffected = (1 << 0) } /*CCGEdgeFlags*/; enum { - Face_eEffected= (1<<0), + Face_eEffected = (1 << 0) } /*FaceFlags*/; struct _CCGVert { @@ -265,7 +280,7 @@ struct _CCGVert { // byte *levelData; // byte *userData; }; -#define VERT_getLevelData(v) ((byte*) &(v)[1]) +#define VERT_getLevelData(v) ((byte *) &(v)[1]) struct _CCGEdge { CCGEdge *next; /* EHData.next */ @@ -280,7 +295,7 @@ struct _CCGEdge { // byte *levelData; // byte *userData; }; -#define EDGE_getLevelData(e) ((byte*) &(e)[1]) +#define EDGE_getLevelData(e) ((byte *) &(e)[1]) struct _CCGFace { CCGFace *next; /* EHData.next */ @@ -296,14 +311,14 @@ struct _CCGFace { }; #define FACE_getVerts(f) ((CCGVert**) &(f)[1]) #define FACE_getEdges(f) ((CCGEdge**) &(FACE_getVerts(f)[(f)->numVerts])) -#define FACE_getCenterData(f) ((byte*) &(FACE_getEdges(f)[(f)->numVerts])) +#define FACE_getCenterData(f) ((byte *) &(FACE_getEdges(f)[(f)->numVerts])) typedef enum { eSyncState_None = 0, eSyncState_Vert, eSyncState_Edge, eSyncState_Face, - eSyncState_Partial, + eSyncState_Partial } SyncState; struct _CCGSubSurf { @@ -350,8 +365,9 @@ struct _CCGSubSurf { /***/ -static CCGVert *_vert_new(CCGVertHDL vHDL, CCGSubSurf *ss) { - CCGVert *v = CCGSUBSURF_alloc(ss, sizeof(CCGVert) + ss->meshIFC.vertDataSize * (ss->subdivLevels+1) + ss->meshIFC.vertUserSize); +static CCGVert *_vert_new(CCGVertHDL vHDL, CCGSubSurf *ss) +{ + CCGVert *v = CCGSUBSURF_alloc(ss, sizeof(CCGVert) + ss->meshIFC.vertDataSize * (ss->subdivLevels + 1) + ss->meshIFC.vertUserSize); byte *userData; v->vHDL = vHDL; @@ -366,71 +382,87 @@ static CCGVert *_vert_new(CCGVertHDL vHDL, CCGSubSurf *ss) { return v; } -static void _vert_remEdge(CCGVert *v, CCGEdge *e) { +static void _vert_remEdge(CCGVert *v, CCGEdge *e) +{ int i; - for (i=0; i<v->numEdges; i++) { - if (v->edges[i]==e) { + for (i = 0; i < v->numEdges; i++) { + if (v->edges[i] == e) { v->edges[i] = v->edges[--v->numEdges]; break; } } } -static void _vert_remFace(CCGVert *v, CCGFace *f) { +static void _vert_remFace(CCGVert *v, CCGFace *f) +{ int i; - for (i=0; i<v->numFaces; i++) { - if (v->faces[i]==f) { + for (i = 0; i < v->numFaces; i++) { + if (v->faces[i] == f) { v->faces[i] = v->faces[--v->numFaces]; break; } } } -static void _vert_addEdge(CCGVert *v, CCGEdge *e, CCGSubSurf *ss) { - v->edges = CCGSUBSURF_realloc(ss, v->edges, (v->numEdges+1)*sizeof(*v->edges), v->numEdges*sizeof(*v->edges)); +static void _vert_addEdge(CCGVert *v, CCGEdge *e, CCGSubSurf *ss) +{ + v->edges = CCGSUBSURF_realloc(ss, v->edges, (v->numEdges + 1) * sizeof(*v->edges), v->numEdges * sizeof(*v->edges)); v->edges[v->numEdges++] = e; } -static void _vert_addFace(CCGVert *v, CCGFace *f, CCGSubSurf *ss) { - v->faces = CCGSUBSURF_realloc(ss, v->faces, (v->numFaces+1)*sizeof(*v->faces), v->numFaces*sizeof(*v->faces)); +static void _vert_addFace(CCGVert *v, CCGFace *f, CCGSubSurf *ss) +{ + v->faces = CCGSUBSURF_realloc(ss, v->faces, (v->numFaces + 1) * sizeof(*v->faces), v->numFaces * sizeof(*v->faces)); v->faces[v->numFaces++] = f; } -static CCGEdge *_vert_findEdgeTo(const CCGVert *v, const CCGVert *vQ) { +static CCGEdge *_vert_findEdgeTo(const CCGVert *v, const CCGVert *vQ) +{ int i; - for (i=0; i<v->numEdges; i++) { - CCGEdge *e = v->edges[v->numEdges-1-i]; // XXX, note reverse - if ( (e->v0==v && e->v1==vQ) || - (e->v1==v && e->v0==vQ)) + for (i = 0; i < v->numEdges; i++) { + CCGEdge *e = v->edges[v->numEdges - 1 - i]; // XXX, note reverse + if ((e->v0 == v && e->v1 == vQ) || + (e->v1 == v && e->v0 == vQ)) + { return e; + } } return NULL; } -static int _vert_isBoundary(const CCGVert *v) { +static int _vert_isBoundary(const CCGVert *v) +{ int i; - for (i=0; i<v->numEdges; i++) + for (i = 0; i < v->numEdges; i++) if (_edge_isBoundary(v->edges[i])) return 1; return 0; } -static void *_vert_getCo(CCGVert *v, int lvl, int dataSize) { - return &VERT_getLevelData(v)[lvl*dataSize]; +static void *_vert_getCo(CCGVert *v, int lvl, int dataSize) +{ + return &VERT_getLevelData(v)[lvl * dataSize]; } -static float *_vert_getNo(CCGVert *v, int lvl, int dataSize, int normalDataOffset) { - return (float*) &VERT_getLevelData(v)[lvl*dataSize + normalDataOffset]; +static float *_vert_getNo(CCGVert *v, int lvl, int dataSize, int normalDataOffset) +{ + return (float *) &VERT_getLevelData(v)[lvl * dataSize + normalDataOffset]; } -static void _vert_free(CCGVert *v, CCGSubSurf *ss) { +static void _vert_free(CCGVert *v, CCGSubSurf *ss) +{ CCGSUBSURF_free(ss, v->edges); CCGSUBSURF_free(ss, v->faces); CCGSUBSURF_free(ss, v); } -static int VERT_seam(const CCGVert *v) { +static int VERT_seam(const CCGVert *v) +{ return ((v->flags & Vert_eSeam) != 0); } /***/ -static CCGEdge *_edge_new(CCGEdgeHDL eHDL, CCGVert *v0, CCGVert *v1, float crease, CCGSubSurf *ss) { - CCGEdge *e = CCGSUBSURF_alloc(ss, sizeof(CCGEdge) + ss->meshIFC.vertDataSize *((ss->subdivLevels+1) + (1<<(ss->subdivLevels+1))-1) + ss->meshIFC.edgeUserSize); +static CCGEdge *_edge_new(CCGEdgeHDL eHDL, CCGVert *v0, CCGVert *v1, float crease, CCGSubSurf *ss) +{ + CCGEdge *e = CCGSUBSURF_alloc(ss, + sizeof(CCGEdge) + + ss->meshIFC.vertDataSize * ((ss->subdivLevels + 1) + (1 << (ss->subdivLevels + 1)) - 1) + + ss->meshIFC.edgeUserSize); byte *userData; e->eHDL = eHDL; @@ -449,53 +481,64 @@ static CCGEdge *_edge_new(CCGEdgeHDL eHDL, CCGVert *v0, CCGVert *v1, float creas return e; } -static void _edge_remFace(CCGEdge *e, CCGFace *f) { +static void _edge_remFace(CCGEdge *e, CCGFace *f) +{ int i; - for (i=0; i<e->numFaces; i++) { - if (e->faces[i]==f) { + for (i = 0; i < e->numFaces; i++) { + if (e->faces[i] == f) { e->faces[i] = e->faces[--e->numFaces]; break; } } } -static void _edge_addFace(CCGEdge *e, CCGFace *f, CCGSubSurf *ss) { - e->faces = CCGSUBSURF_realloc(ss, e->faces, (e->numFaces+1)*sizeof(*e->faces), e->numFaces*sizeof(*e->faces)); +static void _edge_addFace(CCGEdge *e, CCGFace *f, CCGSubSurf *ss) +{ + e->faces = CCGSUBSURF_realloc(ss, e->faces, (e->numFaces + 1) * sizeof(*e->faces), e->numFaces * sizeof(*e->faces)); e->faces[e->numFaces++] = f; } -static int _edge_isBoundary(const CCGEdge *e) { +static int _edge_isBoundary(const CCGEdge *e) +{ return e->numFaces<2; } -static CCGVert *_edge_getOtherVert(CCGEdge *e, CCGVert *vQ) { - if (vQ==e->v0) { +static CCGVert *_edge_getOtherVert(CCGEdge *e, CCGVert *vQ) +{ + if (vQ == e->v0) { return e->v1; - } else { + } + else { return e->v0; } } -static void *_edge_getCo(CCGEdge *e, int lvl, int x, int dataSize) { - int levelBase = lvl + (1<<lvl) - 1; - return &EDGE_getLevelData(e)[dataSize*(levelBase + x)]; +static void *_edge_getCo(CCGEdge *e, int lvl, int x, int dataSize) +{ + int levelBase = lvl + (1 << lvl) - 1; + return &EDGE_getLevelData(e)[dataSize * (levelBase + x)]; } -static float *_edge_getNo(CCGEdge *e, int lvl, int x, int dataSize, int normalDataOffset) { - int levelBase = lvl + (1<<lvl) - 1; - return (float*) &EDGE_getLevelData(e)[dataSize*(levelBase + x) + normalDataOffset]; +static float *_edge_getNo(CCGEdge *e, int lvl, int x, int dataSize, int normalDataOffset) +{ + int levelBase = lvl + (1 << lvl) - 1; + return (float *) &EDGE_getLevelData(e)[dataSize * (levelBase + x) + normalDataOffset]; } -static void *_edge_getCoVert(CCGEdge *e, CCGVert *v, int lvl, int x, int dataSize) { - int levelBase = lvl + (1<<lvl) - 1; - if (v==e->v0) { - return &EDGE_getLevelData(e)[dataSize*(levelBase + x)]; - } else { - return &EDGE_getLevelData(e)[dataSize*(levelBase + (1<<lvl) - x)]; +static void *_edge_getCoVert(CCGEdge *e, CCGVert *v, int lvl, int x, int dataSize) +{ + int levelBase = lvl + (1 << lvl) - 1; + if (v == e->v0) { + return &EDGE_getLevelData(e)[dataSize * (levelBase + x)]; + } + else { + return &EDGE_getLevelData(e)[dataSize * (levelBase + (1 << lvl) - x)]; } } -static void _edge_free(CCGEdge *e, CCGSubSurf *ss) { +static void _edge_free(CCGEdge *e, CCGSubSurf *ss) +{ CCGSUBSURF_free(ss, e->faces); CCGSUBSURF_free(ss, e); } -static void _edge_unlinkMarkAndFree(CCGEdge *e, CCGSubSurf *ss) { +static void _edge_unlinkMarkAndFree(CCGEdge *e, CCGSubSurf *ss) +{ _vert_remEdge(e->v0, e); _vert_remEdge(e->v1, e); e->v0->flags |= Vert_eEffected; @@ -503,7 +546,8 @@ static void _edge_unlinkMarkAndFree(CCGEdge *e, CCGSubSurf *ss) { _edge_free(e, ss); } -static float EDGE_getSharpness(CCGEdge *e, int lvl) { +static float EDGE_getSharpness(CCGEdge *e, int lvl) +{ if (!lvl) return e->crease; else if (!e->crease) @@ -514,9 +558,15 @@ static float EDGE_getSharpness(CCGEdge *e, int lvl) { return e->crease - lvl; } -static CCGFace *_face_new(CCGFaceHDL fHDL, CCGVert **verts, CCGEdge **edges, int numVerts, CCGSubSurf *ss) { - int maxGridSize = 1 + (1<<(ss->subdivLevels-1)); - CCGFace *f = CCGSUBSURF_alloc(ss, sizeof(CCGFace) + sizeof(CCGVert*)*numVerts + sizeof(CCGEdge*)*numVerts + ss->meshIFC.vertDataSize *(1 + numVerts*maxGridSize + numVerts*maxGridSize*maxGridSize) + ss->meshIFC.faceUserSize); +static CCGFace *_face_new(CCGFaceHDL fHDL, CCGVert **verts, CCGEdge **edges, int numVerts, CCGSubSurf *ss) +{ + int maxGridSize = 1 + (1 << (ss->subdivLevels - 1)); + CCGFace *f = CCGSUBSURF_alloc(ss, + sizeof(CCGFace) + + sizeof(CCGVert*) * numVerts + + sizeof(CCGEdge*) * numVerts + + ss->meshIFC.vertDataSize * (1 + numVerts * maxGridSize + numVerts * maxGridSize * maxGridSize) + + ss->meshIFC.faceUserSize); byte *userData; int i; @@ -524,7 +574,7 @@ static CCGFace *_face_new(CCGFaceHDL fHDL, CCGVert **verts, CCGEdge **edges, int f->fHDL = fHDL; f->flags = 0; - for (i=0; i<numVerts; i++) { + for (i = 0; i < numVerts; i++) { FACE_getVerts(f)[i] = verts[i]; FACE_getEdges(f)[i] = edges[i]; _vert_addFace(verts[i], f, ss); @@ -538,102 +588,115 @@ static CCGFace *_face_new(CCGFaceHDL fHDL, CCGVert **verts, CCGEdge **edges, int return f; } -static CCG_INLINE void *_face_getIECo(CCGFace *f, int lvl, int S, int x, int levels, int dataSize) { - int maxGridSize = 1 + (1<<(levels-1)); - int spacing = 1<<(levels-lvl); - byte *gridBase = FACE_getCenterData(f) + dataSize*(1 + S*(maxGridSize + maxGridSize*maxGridSize)); - return &gridBase[dataSize*x*spacing]; +static CCG_INLINE void *_face_getIECo(CCGFace *f, int lvl, int S, int x, int levels, int dataSize) +{ + int maxGridSize = 1 + (1 << (levels - 1)); + int spacing = 1 << (levels - lvl); + byte *gridBase = FACE_getCenterData(f) + dataSize * (1 + S * (maxGridSize + maxGridSize * maxGridSize)); + return &gridBase[dataSize * x * spacing]; } -static CCG_INLINE void *_face_getIENo(CCGFace *f, int lvl, int S, int x, int levels, int dataSize, int normalDataOffset) { - int maxGridSize = 1 + (1<<(levels-1)); - int spacing = 1<<(levels-lvl); - byte *gridBase = FACE_getCenterData(f) + dataSize*(1 + S*(maxGridSize + maxGridSize*maxGridSize)); - return &gridBase[dataSize*x*spacing + normalDataOffset]; +static CCG_INLINE void *_face_getIENo(CCGFace *f, int lvl, int S, int x, int levels, int dataSize, int normalDataOffset) +{ + int maxGridSize = 1 + (1 << (levels - 1)); + int spacing = 1 << (levels - lvl); + byte *gridBase = FACE_getCenterData(f) + dataSize * (1 + S * (maxGridSize + maxGridSize * maxGridSize)); + return &gridBase[dataSize * x * spacing + normalDataOffset]; } -static CCG_INLINE void *_face_getIFCo(CCGFace *f, int lvl, int S, int x, int y, int levels, int dataSize) { - int maxGridSize = 1 + (1<<(levels-1)); - int spacing = 1<<(levels-lvl); - byte *gridBase = FACE_getCenterData(f) + dataSize*(1 + S*(maxGridSize + maxGridSize*maxGridSize)); - return &gridBase[dataSize*(maxGridSize + (y*maxGridSize + x)*spacing)]; +static CCG_INLINE void *_face_getIFCo(CCGFace *f, int lvl, int S, int x, int y, int levels, int dataSize) +{ + int maxGridSize = 1 + (1 << (levels - 1)); + int spacing = 1 << (levels - lvl); + byte *gridBase = FACE_getCenterData(f) + dataSize * (1 + S * (maxGridSize + maxGridSize * maxGridSize)); + return &gridBase[dataSize * (maxGridSize + (y * maxGridSize + x) * spacing)]; } -static CCG_INLINE float *_face_getIFNo(CCGFace *f, int lvl, int S, int x, int y, int levels, int dataSize, int normalDataOffset) { - int maxGridSize = 1 + (1<<(levels-1)); - int spacing = 1<<(levels-lvl); - byte *gridBase = FACE_getCenterData(f) + dataSize*(1 + S*(maxGridSize + maxGridSize*maxGridSize)); - return (float*) &gridBase[dataSize*(maxGridSize + (y*maxGridSize + x)*spacing) + normalDataOffset]; +static CCG_INLINE float *_face_getIFNo(CCGFace *f, int lvl, int S, int x, int y, int levels, int dataSize, int normalDataOffset) +{ + int maxGridSize = 1 + (1 << (levels - 1)); + int spacing = 1 << (levels - lvl); + byte *gridBase = FACE_getCenterData(f) + dataSize * (1 + S * (maxGridSize + maxGridSize * maxGridSize)); + return (float *) &gridBase[dataSize * (maxGridSize + (y * maxGridSize + x) * spacing) + normalDataOffset]; } -static int _face_getVertIndex(CCGFace *f, CCGVert *v) { +static int _face_getVertIndex(CCGFace *f, CCGVert *v) +{ int i; - for (i=0; i<f->numVerts; i++) - if (FACE_getVerts(f)[i]==v) + for (i = 0; i < f->numVerts; i++) + if (FACE_getVerts(f)[i] == v) return i; return -1; } -static CCG_INLINE void *_face_getIFCoEdge(CCGFace *f, CCGEdge *e, int lvl, int eX, int eY, int levels, int dataSize) { - int maxGridSize = 1 + (1<<(levels-1)); - int spacing = 1<<(levels-lvl); +static CCG_INLINE void *_face_getIFCoEdge(CCGFace *f, CCGEdge *e, int lvl, int eX, int eY, int levels, int dataSize) +{ + int maxGridSize = 1 + (1 << (levels - 1)); + int spacing = 1 << (levels - lvl); int S, x, y, cx, cy; - for (S=0; S<f->numVerts; S++) - if (FACE_getEdges(f)[S]==e) + for (S = 0; S < f->numVerts; S++) + if (FACE_getEdges(f)[S] == e) break; - eX = eX*spacing; - eY = eY*spacing; + eX = eX * spacing; + eY = eY * spacing; if (e->v0!=FACE_getVerts(f)[S]) { - eX = (maxGridSize*2 - 1)-1 - eX; + eX = (maxGridSize * 2 - 1) - 1 - eX; } y = maxGridSize - 1 - eX; x = maxGridSize - 1 - eY; if (x<0) { - S = (S+f->numVerts-1)%f->numVerts; + S = (S + f->numVerts - 1) % f->numVerts; cx = y; cy = -x; - } else if (y<0) { - S = (S+1)%f->numVerts; + } + else if (y < 0) { + S = (S + 1) % f->numVerts; cx = -y; cy = x; - } else { + } + else { cx = x; cy = y; } return _face_getIFCo(f, levels, S, cx, cy, levels, dataSize); } -static float *_face_getIFNoEdge(CCGFace *f, CCGEdge *e, int lvl, int eX, int eY, int levels, int dataSize, int normalDataOffset) { - return (float*) ((byte*) _face_getIFCoEdge(f, e, lvl, eX, eY, levels, dataSize) + normalDataOffset); +static float *_face_getIFNoEdge(CCGFace *f, CCGEdge *e, int lvl, int eX, int eY, int levels, int dataSize, int normalDataOffset) +{ + return (float *) ((byte *) _face_getIFCoEdge(f, e, lvl, eX, eY, levels, dataSize) + normalDataOffset); } -static void _face_calcIFNo(CCGFace *f, int lvl, int S, int x, int y, float *no, int levels, int dataSize) { - float *a = _face_getIFCo(f, lvl, S, x+0, y+0, levels, dataSize); - float *b = _face_getIFCo(f, lvl, S, x+1, y+0, levels, dataSize); - float *c = _face_getIFCo(f, lvl, S, x+1, y+1, levels, dataSize); - float *d = _face_getIFCo(f, lvl, S, x+0, y+1, levels, dataSize); +static void _face_calcIFNo(CCGFace *f, int lvl, int S, int x, int y, float *no, int levels, int dataSize) +{ + float *a = _face_getIFCo(f, lvl, S, x + 0, y + 0, levels, dataSize); + float *b = _face_getIFCo(f, lvl, S, x + 1, y + 0, levels, dataSize); + float *c = _face_getIFCo(f, lvl, S, x + 1, y + 1, levels, dataSize); + float *d = _face_getIFCo(f, lvl, S, x + 0, y + 1, levels, dataSize); float a_cX = c[0]-a[0], a_cY = c[1]-a[1], a_cZ = c[2]-a[2]; float b_dX = d[0]-b[0], b_dY = d[1]-b[1], b_dZ = d[2]-b[2]; float length; - no[0] = b_dY*a_cZ - b_dZ*a_cY; - no[1] = b_dZ*a_cX - b_dX*a_cZ; - no[2] = b_dX*a_cY - b_dY*a_cX; + no[0] = b_dY * a_cZ - b_dZ * a_cY; + no[1] = b_dZ * a_cX - b_dX * a_cZ; + no[2] = b_dX * a_cY - b_dY * a_cX; - length = sqrt(no[0]*no[0] + no[1]*no[1] + no[2]*no[2]); + length = sqrt(no[0] * no[0] + no[1] * no[1] + no[2] * no[2]); - if (length>EPSILON) { + if (length > EPSILON) { float invLength = 1.f/length; no[0] *= invLength; no[1] *= invLength; no[2] *= invLength; - } else { + } + else { NormZero(no); } } -static void _face_free(CCGFace *f, CCGSubSurf *ss) { +static void _face_free(CCGFace *f, CCGSubSurf *ss) +{ CCGSUBSURF_free(ss, f); } -static void _face_unlinkMarkAndFree(CCGFace *f, CCGSubSurf *ss) { +static void _face_unlinkMarkAndFree(CCGFace *f, CCGSubSurf *ss) +{ int j; - for (j=0; j<f->numVerts; j++) { + for (j = 0; j < f->numVerts; j++) { _vert_remFace(FACE_getVerts(f)[j], f); _edge_remFace(FACE_getEdges(f)[j], f); FACE_getVerts(f)[j]->flags |= Vert_eEffected; @@ -643,7 +706,8 @@ static void _face_unlinkMarkAndFree(CCGFace *f, CCGSubSurf *ss) { /***/ -CCGSubSurf *ccgSubSurf_new(CCGMeshIFC *ifc, int subdivLevels, CCGAllocatorIFC *allocatorIFC, CCGAllocatorHDL allocator) { +CCGSubSurf *ccgSubSurf_new(CCGMeshIFC *ifc, int subdivLevels, CCGAllocatorIFC *allocatorIFC, CCGAllocatorHDL allocator) +{ if (!allocatorIFC) { allocatorIFC = _getStandardAllocatorIFC(); allocator = NULL; @@ -651,7 +715,8 @@ CCGSubSurf *ccgSubSurf_new(CCGMeshIFC *ifc, int subdivLevels, CCGAllocatorIFC *a if (subdivLevels<1) { return NULL; - } else { + } + else { CCGSubSurf *ss = allocatorIFC->alloc(allocator, sizeof(*ss)); ss->allocatorIFC = *allocatorIFC; @@ -691,7 +756,8 @@ CCGSubSurf *ccgSubSurf_new(CCGMeshIFC *ifc, int subdivLevels, CCGAllocatorIFC *a } } -void ccgSubSurf_free(CCGSubSurf *ss) { +void ccgSubSurf_free(CCGSubSurf *ss) +{ CCGAllocatorIFC allocatorIFC = ss->allocatorIFC; CCGAllocatorHDL allocator = ss->allocator; @@ -719,7 +785,8 @@ void ccgSubSurf_free(CCGSubSurf *ss) { } } -CCGError ccgSubSurf_setAllowEdgeCreation(CCGSubSurf *ss, int allowEdgeCreation, float defaultCreaseValue, void *defaultUserData) { +CCGError ccgSubSurf_setAllowEdgeCreation(CCGSubSurf *ss, int allowEdgeCreation, float defaultCreaseValue, void *defaultUserData) +{ if (ss->defaultEdgeUserData) { CCGSUBSURF_free(ss, ss->defaultEdgeUserData); } @@ -730,13 +797,15 @@ CCGError ccgSubSurf_setAllowEdgeCreation(CCGSubSurf *ss, int allowEdgeCreation, if (defaultUserData) { memcpy(ss->defaultEdgeUserData, defaultUserData, ss->meshIFC.edgeUserSize); - } else { + } + else { memset(ss->defaultEdgeUserData, 0, ss->meshIFC.edgeUserSize); } return eCCGError_None; } -void ccgSubSurf_getAllowEdgeCreation(CCGSubSurf *ss, int *allowEdgeCreation_r, float *defaultCreaseValue_r, void *defaultUserData_r) { +void ccgSubSurf_getAllowEdgeCreation(CCGSubSurf *ss, int *allowEdgeCreation_r, float *defaultCreaseValue_r, void *defaultUserData_r) +{ if (allowEdgeCreation_r) *allowEdgeCreation_r = ss->allowEdgeCreation; if (ss->allowEdgeCreation) { if (defaultCreaseValue_r) *defaultCreaseValue_r = ss->defaultCreaseValue; @@ -744,10 +813,12 @@ void ccgSubSurf_getAllowEdgeCreation(CCGSubSurf *ss, int *allowEdgeCreation_r, f } } -CCGError ccgSubSurf_setSubdivisionLevels(CCGSubSurf *ss, int subdivisionLevels) { +CCGError ccgSubSurf_setSubdivisionLevels(CCGSubSurf *ss, int subdivisionLevels) +{ if (subdivisionLevels<=0) { return eCCGError_InvalidValue; - } else if (subdivisionLevels!=ss->subdivLevels) { + } + else if (subdivisionLevels!=ss->subdivLevels) { ss->numGrids = 0; ss->subdivLevels = subdivisionLevels; _ehash_free(ss->vMap, (EHEntryFreeFP) _vert_free, ss); @@ -770,19 +841,23 @@ void ccgSubSurf_getUseAgeCounts(CCGSubSurf *ss, int *useAgeCounts_r, int *vertUs if (faceUserOffset_r) *faceUserOffset_r = ss->faceUserAgeOffset; } -CCGError ccgSubSurf_setUseAgeCounts(CCGSubSurf *ss, int useAgeCounts, int vertUserOffset, int edgeUserOffset, int faceUserOffset) { +CCGError ccgSubSurf_setUseAgeCounts(CCGSubSurf *ss, int useAgeCounts, int vertUserOffset, int edgeUserOffset, int faceUserOffset) +{ if (useAgeCounts) { - if ( (vertUserOffset+4>ss->meshIFC.vertUserSize) || - (edgeUserOffset+4>ss->meshIFC.edgeUserSize) || - (faceUserOffset+4>ss->meshIFC.faceUserSize)) { + if ((vertUserOffset + 4 > ss->meshIFC.vertUserSize) || + (edgeUserOffset + 4 > ss->meshIFC.edgeUserSize) || + (faceUserOffset + 4 > ss->meshIFC.faceUserSize)) + { return eCCGError_InvalidValue; - } else { + } + else { ss->useAgeCounts = 1; ss->vertUserAgeOffset = vertUserOffset; ss->edgeUserAgeOffset = edgeUserOffset; ss->faceUserAgeOffset = faceUserOffset; } - } else { + } + else { ss->useAgeCounts = 0; ss->vertUserAgeOffset = ss->edgeUserAgeOffset = ss->faceUserAgeOffset = 0; } @@ -790,15 +865,18 @@ CCGError ccgSubSurf_setUseAgeCounts(CCGSubSurf *ss, int useAgeCounts, int vertUs return eCCGError_None; } -CCGError ccgSubSurf_setCalcVertexNormals(CCGSubSurf *ss, int useVertNormals, int normalDataOffset) { +CCGError ccgSubSurf_setCalcVertexNormals(CCGSubSurf *ss, int useVertNormals, int normalDataOffset) +{ if (useVertNormals) { - if (normalDataOffset<0 || normalDataOffset+12>ss->meshIFC.vertDataSize) { + if (normalDataOffset<0 || normalDataOffset + 12>ss->meshIFC.vertDataSize) { return eCCGError_InvalidValue; - } else { + } + else { ss->calcVertNormals = 1; ss->normalDataOffset = normalDataOffset; } - } else { + } + else { ss->calcVertNormals = 0; ss->normalDataOffset = 0; } @@ -808,7 +886,8 @@ CCGError ccgSubSurf_setCalcVertexNormals(CCGSubSurf *ss, int useVertNormals, int /***/ -CCGError ccgSubSurf_initFullSync(CCGSubSurf *ss) { +CCGError ccgSubSurf_initFullSync(CCGSubSurf *ss) +{ if (ss->syncState!=eSyncState_None) { return eCCGError_InvalidSyncState; } @@ -826,15 +905,16 @@ CCGError ccgSubSurf_initFullSync(CCGSubSurf *ss) { ss->numGrids = 0; ss->lenTempArrays = 12; - ss->tempVerts = MEM_mallocN(sizeof(*ss->tempVerts)*ss->lenTempArrays, "CCGSubsurf tempVerts"); - ss->tempEdges = MEM_mallocN(sizeof(*ss->tempEdges)*ss->lenTempArrays, "CCGSubsurf tempEdges"); + ss->tempVerts = MEM_mallocN(sizeof(*ss->tempVerts) * ss->lenTempArrays, "CCGSubsurf tempVerts"); + ss->tempEdges = MEM_mallocN(sizeof(*ss->tempEdges) * ss->lenTempArrays, "CCGSubsurf tempEdges"); ss->syncState = eSyncState_Vert; return eCCGError_None; } -CCGError ccgSubSurf_initPartialSync(CCGSubSurf *ss) { +CCGError ccgSubSurf_initPartialSync(CCGSubSurf *ss) +{ if (ss->syncState!=eSyncState_None) { return eCCGError_InvalidSyncState; } @@ -846,16 +926,19 @@ CCGError ccgSubSurf_initPartialSync(CCGSubSurf *ss) { return eCCGError_None; } -CCGError ccgSubSurf_syncVertDel(CCGSubSurf *ss, CCGVertHDL vHDL) { +CCGError ccgSubSurf_syncVertDel(CCGSubSurf *ss, CCGVertHDL vHDL) +{ if (ss->syncState!=eSyncState_Partial) { return eCCGError_InvalidSyncState; - } else { + } + else { void **prevp; CCGVert *v = _ehash_lookupWithPrev(ss->vMap, vHDL, &prevp); if (!v || v->numFaces || v->numEdges) { return eCCGError_InvalidValue; - } else { + } + else { *prevp = v->next; _vert_free(v, ss); } @@ -864,16 +947,19 @@ CCGError ccgSubSurf_syncVertDel(CCGSubSurf *ss, CCGVertHDL vHDL) { return eCCGError_None; } -CCGError ccgSubSurf_syncEdgeDel(CCGSubSurf *ss, CCGEdgeHDL eHDL) { +CCGError ccgSubSurf_syncEdgeDel(CCGSubSurf *ss, CCGEdgeHDL eHDL) +{ if (ss->syncState!=eSyncState_Partial) { return eCCGError_InvalidSyncState; - } else { + } + else { void **prevp; CCGEdge *e = _ehash_lookupWithPrev(ss->eMap, eHDL, &prevp); if (!e || e->numFaces) { return eCCGError_InvalidValue; - } else { + } + else { *prevp = e->next; _edge_unlinkMarkAndFree(e, ss); } @@ -882,16 +968,19 @@ CCGError ccgSubSurf_syncEdgeDel(CCGSubSurf *ss, CCGEdgeHDL eHDL) { return eCCGError_None; } -CCGError ccgSubSurf_syncFaceDel(CCGSubSurf *ss, CCGFaceHDL fHDL) { +CCGError ccgSubSurf_syncFaceDel(CCGSubSurf *ss, CCGFaceHDL fHDL) +{ if (ss->syncState!=eSyncState_Partial) { return eCCGError_InvalidSyncState; - } else { + } + else { void **prevp; CCGFace *f = _ehash_lookupWithPrev(ss->fMap, fHDL, &prevp); if (!f) { return eCCGError_InvalidValue; - } else { + } + else { *prevp = f->next; _face_unlinkMarkAndFree(f, ss); } @@ -900,37 +989,40 @@ CCGError ccgSubSurf_syncFaceDel(CCGSubSurf *ss, CCGFaceHDL fHDL) { return eCCGError_None; } -CCGError ccgSubSurf_syncVert(CCGSubSurf *ss, CCGVertHDL vHDL, const void *vertData, int seam, CCGVert **v_r) { +CCGError ccgSubSurf_syncVert(CCGSubSurf *ss, CCGVertHDL vHDL, const void *vertData, int seam, CCGVert **v_r) +{ void **prevp; CCGVert *v = NULL; short seamflag = (seam)? Vert_eSeam: 0; - if (ss->syncState==eSyncState_Partial) { + if (ss->syncState == eSyncState_Partial) { v = _ehash_lookupWithPrev(ss->vMap, vHDL, &prevp); if (!v) { v = _vert_new(vHDL, ss); VertDataCopy(_vert_getCo(v,0,ss->meshIFC.vertDataSize), vertData); _ehash_insert(ss->vMap, (EHEntry*) v); v->flags = Vert_eEffected|seamflag; - } else if (!VertDataEqual(vertData, _vert_getCo(v, 0, ss->meshIFC.vertDataSize)) || ((v->flags & Vert_eSeam) != seamflag)) { + } + else if (!VertDataEqual(vertData, _vert_getCo(v, 0, ss->meshIFC.vertDataSize)) || ((v->flags & Vert_eSeam) != seamflag)) { int i, j; VertDataCopy(_vert_getCo(v,0,ss->meshIFC.vertDataSize), vertData); v->flags = Vert_eEffected|seamflag; - for (i=0; i<v->numEdges; i++) { + for (i = 0; i < v->numEdges; i++) { CCGEdge *e = v->edges[i]; e->v0->flags |= Vert_eEffected; e->v1->flags |= Vert_eEffected; } - for (i=0; i<v->numFaces; i++) { + for (i = 0; i < v->numFaces; i++) { CCGFace *f = v->faces[i]; - for (j=0; j<f->numVerts; j++) { + for (j = 0; j < f->numVerts; j++) { FACE_getVerts(f)[j]->flags |= Vert_eEffected; } } } - } else { + } + else { if (ss->syncState!=eSyncState_Vert) { return eCCGError_InvalidSyncState; } @@ -941,12 +1033,14 @@ CCGError ccgSubSurf_syncVert(CCGSubSurf *ss, CCGVertHDL vHDL, const void *vertDa VertDataCopy(_vert_getCo(v,0,ss->meshIFC.vertDataSize), vertData); _ehash_insert(ss->vMap, (EHEntry*) v); v->flags = Vert_eEffected|seamflag; - } else if (!VertDataEqual(vertData, _vert_getCo(v, 0, ss->meshIFC.vertDataSize)) || ((v->flags & Vert_eSeam) != seamflag)) { + } + else if (!VertDataEqual(vertData, _vert_getCo(v, 0, ss->meshIFC.vertDataSize)) || ((v->flags & Vert_eSeam) != seamflag)) { *prevp = v->next; _ehash_insert(ss->vMap, (EHEntry*) v); VertDataCopy(_vert_getCo(v,0,ss->meshIFC.vertDataSize), vertData); v->flags = Vert_eEffected|Vert_eChanged|seamflag; - } else { + } + else { *prevp = v->next; _ehash_insert(ss->vMap, (EHEntry*) v); v->flags = 0; @@ -957,11 +1051,12 @@ CCGError ccgSubSurf_syncVert(CCGSubSurf *ss, CCGVertHDL vHDL, const void *vertDa return eCCGError_None; } -CCGError ccgSubSurf_syncEdge(CCGSubSurf *ss, CCGEdgeHDL eHDL, CCGVertHDL e_vHDL0, CCGVertHDL e_vHDL1, float crease, CCGEdge **e_r) { +CCGError ccgSubSurf_syncEdge(CCGSubSurf *ss, CCGEdgeHDL eHDL, CCGVertHDL e_vHDL0, CCGVertHDL e_vHDL1, float crease, CCGEdge **e_r) +{ void **prevp; CCGEdge *e = NULL, *eNew; - if (ss->syncState==eSyncState_Partial) { + if (ss->syncState == eSyncState_Partial) { e = _ehash_lookupWithPrev(ss->eMap, eHDL, &prevp); if (!e || e->v0->vHDL!=e_vHDL0 || e->v1->vHDL!=e_vHDL1 || crease!=e->crease) { CCGVert *v0 = _ehash_lookup(ss->vMap, e_vHDL0); @@ -974,17 +1069,20 @@ CCGError ccgSubSurf_syncEdge(CCGSubSurf *ss, CCGEdgeHDL eHDL, CCGVertHDL e_vHDL0 eNew->next = e->next; _edge_unlinkMarkAndFree(e, ss); - } else { + } + else { _ehash_insert(ss->eMap, (EHEntry*) eNew); } eNew->v0->flags |= Vert_eEffected; eNew->v1->flags |= Vert_eEffected; } - } else { - if (ss->syncState==eSyncState_Vert) { + } + else { + if (ss->syncState == eSyncState_Vert) { ss->syncState = eSyncState_Edge; - } else if (ss->syncState!=eSyncState_Edge) { + } + else if (ss->syncState!=eSyncState_Edge) { return eCCGError_InvalidSyncState; } @@ -996,7 +1094,8 @@ CCGError ccgSubSurf_syncEdge(CCGSubSurf *ss, CCGEdgeHDL eHDL, CCGVertHDL e_vHDL0 _ehash_insert(ss->eMap, (EHEntry*) e); e->v0->flags |= Vert_eEffected; e->v1->flags |= Vert_eEffected; - } else { + } + else { *prevp = e->next; _ehash_insert(ss->eMap, (EHEntry*) e); e->flags = 0; @@ -1011,31 +1110,32 @@ CCGError ccgSubSurf_syncEdge(CCGSubSurf *ss, CCGEdgeHDL eHDL, CCGVertHDL e_vHDL0 return eCCGError_None; } -CCGError ccgSubSurf_syncFace(CCGSubSurf *ss, CCGFaceHDL fHDL, int numVerts, CCGVertHDL *vHDLs, CCGFace **f_r) { +CCGError ccgSubSurf_syncFace(CCGSubSurf *ss, CCGFaceHDL fHDL, int numVerts, CCGVertHDL *vHDLs, CCGFace **f_r) +{ void **prevp; CCGFace *f = NULL, *fNew; int j, k, topologyChanged = 0; - if (numVerts>ss->lenTempArrays) { - ss->lenTempArrays = (numVerts<ss->lenTempArrays*2)?ss->lenTempArrays*2:numVerts; - ss->tempVerts = MEM_reallocN(ss->tempVerts, sizeof(*ss->tempVerts)*ss->lenTempArrays); - ss->tempEdges = MEM_reallocN(ss->tempEdges, sizeof(*ss->tempEdges)*ss->lenTempArrays); + if (numVerts > ss->lenTempArrays) { + ss->lenTempArrays = (numVerts < ss->lenTempArrays * 2) ? ss->lenTempArrays * 2 : numVerts; + ss->tempVerts = MEM_reallocN(ss->tempVerts, sizeof(*ss->tempVerts) * ss->lenTempArrays); + ss->tempEdges = MEM_reallocN(ss->tempEdges, sizeof(*ss->tempEdges) * ss->lenTempArrays); } - if (ss->syncState==eSyncState_Partial) { + if (ss->syncState == eSyncState_Partial) { f = _ehash_lookupWithPrev(ss->fMap, fHDL, &prevp); - for (k=0; k<numVerts; k++) { + for (k = 0; k < numVerts; k++) { ss->tempVerts[k] = _ehash_lookup(ss->vMap, vHDLs[k]); } - for (k=0; k<numVerts; k++) { - ss->tempEdges[k] = _vert_findEdgeTo(ss->tempVerts[k], ss->tempVerts[(k+1)%numVerts]); + for (k = 0; k < numVerts; k++) { + ss->tempEdges[k] = _vert_findEdgeTo(ss->tempVerts[k], ss->tempVerts[(k + 1) % numVerts]); } if (f) { if ( f->numVerts!=numVerts || - memcmp(FACE_getVerts(f), ss->tempVerts, sizeof(*ss->tempVerts)*numVerts) || - memcmp(FACE_getEdges(f), ss->tempEdges, sizeof(*ss->tempEdges)*numVerts)) + memcmp(FACE_getVerts(f), ss->tempVerts, sizeof(*ss->tempVerts) * numVerts) || + memcmp(FACE_getEdges(f), ss->tempEdges, sizeof(*ss->tempEdges) * numVerts)) topologyChanged = 1; } @@ -1049,42 +1149,46 @@ CCGError ccgSubSurf_syncFace(CCGSubSurf *ss, CCGFaceHDL fHDL, int numVerts, CCGV fNew->next = f->next; _face_unlinkMarkAndFree(f, ss); - } else { + } + else { ss->numGrids += numVerts; _ehash_insert(ss->fMap, (EHEntry*) fNew); } - for (k=0; k<numVerts; k++) + for (k = 0; k < numVerts; k++) FACE_getVerts(fNew)[k]->flags |= Vert_eEffected; } - } else { - if (ss->syncState==eSyncState_Vert || ss->syncState==eSyncState_Edge) { + } + else { + if (ss->syncState == eSyncState_Vert || ss->syncState == eSyncState_Edge) { ss->syncState = eSyncState_Face; - } else if (ss->syncState!=eSyncState_Face) { + } + else if (ss->syncState!=eSyncState_Face) { return eCCGError_InvalidSyncState; } f = _ehash_lookupWithPrev(ss->oldFMap, fHDL, &prevp); - for (k=0; k<numVerts; k++) { + for (k = 0; k < numVerts; k++) { ss->tempVerts[k] = _ehash_lookup(ss->vMap, vHDLs[k]); if (!ss->tempVerts[k]) return eCCGError_InvalidValue; } - for (k=0; k<numVerts; k++) { - ss->tempEdges[k] = _vert_findEdgeTo(ss->tempVerts[k], ss->tempVerts[(k+1)%numVerts]); + for (k = 0; k < numVerts; k++) { + ss->tempEdges[k] = _vert_findEdgeTo(ss->tempVerts[k], ss->tempVerts[(k + 1) % numVerts]); if (!ss->tempEdges[k]) { if (ss->allowEdgeCreation) { - CCGEdge *e = ss->tempEdges[k] = _edge_new((CCGEdgeHDL) -1, ss->tempVerts[k], ss->tempVerts[(k+1)%numVerts], ss->defaultCreaseValue, ss); + CCGEdge *e = ss->tempEdges[k] = _edge_new((CCGEdgeHDL) -1, ss->tempVerts[k], ss->tempVerts[(k + 1) % numVerts], ss->defaultCreaseValue, ss); _ehash_insert(ss->eMap, (EHEntry*) e); e->v0->flags |= Vert_eEffected; e->v1->flags |= Vert_eEffected; if (ss->meshIFC.edgeUserSize) { memcpy(ccgSubSurf_getEdgeUserData(ss, e), ss->defaultEdgeUserData, ss->meshIFC.edgeUserSize); } - } else { + } + else { return eCCGError_InvalidValue; } } @@ -1092,8 +1196,8 @@ CCGError ccgSubSurf_syncFace(CCGSubSurf *ss, CCGFaceHDL fHDL, int numVerts, CCGV if (f) { if ( f->numVerts!=numVerts || - memcmp(FACE_getVerts(f), ss->tempVerts, sizeof(*ss->tempVerts)*numVerts) || - memcmp(FACE_getEdges(f), ss->tempEdges, sizeof(*ss->tempEdges)*numVerts)) + memcmp(FACE_getVerts(f), ss->tempVerts, sizeof(*ss->tempVerts) * numVerts) || + memcmp(FACE_getEdges(f), ss->tempEdges, sizeof(*ss->tempEdges) * numVerts)) topologyChanged = 1; } @@ -1102,17 +1206,18 @@ CCGError ccgSubSurf_syncFace(CCGSubSurf *ss, CCGFaceHDL fHDL, int numVerts, CCGV _ehash_insert(ss->fMap, (EHEntry*) f); ss->numGrids += numVerts; - for (k=0; k<numVerts; k++) + for (k = 0; k < numVerts; k++) FACE_getVerts(f)[k]->flags |= Vert_eEffected; - } else { + } + else { *prevp = f->next; _ehash_insert(ss->fMap, (EHEntry*) f); f->flags = 0; ss->numGrids += f->numVerts; - for (j=0; j<f->numVerts; j++) { - if (FACE_getVerts(f)[j]->flags&Vert_eChanged) { - for (k=0; k<f->numVerts; k++) + for (j = 0; j < f->numVerts; j++) { + if (FACE_getVerts(f)[j]->flags & Vert_eChanged) { + for (k = 0; k < f->numVerts; k++) FACE_getVerts(f)[k]->flags |= Vert_eEffected; break; } @@ -1125,12 +1230,14 @@ CCGError ccgSubSurf_syncFace(CCGSubSurf *ss, CCGFaceHDL fHDL, int numVerts, CCGV } static void ccgSubSurf__sync(CCGSubSurf *ss); -CCGError ccgSubSurf_processSync(CCGSubSurf *ss) { - if (ss->syncState==eSyncState_Partial) { +CCGError ccgSubSurf_processSync(CCGSubSurf *ss) +{ + if (ss->syncState == eSyncState_Partial) { ss->syncState = eSyncState_None; ccgSubSurf__sync(ss); - } else if (ss->syncState) { + } + else if (ss->syncState) { _ehash_free(ss->oldFMap, (EHEntryFreeFP) _face_unlinkMarkAndFree, ss); _ehash_free(ss->oldEMap, (EHEntryFreeFP) _edge_unlinkMarkAndFree, ss); _ehash_free(ss->oldVMap, (EHEntryFreeFP) _vert_free, ss); @@ -1146,7 +1253,8 @@ CCGError ccgSubSurf_processSync(CCGSubSurf *ss) { ss->syncState = eSyncState_None; ccgSubSurf__sync(ss); - } else { + } + else { return eCCGError_InvalidSyncState; } @@ -1164,130 +1272,133 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss, int i,ptrIdx; int subdivLevels = ss->subdivLevels; int lvl = ss->subdivLevels; - int edgeSize = 1 + (1<<lvl); - int gridSize = 1 + (1<<(lvl-1)); + int edgeSize = 1 + (1 << lvl); + int gridSize = 1 + (1 << (lvl - 1)); int normalDataOffset = ss->normalDataOffset; int vertDataSize = ss->meshIFC.vertDataSize; - #pragma omp parallel for private(ptrIdx) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT) - for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) { + #pragma omp parallel for private(ptrIdx) if (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT) + for (ptrIdx = 0; ptrIdx < numEffectedF; ptrIdx++) { CCGFace *f = (CCGFace*) effectedF[ptrIdx]; int S, x, y; float no[3]; - for (S=0; S<f->numVerts; S++) { - for (y=0; y<gridSize-1; y++) - for (x=0; x<gridSize-1; x++) + for (S = 0; S < f->numVerts; S++) { + for (y = 0; y < gridSize - 1; y++) + for (x = 0; x < gridSize - 1; x++) NormZero(FACE_getIFNo(f, lvl, S, x, y)); - if (FACE_getEdges(f)[(S-1+f->numVerts)%f->numVerts]->flags&Edge_eEffected) - for (x=0; x<gridSize-1; x++) - NormZero(FACE_getIFNo(f, lvl, S, x, gridSize-1)); + if (FACE_getEdges(f)[(S - 1+f->numVerts)%f->numVerts]->flags&Edge_eEffected) + for (x = 0; x < gridSize - 1; x++) + NormZero(FACE_getIFNo(f, lvl, S, x, gridSize - 1)); if (FACE_getEdges(f)[S]->flags&Edge_eEffected) - for (y=0; y<gridSize-1; y++) - NormZero(FACE_getIFNo(f, lvl, S, gridSize-1, y)); + for (y = 0; y < gridSize - 1; y++) + NormZero(FACE_getIFNo(f, lvl, S, gridSize - 1, y)); if (FACE_getVerts(f)[S]->flags&Vert_eEffected) - NormZero(FACE_getIFNo(f, lvl, S, gridSize-1, gridSize-1)); + NormZero(FACE_getIFNo(f, lvl, S, gridSize - 1, gridSize - 1)); } - for (S=0; S<f->numVerts; S++) { - int yLimit = !(FACE_getEdges(f)[(S-1+f->numVerts)%f->numVerts]->flags&Edge_eEffected); + for (S = 0; S < f->numVerts; S++) { + int yLimit = !(FACE_getEdges(f)[(S - 1 + f->numVerts) % f->numVerts]->flags & Edge_eEffected); int xLimit = !(FACE_getEdges(f)[S]->flags&Edge_eEffected); int yLimitNext = xLimit; int xLimitPrev = yLimit; - for (y=0; y<gridSize - 1; y++) { - for (x=0; x<gridSize - 1; x++) { - int xPlusOk = (!xLimit || x<gridSize-2); - int yPlusOk = (!yLimit || y<gridSize-2); + for (y = 0; y < gridSize - 1; y++) { + for (x = 0; x < gridSize - 1; x++) { + int xPlusOk = (!xLimit || x < gridSize - 2); + int yPlusOk = (!yLimit || y < gridSize - 2); FACE_calcIFNo(f, lvl, S, x, y, no); - NormAdd(FACE_getIFNo(f, lvl, S, x+0, y+0), no); + NormAdd(FACE_getIFNo(f, lvl, S, x + 0, y + 0), no); if (xPlusOk) - NormAdd(FACE_getIFNo(f, lvl, S, x+1, y+0), no); + NormAdd(FACE_getIFNo(f, lvl, S, x + 1, y + 0), no); if (yPlusOk) - NormAdd(FACE_getIFNo(f, lvl, S, x+0, y+1), no); + NormAdd(FACE_getIFNo(f, lvl, S, x + 0, y + 1), no); if (xPlusOk && yPlusOk) { - if (x<gridSize-2 || y<gridSize-2 || FACE_getVerts(f)[S]->flags&Vert_eEffected) { - NormAdd(FACE_getIFNo(f, lvl, S, x+1, y+1), no); + if (x < gridSize - 2 || y < gridSize - 2 || FACE_getVerts(f)[S]->flags & Vert_eEffected) { + NormAdd(FACE_getIFNo(f, lvl, S, x + 1, y + 1), no); } } - if (x==0 && y==0) { + if (x == 0 && y == 0) { int K; - if (!yLimitNext || 1<gridSize-1) - NormAdd(FACE_getIFNo(f, lvl, (S+1)%f->numVerts, 0, 1), no); - if (!xLimitPrev || 1<gridSize-1) - NormAdd(FACE_getIFNo(f, lvl, (S-1+f->numVerts)%f->numVerts, 1, 0), no); + if (!yLimitNext || 1<gridSize - 1) + NormAdd(FACE_getIFNo(f, lvl, (S + 1) % f->numVerts, 0, 1), no); + if (!xLimitPrev || 1<gridSize - 1) + NormAdd(FACE_getIFNo(f, lvl, (S - 1 + f->numVerts) % f->numVerts, 1, 0), no); - for (K=0; K<f->numVerts; K++) { + for (K = 0; K < f->numVerts; K++) { if (K!=S) { NormAdd(FACE_getIFNo(f, lvl, K, 0, 0), no); } } - } else if (y==0) { - NormAdd(FACE_getIFNo(f, lvl, (S+1)%f->numVerts, 0, x), no); - if (!yLimitNext || x<gridSize-2) - NormAdd(FACE_getIFNo(f, lvl, (S+1)%f->numVerts, 0, x+1), no); - } else if (x==0) { - NormAdd(FACE_getIFNo(f, lvl, (S-1+f->numVerts)%f->numVerts, y, 0), no); - if (!xLimitPrev || y<gridSize-2) - NormAdd(FACE_getIFNo(f, lvl, (S-1+f->numVerts)%f->numVerts, y+1, 0), no); + } + else if (y == 0) { + NormAdd(FACE_getIFNo(f, lvl, (S + 1) % f->numVerts, 0, x), no); + if (!yLimitNext || x < gridSize - 2) + NormAdd(FACE_getIFNo(f, lvl, (S + 1) % f->numVerts, 0, x + 1), no); + } + else if (x == 0) { + NormAdd(FACE_getIFNo(f, lvl, (S - 1 + f->numVerts) % f->numVerts, y, 0), no); + if (!xLimitPrev || y < gridSize - 2) + NormAdd(FACE_getIFNo(f, lvl, (S - 1 + f->numVerts) % f->numVerts, y + 1, 0), no); } } } } } // XXX can I reduce the number of normalisations here? - for (ptrIdx=0; ptrIdx<numEffectedV; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedV; ptrIdx++) { CCGVert *v = (CCGVert*) effectedV[ptrIdx]; float length, *no = _vert_getNo(v, lvl, vertDataSize, normalDataOffset); NormZero(no); - for (i=0; i<v->numFaces; i++) { + for (i = 0; i < v->numFaces; i++) { CCGFace *f = v->faces[i]; - NormAdd(no, FACE_getIFNo(f, lvl, _face_getVertIndex(f,v), gridSize-1, gridSize-1)); + NormAdd(no, FACE_getIFNo(f, lvl, _face_getVertIndex(f,v), gridSize - 1, gridSize - 1)); } - length = sqrt(no[0]*no[0] + no[1]*no[1] + no[2]*no[2]); + length = sqrt(no[0] * no[0] + no[1] * no[1] + no[2] * no[2]); - if (length>EPSILON) { + if (length > EPSILON) { float invLength = 1.0f/length; no[0] *= invLength; no[1] *= invLength; no[2] *= invLength; - } else { + } + else { NormZero(no); } - for (i=0; i<v->numFaces; i++) { + for (i = 0; i < v->numFaces; i++) { CCGFace *f = v->faces[i]; - NormCopy(FACE_getIFNo(f, lvl, _face_getVertIndex(f,v), gridSize-1, gridSize-1), no); + NormCopy(FACE_getIFNo(f, lvl, _face_getVertIndex(f,v), gridSize - 1, gridSize - 1), no); } } - for (ptrIdx=0; ptrIdx<numEffectedE; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedE; ptrIdx++) { CCGEdge *e = (CCGEdge*) effectedE[ptrIdx]; if (e->numFaces) { - CCGFace *fLast = e->faces[e->numFaces-1]; + CCGFace *fLast = e->faces[e->numFaces - 1]; int x; - for (i=0; i<e->numFaces-1; i++) { + for (i = 0; i < e->numFaces - 1; i++) { CCGFace *f = e->faces[i]; - for (x=1; x<edgeSize-1; x++) { + for (x = 1; x < edgeSize - 1; x++) { NormAdd(_face_getIFNoEdge(fLast, e, lvl, x, 0, subdivLevels, vertDataSize, normalDataOffset), _face_getIFNoEdge(f, e, lvl, x, 0, subdivLevels, vertDataSize, normalDataOffset)); } } - for (i=0; i<e->numFaces-1; i++) { + for (i = 0; i < e->numFaces - 1; i++) { CCGFace *f = e->faces[i]; - for (x=1; x<edgeSize-1; x++) { + for (x = 1; x < edgeSize - 1; x++) { NormCopy(_face_getIFNoEdge(f, e, lvl, x, 0, subdivLevels, vertDataSize, normalDataOffset), _face_getIFNoEdge(fLast, e, lvl, x, 0, subdivLevels, vertDataSize, normalDataOffset)); } @@ -1295,50 +1406,51 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss, } } - #pragma omp parallel for private(ptrIdx) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT) - for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) { + #pragma omp parallel for private(ptrIdx) if (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT) + for (ptrIdx = 0; ptrIdx < numEffectedF; ptrIdx++) { CCGFace *f = (CCGFace*) effectedF[ptrIdx]; int S, x, y; - for (S=0; S<f->numVerts; S++) { - NormCopy(FACE_getIFNo(f, lvl, (S+1)%f->numVerts, 0, gridSize-1), - FACE_getIFNo(f, lvl, S, gridSize-1, 0)); + for (S = 0; S < f->numVerts; S++) { + NormCopy(FACE_getIFNo(f, lvl, (S + 1) % f->numVerts, 0, gridSize - 1), + FACE_getIFNo(f, lvl, S, gridSize - 1, 0)); } - for (S=0; S<f->numVerts; S++) { - for (y=0; y<gridSize; y++) { - for (x=0; x<gridSize; x++) { + for (S = 0; S < f->numVerts; S++) { + for (y = 0; y < gridSize; y++) { + for (x = 0; x < gridSize; x++) { float *no = FACE_getIFNo(f, lvl, S, x, y); - float length = sqrt(no[0]*no[0] + no[1]*no[1] + no[2]*no[2]); + float length = sqrt(no[0] * no[0] + no[1] * no[1] + no[2] * no[2]); - if (length>EPSILON) { + if (length > EPSILON) { float invLength = 1.0f/length; no[0] *= invLength; no[1] *= invLength; no[2] *= invLength; - } else { + } + else { NormZero(no); } } } - VertDataCopy((float*)((byte*)FACE_getCenterData(f) + normalDataOffset), + VertDataCopy((float *)((byte *)FACE_getCenterData(f) + normalDataOffset), FACE_getIFNo(f, lvl, S, 0, 0)); - for (x=1; x<gridSize-1; x++) + for (x = 1; x < gridSize - 1; x++) NormCopy(FACE_getIENo(f, lvl, S, x), FACE_getIFNo(f, lvl, S, x, 0)); } } - for (ptrIdx=0; ptrIdx<numEffectedE; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedE; ptrIdx++) { CCGEdge *e = (CCGEdge*) effectedE[ptrIdx]; if (e->numFaces) { CCGFace *f = e->faces[0]; int x; - for (x=0; x<edgeSize; x++) + for (x = 0; x < edgeSize; x++) NormCopy(EDGE_getNo(e, lvl, x), _face_getIFNoEdge(f, e, lvl, x, 0, subdivLevels, vertDataSize, normalDataOffset)); } @@ -1349,7 +1461,7 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss, * most likely not used so just zero out. */ int x; - for (x=0; x<edgeSize; x++) { + for (x = 0; x < edgeSize; x++) { NormZero(EDGE_getNo(e, lvl, x)); } } @@ -1361,34 +1473,36 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss, #define EDGE_getCo(e, lvl, x) _edge_getCo(e, lvl, x, vertDataSize) #define FACE_getIECo(f, lvl, S, x) _face_getIECo(f, lvl, S, x, subdivLevels, vertDataSize) #define FACE_getIFCo(f, lvl, S, x, y) _face_getIFCo(f, lvl, S, x, y, subdivLevels, vertDataSize) + static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, - CCGVert **effectedV, CCGEdge **effectedE, CCGFace **effectedF, - int numEffectedV, int numEffectedE, int numEffectedF, int curLvl) { + CCGVert **effectedV, CCGEdge **effectedE, CCGFace **effectedF, + int numEffectedV, int numEffectedE, int numEffectedF, int curLvl) +{ int subdivLevels = ss->subdivLevels; - int edgeSize = 1 + (1<<curLvl); - int gridSize = 1 + (1<<(curLvl-1)); - int nextLvl = curLvl+1; + int edgeSize = 1 + (1 << curLvl); + int gridSize = 1 + (1 << (curLvl - 1)); + int nextLvl = curLvl + 1; int ptrIdx, cornerIdx, i; int vertDataSize = ss->meshIFC.vertDataSize; void *q = ss->q, *r = ss->r; - #pragma omp parallel for private(ptrIdx) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT) - for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) { + #pragma omp parallel for private(ptrIdx) if (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT) + for (ptrIdx = 0; ptrIdx < numEffectedF; ptrIdx++) { CCGFace *f = (CCGFace*) effectedF[ptrIdx]; int S, x, y; /* interior face midpoints * o old interior face points */ - for (S=0; S<f->numVerts; S++) { - for (y=0; y<gridSize-1; y++) { - for (x=0; x<gridSize-1; x++) { + for (S = 0; S < f->numVerts; S++) { + for (y = 0; y < gridSize - 1; y++) { + for (x = 0; x < gridSize - 1; x++) { int fx = 1 + 2*x; int fy = 1 + 2*y; - void *co0 = FACE_getIFCo(f, curLvl, S, x+0, y+0); - void *co1 = FACE_getIFCo(f, curLvl, S, x+1, y+0); - void *co2 = FACE_getIFCo(f, curLvl, S, x+1, y+1); - void *co3 = FACE_getIFCo(f, curLvl, S, x+0, y+1); + void *co0 = FACE_getIFCo(f, curLvl, S, x + 0, y + 0); + void *co1 = FACE_getIFCo(f, curLvl, S, x + 1, y + 0); + void *co2 = FACE_getIFCo(f, curLvl, S, x + 1, y + 1); + void *co3 = FACE_getIFCo(f, curLvl, S, x + 0, y + 1); void *co = FACE_getIFCo(f, nextLvl, S, fx, fy); VertDataAvg4(co, co0, co1, co2, co3); @@ -1400,14 +1514,14 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, * o old interior edge points * o new interior face midpoints */ - for (S=0; S<f->numVerts; S++) { - for (x=0; x<gridSize-1; x++) { - int fx = x*2 + 1; - void *co0 = FACE_getIECo(f, curLvl, S, x+0); - void *co1 = FACE_getIECo(f, curLvl, S, x+1); - void *co2 = FACE_getIFCo(f, nextLvl, (S+1)%f->numVerts, 1, fx); + for (S = 0; S < f->numVerts; S++) { + for (x = 0; x < gridSize - 1; x++) { + int fx = x * 2 + 1; + void *co0 = FACE_getIECo(f, curLvl, S, x + 0); + void *co1 = FACE_getIECo(f, curLvl, S, x + 1); + void *co2 = FACE_getIFCo(f, nextLvl, (S + 1) % f->numVerts, 1, fx); void *co3 = FACE_getIFCo(f, nextLvl, S, fx, 1); - void *co = FACE_getIECo(f, nextLvl, S, fx); + void *co = FACE_getIECo(f, nextLvl, S, fx); VertDataAvg4(co, co0, co1, co2, co3); } @@ -1418,30 +1532,30 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, */ /* vertical */ - for (x=1; x<gridSize-1; x++) { - for (y=0; y<gridSize-1; y++) { - int fx = x*2; - int fy = y*2+1; - void *co0 = FACE_getIFCo(f, curLvl, S, x, y+0); - void *co1 = FACE_getIFCo(f, curLvl, S, x, y+1); - void *co2 = FACE_getIFCo(f, nextLvl, S, fx-1, fy); - void *co3 = FACE_getIFCo(f, nextLvl, S, fx+1, fy); - void *co = FACE_getIFCo(f, nextLvl, S, fx, fy); + for (x = 1; x < gridSize - 1; x++) { + for (y = 0; y < gridSize - 1; y++) { + int fx = x * 2; + int fy = y * 2 + 1; + void *co0 = FACE_getIFCo(f, curLvl, S, x, y + 0); + void *co1 = FACE_getIFCo(f, curLvl, S, x, y + 1); + void *co2 = FACE_getIFCo(f, nextLvl, S, fx - 1, fy); + void *co3 = FACE_getIFCo(f, nextLvl, S, fx + 1, fy); + void *co = FACE_getIFCo(f, nextLvl, S, fx, fy); VertDataAvg4(co, co0, co1, co2, co3); } } /* horizontal */ - for (y=1; y<gridSize-1; y++) { - for (x=0; x<gridSize-1; x++) { - int fx = x*2+1; - int fy = y*2; - void *co0 = FACE_getIFCo(f, curLvl, S, x+0, y); - void *co1 = FACE_getIFCo(f, curLvl, S, x+1, y); - void *co2 = FACE_getIFCo(f, nextLvl, S, fx, fy-1); - void *co3 = FACE_getIFCo(f, nextLvl, S, fx, fy+1); - void *co = FACE_getIFCo(f, nextLvl, S, fx, fy); + for (y = 1; y < gridSize - 1; y++) { + for (x = 0; x < gridSize - 1; x++) { + int fx = x * 2 + 1; + int fy = y * 2; + void *co0 = FACE_getIFCo(f, curLvl, S, x + 0, y); + void *co1 = FACE_getIFCo(f, curLvl, S, x + 1, y); + void *co2 = FACE_getIFCo(f, nextLvl, S, fx, fy - 1); + void *co3 = FACE_getIFCo(f, nextLvl, S, fx, fy + 1); + void *co = FACE_getIFCo(f, nextLvl, S, fx, fy); VertDataAvg4(co, co0, co1, co2, co3); } @@ -1453,40 +1567,41 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, * o old exterior edge points * o new interior face midpoints */ - for (ptrIdx=0; ptrIdx<numEffectedE; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedE; ptrIdx++) { CCGEdge *e = (CCGEdge*) effectedE[ptrIdx]; float sharpness = EDGE_getSharpness(e, curLvl); int x, j; if (_edge_isBoundary(e) || sharpness > 1.0f) { - for (x=0; x<edgeSize-1; x++) { - int fx = x*2 + 1; - void *co0 = EDGE_getCo(e, curLvl, x+0); - void *co1 = EDGE_getCo(e, curLvl, x+1); - void *co = EDGE_getCo(e, nextLvl, fx); + for (x = 0; x < edgeSize - 1; x++) { + int fx = x * 2 + 1; + void *co0 = EDGE_getCo(e, curLvl, x + 0); + void *co1 = EDGE_getCo(e, curLvl, x + 1); + void *co = EDGE_getCo(e, nextLvl, fx); VertDataCopy(co, co0); VertDataAdd(co, co1); VertDataMulN(co, 0.5f); } - } else { - for (x=0; x<edgeSize-1; x++) { - int fx = x*2 + 1; - void *co0 = EDGE_getCo(e, curLvl, x+0); - void *co1 = EDGE_getCo(e, curLvl, x+1); - void *co = EDGE_getCo(e, nextLvl, fx); + } + else { + for (x = 0; x < edgeSize - 1; x++) { + int fx = x * 2 + 1; + void *co0 = EDGE_getCo(e, curLvl, x + 0); + void *co1 = EDGE_getCo(e, curLvl, x + 1); + void *co = EDGE_getCo(e, nextLvl, fx); int numFaces = 0; VertDataCopy(q, co0); VertDataAdd(q, co1); - for (j=0; j<e->numFaces; j++) { + for (j = 0; j < e->numFaces; j++) { CCGFace *f = e->faces[j]; VertDataAdd(q, _face_getIFCoEdge(f, e, nextLvl, fx, 1, subdivLevels, vertDataSize)); numFaces++; } - VertDataMulN(q, 1.0f/(2.0f+numFaces)); + VertDataMulN(q, 1.0f / (2.0f + numFaces)); VertDataCopy(r, co0); VertDataAdd(r, co1); @@ -1505,7 +1620,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, * o old exterior edge points * o new interior face midpoints */ - for (ptrIdx=0; ptrIdx<numEffectedV; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedV; ptrIdx++) { CCGVert *v = (CCGVert*) effectedV[ptrIdx]; void *co = VERT_getCo(v, curLvl); void *nCo = VERT_getCo(v, nextLvl); @@ -1513,7 +1628,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, float avgSharpness = 0.0; int j, seam = VERT_seam(v), seamEdges = 0; - for (j=0; j<v->numEdges; j++) { + for (j = 0; j < v->numEdges; j++) { CCGEdge *e = v->edges[j]; float sharpness = EDGE_getSharpness(e, curLvl); @@ -1523,12 +1638,13 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, if (sharpness!=0.0f) { sharpCount++; avgSharpness += sharpness; - } else { + } + else { allSharp = 0; } } - if(sharpCount) { + if (sharpCount) { avgSharpness /= sharpCount; if (avgSharpness > 1.0f) { avgSharpness = 1.0f; @@ -1540,11 +1656,12 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, if (!v->numEdges) { VertDataCopy(nCo, co); - } else if (_vert_isBoundary(v)) { + } + else if (_vert_isBoundary(v)) { int numBoundary = 0; VertDataZero(r); - for (j=0; j<v->numEdges; j++) { + for (j = 0; j < v->numEdges; j++) { CCGEdge *e = v->edges[j]; if (_edge_isBoundary(e)) { VertDataAdd(r, _edge_getCoVert(e, v, curLvl, 1, vertDataSize)); @@ -1556,19 +1673,20 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, VertDataMulN(nCo, 0.75f); VertDataMulN(r, 0.25f/numBoundary); VertDataAdd(nCo, r); - } else { - int cornerIdx = (1 + (1<<(curLvl))) - 2; + } + else { + int cornerIdx = (1 + (1 << (curLvl))) - 2; int numEdges = 0, numFaces = 0; VertDataZero(q); - for (j=0; j<v->numFaces; j++) { + for (j = 0; j < v->numFaces; j++) { CCGFace *f = v->faces[j]; VertDataAdd(q, FACE_getIFCo(f, nextLvl, _face_getVertIndex(f,v), cornerIdx, cornerIdx)); numFaces++; } VertDataMulN(q, 1.0f/numFaces); VertDataZero(r); - for (j=0; j<v->numEdges; j++) { + for (j = 0; j < v->numEdges; j++) { CCGEdge *e = v->edges[j]; VertDataAdd(r, _edge_getCoVert(e, v, curLvl, 1,vertDataSize)); numEdges++; @@ -1576,7 +1694,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, VertDataMulN(r, 1.0f/numEdges); VertDataCopy(nCo, co); - VertDataMulN(nCo, numEdges-2.0f); + VertDataMulN(nCo, numEdges - 2.0f); VertDataAdd(nCo, q); VertDataAdd(nCo, r); VertDataMulN(nCo, 1.0f/numEdges); @@ -1591,14 +1709,15 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, allSharp = 1; } - for (j=0; j<v->numEdges; j++) { + for (j = 0; j < v->numEdges; j++) { CCGEdge *e = v->edges[j]; float sharpness = EDGE_getSharpness(e, curLvl); if (seam) { if (_edge_isBoundary(e)) VertDataAdd(q, _edge_getCoVert(e, v, curLvl, 1, vertDataSize)); - } else if (sharpness != 0.0f) { + } + else if (sharpness != 0.0f) { VertDataAdd(q, _edge_getCoVert(e, v, curLvl, 1, vertDataSize)); } } @@ -1606,7 +1725,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, VertDataMulN(q, (float) 1/sharpCount); if (sharpCount!=2 || allSharp) { - // q = q + (co-q)*avgSharpness + // q = q + (co-q) * avgSharpness VertDataCopy(r, co); VertDataSub(r, q); VertDataMulN(r, avgSharpness); @@ -1619,7 +1738,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, VertDataMulN(q, .25f); VertDataAdd(r, q); - // nCo = nCo + (r-nCo)*avgSharpness + // nCo = nCo + (r-nCo) * avgSharpness VertDataSub(r, nCo); VertDataMulN(r, avgSharpness); VertDataAdd(nCo, r); @@ -1631,7 +1750,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, * o old exterior edge midpoints * o new interior face midpoints */ - for (ptrIdx=0; ptrIdx<numEffectedE; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedE; ptrIdx++) { CCGEdge *e = (CCGEdge*) effectedE[ptrIdx]; float sharpness = EDGE_getSharpness(e, curLvl); int sharpCount = 0; @@ -1645,57 +1764,59 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, if (avgSharpness > 1.0f) { avgSharpness = 1.0f; } - } else { + } + else { sharpCount = 0; avgSharpness = 0; } if (_edge_isBoundary(e) && (!e->numFaces || sharpCount<2)) { - for (x=1; x<edgeSize-1; x++) { - int fx = x*2; + for (x = 1; x < edgeSize - 1; x++) { + int fx = x * 2; void *co = EDGE_getCo(e, curLvl, x); void *nCo = EDGE_getCo(e, nextLvl, fx); - VertDataCopy(r, EDGE_getCo(e, curLvl, x-1)); - VertDataAdd(r, EDGE_getCo(e, curLvl, x+1)); + VertDataCopy(r, EDGE_getCo(e, curLvl, x - 1)); + VertDataAdd(r, EDGE_getCo(e, curLvl, x + 1)); VertDataMulN(r, 0.5f); VertDataCopy(nCo, co); VertDataMulN(nCo, 0.75f); VertDataMulN(r, 0.25f); VertDataAdd(nCo, r); } - } else { - for (x=1; x<edgeSize-1; x++) { - int fx = x*2; + } + else { + for (x = 1; x < edgeSize - 1; x++) { + int fx = x * 2; void *co = EDGE_getCo(e, curLvl, x); void *nCo = EDGE_getCo(e, nextLvl, fx); int numFaces = 0; VertDataZero(q); VertDataZero(r); - VertDataAdd(r, EDGE_getCo(e, curLvl, x-1)); - VertDataAdd(r, EDGE_getCo(e, curLvl, x+1)); - for (j=0; j<e->numFaces; j++) { + VertDataAdd(r, EDGE_getCo(e, curLvl, x - 1)); + VertDataAdd(r, EDGE_getCo(e, curLvl, x + 1)); + for (j = 0; j < e->numFaces; j++) { CCGFace *f = e->faces[j]; - VertDataAdd(q, _face_getIFCoEdge(f, e, nextLvl, fx-1, 1, subdivLevels, vertDataSize)); - VertDataAdd(q, _face_getIFCoEdge(f, e, nextLvl, fx+1, 1, subdivLevels, vertDataSize)); + VertDataAdd(q, _face_getIFCoEdge(f, e, nextLvl, fx - 1, 1, subdivLevels, vertDataSize)); + VertDataAdd(q, _face_getIFCoEdge(f, e, nextLvl, fx + 1, 1, subdivLevels, vertDataSize)); VertDataAdd(r, _face_getIFCoEdge(f, e, curLvl, x, 1, subdivLevels, vertDataSize)); numFaces++; } - VertDataMulN(q, 1.0f/(numFaces*2.0f)); - VertDataMulN(r, 1.0f/(2.0f + numFaces)); + VertDataMulN(q, 1.0f / (numFaces * 2.0f)); + VertDataMulN(r, 1.0f / (2.0f + numFaces)); VertDataCopy(nCo, co); VertDataMulN(nCo, (float) numFaces); VertDataAdd(nCo, q); VertDataAdd(nCo, r); - VertDataMulN(nCo, 1.0f/(2+numFaces)); + VertDataMulN(nCo, 1.0f / (2 + numFaces)); - if (sharpCount==2) { + if (sharpCount == 2) { VertDataCopy(q, co); VertDataMulN(q, 6.0f); - VertDataAdd(q, EDGE_getCo(e, curLvl, x-1)); - VertDataAdd(q, EDGE_getCo(e, curLvl, x+1)); + VertDataAdd(q, EDGE_getCo(e, curLvl, x - 1)); + VertDataAdd(q, EDGE_getCo(e, curLvl, x + 1)); VertDataMulN(q, 1/8.0f); VertDataSub(q, nCo); @@ -1706,7 +1827,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, } } - #pragma omp parallel private(ptrIdx) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT) + #pragma omp parallel private(ptrIdx) if (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT) { void *q, *r; @@ -1717,7 +1838,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, } #pragma omp for schedule(static) - for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedF; ptrIdx++) { CCGFace *f = (CCGFace*) effectedF[ptrIdx]; int S, x, y; @@ -1727,43 +1848,45 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, * o new interior face midpoints */ VertDataZero(q); - for (S=0; S<f->numVerts; S++) { + for (S = 0; S < f->numVerts; S++) { VertDataAdd(q, FACE_getIFCo(f, nextLvl, S, 1, 1)); } VertDataMulN(q, 1.0f/f->numVerts); VertDataZero(r); - for (S=0; S<f->numVerts; S++) { + for (S = 0; S < f->numVerts; S++) { VertDataAdd(r, FACE_getIECo(f, curLvl, S, 1)); } VertDataMulN(r, 1.0f/f->numVerts); - VertDataMulN(FACE_getCenterData(f), f->numVerts-2.0f); + VertDataMulN(FACE_getCenterData(f), f->numVerts - 2.0f); VertDataAdd(FACE_getCenterData(f), q); VertDataAdd(FACE_getCenterData(f), r); VertDataMulN(FACE_getCenterData(f), 1.0f/f->numVerts); - for (S=0; S<f->numVerts; S++) { + for (S = 0; S < f->numVerts; S++) { /* interior face shift * o old interior face point (shifting) * o new interior edge midpoints * o new interior face midpoints */ - for (x=1; x<gridSize-1; x++) { - for (y=1; y<gridSize-1; y++) { - int fx = x*2; - int fy = y*2; + for (x = 1; x < gridSize - 1; x++) { + for (y = 1; y < gridSize - 1; y++) { + int fx = x * 2; + int fy = y * 2; void *co = FACE_getIFCo(f, curLvl, S, x, y); void *nCo = FACE_getIFCo(f, nextLvl, S, fx, fy); - VertDataAvg4(q, FACE_getIFCo(f, nextLvl, S, fx-1, fy-1), - FACE_getIFCo(f, nextLvl, S, fx+1, fy-1), - FACE_getIFCo(f, nextLvl, S, fx+1, fy+1), - FACE_getIFCo(f, nextLvl, S, fx-1, fy+1)); - - VertDataAvg4(r, FACE_getIFCo(f, nextLvl, S, fx-1, fy+0), - FACE_getIFCo(f, nextLvl, S, fx+1, fy+0), - FACE_getIFCo(f, nextLvl, S, fx+0, fy-1), - FACE_getIFCo(f, nextLvl, S, fx+0, fy+1)); + VertDataAvg4(q, + FACE_getIFCo(f, nextLvl, S, fx - 1, fy - 1), + FACE_getIFCo(f, nextLvl, S, fx + 1, fy - 1), + FACE_getIFCo(f, nextLvl, S, fx + 1, fy + 1), + FACE_getIFCo(f, nextLvl, S, fx - 1, fy + 1)); + + VertDataAvg4(r, + FACE_getIFCo(f, nextLvl, S, fx - 1, fy + 0), + FACE_getIFCo(f, nextLvl, S, fx + 1, fy + 0), + FACE_getIFCo(f, nextLvl, S, fx + 0, fy - 1), + FACE_getIFCo(f, nextLvl, S, fx + 0, fy + 1)); VertDataCopy(nCo, co); VertDataSub(nCo, q); @@ -1777,20 +1900,22 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, * o new interior edge midpoints * o new interior face midpoints */ - for (x=1; x<gridSize-1; x++) { - int fx = x*2; + for (x = 1; x < gridSize - 1; x++) { + int fx = x * 2; void *co = FACE_getIECo(f, curLvl, S, x); void *nCo = FACE_getIECo(f, nextLvl, S, fx); - VertDataAvg4(q, FACE_getIFCo(f, nextLvl, (S+1)%f->numVerts, 1, fx-1), - FACE_getIFCo(f, nextLvl, (S+1)%f->numVerts, 1, fx+1), - FACE_getIFCo(f, nextLvl, S, fx+1, +1), - FACE_getIFCo(f, nextLvl, S, fx-1, +1)); - - VertDataAvg4(r, FACE_getIECo(f, nextLvl, S, fx-1), - FACE_getIECo(f, nextLvl, S, fx+1), - FACE_getIFCo(f, nextLvl, (S+1)%f->numVerts, 1, fx), - FACE_getIFCo(f, nextLvl, S, fx, 1)); + VertDataAvg4(q, + FACE_getIFCo(f, nextLvl, (S + 1) % f->numVerts, 1, fx - 1), + FACE_getIFCo(f, nextLvl, (S + 1) % f->numVerts, 1, fx + 1), + FACE_getIFCo(f, nextLvl, S, fx + 1, + 1), + FACE_getIFCo(f, nextLvl, S, fx - 1, + 1)); + + VertDataAvg4(r, + FACE_getIECo(f, nextLvl, S, fx - 1), + FACE_getIECo(f, nextLvl, S, fx + 1), + FACE_getIFCo(f, nextLvl, (S + 1) % f->numVerts, 1, fx), + FACE_getIFCo(f, nextLvl, S, fx, 1)); VertDataCopy(nCo, co); VertDataSub(nCo, q); @@ -1808,37 +1933,37 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, } /* copy down */ - edgeSize = 1 + (1<<(nextLvl)); - gridSize = 1 + (1<<((nextLvl)-1)); - cornerIdx = gridSize-1; + edgeSize = 1 + (1 << (nextLvl)); + gridSize = 1 + (1 << ((nextLvl)-1)); + cornerIdx = gridSize - 1; - #pragma omp parallel for private(i) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT) - for (i=0; i<numEffectedE; i++) { + #pragma omp parallel for private(i) if (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT) + for (i = 0; i < numEffectedE; i++) { CCGEdge *e = effectedE[i]; VertDataCopy(EDGE_getCo(e, nextLvl, 0), VERT_getCo(e->v0, nextLvl)); - VertDataCopy(EDGE_getCo(e, nextLvl, edgeSize-1), VERT_getCo(e->v1, nextLvl)); + VertDataCopy(EDGE_getCo(e, nextLvl, edgeSize - 1), VERT_getCo(e->v1, nextLvl)); } - #pragma omp parallel for private(i) if(numEffectedF*edgeSize*edgeSize*4 >= CCG_OMP_LIMIT) - for (i=0; i<numEffectedF; i++) { + #pragma omp parallel for private(i) if (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT) + for (i = 0; i < numEffectedF; i++) { CCGFace *f = effectedF[i]; int S, x; - for (S=0; S<f->numVerts; S++) { + for (S = 0; S < f->numVerts; S++) { CCGEdge *e = FACE_getEdges(f)[S]; - CCGEdge *prevE = FACE_getEdges(f)[(S+f->numVerts-1)%f->numVerts]; + CCGEdge *prevE = FACE_getEdges(f)[(S + f->numVerts - 1) % f->numVerts]; VertDataCopy(FACE_getIFCo(f, nextLvl, S, 0, 0), FACE_getCenterData(f)); VertDataCopy(FACE_getIECo(f, nextLvl, S, 0), FACE_getCenterData(f)); VertDataCopy(FACE_getIFCo(f, nextLvl, S, cornerIdx, cornerIdx), VERT_getCo(FACE_getVerts(f)[S], nextLvl)); VertDataCopy(FACE_getIECo(f, nextLvl, S, cornerIdx), EDGE_getCo(FACE_getEdges(f)[S], nextLvl, cornerIdx)); - for (x=1; x<gridSize-1; x++) { + for (x = 1; x < gridSize - 1; x++) { void *co = FACE_getIECo(f, nextLvl, S, x); VertDataCopy(FACE_getIFCo(f, nextLvl, S, x, 0), co); - VertDataCopy(FACE_getIFCo(f, nextLvl, (S+1)%f->numVerts, 0, x), co); + VertDataCopy(FACE_getIFCo(f, nextLvl, (S + 1) % f->numVerts, 0, x), co); } - for (x=0; x<gridSize-1; x++) { - int eI = gridSize-1-x; + for (x = 0; x < gridSize - 1; x++) { + int eI = gridSize - 1 - x; VertDataCopy(FACE_getIFCo(f, nextLvl, S, cornerIdx, x), _edge_getCoVert(e, FACE_getVerts(f)[S], nextLvl, eI,vertDataSize)); VertDataCopy(FACE_getIFCo(f, nextLvl, S, x, cornerIdx), _edge_getCoVert(prevE, FACE_getVerts(f)[S], nextLvl, eI,vertDataSize)); } @@ -1847,7 +1972,8 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss, } -static void ccgSubSurf__sync(CCGSubSurf *ss) { +static void ccgSubSurf__sync(CCGSubSurf *ss) +{ CCGVert **effectedV; CCGEdge **effectedE; CCGFace **effectedF; @@ -1858,17 +1984,17 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { int curLvl, nextLvl; void *q = ss->q, *r = ss->r; - effectedV = MEM_mallocN(sizeof(*effectedV)*ss->vMap->numEntries, "CCGSubsurf effectedV"); - effectedE = MEM_mallocN(sizeof(*effectedE)*ss->eMap->numEntries, "CCGSubsurf effectedE"); - effectedF = MEM_mallocN(sizeof(*effectedF)*ss->fMap->numEntries, "CCGSubsurf effectedF"); + effectedV = MEM_mallocN(sizeof(*effectedV) * ss->vMap->numEntries, "CCGSubsurf effectedV"); + effectedE = MEM_mallocN(sizeof(*effectedE) * ss->eMap->numEntries, "CCGSubsurf effectedE"); + effectedF = MEM_mallocN(sizeof(*effectedF) * ss->fMap->numEntries, "CCGSubsurf effectedF"); numEffectedV = numEffectedE = numEffectedF = 0; - for (i=0; i<ss->vMap->curSize; i++) { + for (i = 0; i < ss->vMap->curSize; i++) { CCGVert *v = (CCGVert*) ss->vMap->buckets[i]; for (; v; v = v->next) { if (v->flags&Vert_eEffected) { effectedV[numEffectedV++] = v; - for (j=0; j<v->numEdges; j++) { + for (j = 0; j < v->numEdges; j++) { CCGEdge *e = v->edges[j]; if (!(e->flags&Edge_eEffected)) { effectedE[numEffectedE++] = e; @@ -1876,7 +2002,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { } } - for (j=0; j<v->numFaces; j++) { + for (j = 0; j < v->numFaces; j++) { CCGFace *f = v->faces[j]; if (!(f->flags&Face_eEffected)) { effectedF[numEffectedF++] = f; @@ -1888,20 +2014,20 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { } curLvl = 0; - nextLvl = curLvl+1; + nextLvl = curLvl + 1; - for (ptrIdx=0; ptrIdx<numEffectedF; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedF; ptrIdx++) { CCGFace *f = effectedF[ptrIdx]; void *co = FACE_getCenterData(f); VertDataZero(co); - for (i=0; i<f->numVerts; i++) { + for (i = 0; i < f->numVerts; i++) { VertDataAdd(co, VERT_getCo(FACE_getVerts(f)[i], curLvl)); } VertDataMulN(co, 1.0f/f->numVerts); f->flags = 0; } - for (ptrIdx=0; ptrIdx<numEffectedE; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedE; ptrIdx++) { CCGEdge *e = effectedE[ptrIdx]; void *co = EDGE_getCo(e, nextLvl, 1); float sharpness = EDGE_getSharpness(e, curLvl); @@ -1910,16 +2036,17 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { VertDataCopy(co, VERT_getCo(e->v0, curLvl)); VertDataAdd(co, VERT_getCo(e->v1, curLvl)); VertDataMulN(co, 0.5f); - } else { + } + else { int numFaces = 0; VertDataCopy(q, VERT_getCo(e->v0, curLvl)); VertDataAdd(q, VERT_getCo(e->v1, curLvl)); - for (i=0; i<e->numFaces; i++) { + for (i = 0; i < e->numFaces; i++) { CCGFace *f = e->faces[i]; VertDataAdd(q, FACE_getCenterData(f)); numFaces++; } - VertDataMulN(q, 1.0f/(2.0f+numFaces)); + VertDataMulN(q, 1.0f / (2.0f + numFaces)); VertDataCopy(r, VERT_getCo(e->v0, curLvl)); VertDataAdd(r, VERT_getCo(e->v1, curLvl)); @@ -1933,7 +2060,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { // edge flags cleared later } - for (ptrIdx=0; ptrIdx<numEffectedV; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedV; ptrIdx++) { CCGVert *v = effectedV[ptrIdx]; void *co = VERT_getCo(v, curLvl); void *nCo = VERT_getCo(v, nextLvl); @@ -1941,7 +2068,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { float avgSharpness = 0.0; int seam = VERT_seam(v), seamEdges = 0; - for (i=0; i<v->numEdges; i++) { + for (i = 0; i < v->numEdges; i++) { CCGEdge *e = v->edges[i]; float sharpness = EDGE_getSharpness(e, curLvl); @@ -1951,12 +2078,13 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { if (sharpness!=0.0f) { sharpCount++; avgSharpness += sharpness; - } else { + } + else { allSharp = 0; } } - if(sharpCount) { + if (sharpCount) { avgSharpness /= sharpCount; if (avgSharpness > 1.0f) { avgSharpness = 1.0f; @@ -1968,11 +2096,12 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { if (!v->numEdges) { VertDataCopy(nCo, co); - } else if (_vert_isBoundary(v)) { + } + else if (_vert_isBoundary(v)) { int numBoundary = 0; VertDataZero(r); - for (i=0; i<v->numEdges; i++) { + for (i = 0; i < v->numEdges; i++) { CCGEdge *e = v->edges[i]; if (_edge_isBoundary(e)) { VertDataAdd(r, VERT_getCo(_edge_getOtherVert(e, v), curLvl)); @@ -1983,18 +2112,19 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { VertDataMulN(nCo, 0.75f); VertDataMulN(r, 0.25f/numBoundary); VertDataAdd(nCo, r); - } else { + } + else { int numEdges = 0, numFaces = 0; VertDataZero(q); - for (i=0; i<v->numFaces; i++) { + for (i = 0; i < v->numFaces; i++) { CCGFace *f = v->faces[i]; VertDataAdd(q, FACE_getCenterData(f)); numFaces++; } VertDataMulN(q, 1.0f/numFaces); VertDataZero(r); - for (i=0; i<v->numEdges; i++) { + for (i = 0; i < v->numEdges; i++) { CCGEdge *e = v->edges[i]; VertDataAdd(r, VERT_getCo(_edge_getOtherVert(e, v), curLvl)); numEdges++; @@ -2002,7 +2132,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { VertDataMulN(r, 1.0f/numEdges); VertDataCopy(nCo, co); - VertDataMulN(nCo, numEdges-2.0f); + VertDataMulN(nCo, numEdges - 2.0f); VertDataAdd(nCo, q); VertDataAdd(nCo, r); VertDataMulN(nCo, 1.0f/numEdges); @@ -2017,7 +2147,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { allSharp = 1; } - for (i=0; i<v->numEdges; i++) { + for (i = 0; i < v->numEdges; i++) { CCGEdge *e = v->edges[i]; float sharpness = EDGE_getSharpness(e, curLvl); @@ -2026,7 +2156,8 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { CCGVert *oV = _edge_getOtherVert(e, v); VertDataAdd(q, VERT_getCo(oV, curLvl)); } - } else if (sharpness != 0.0f) { + } + else if (sharpness != 0.0f) { CCGVert *oV = _edge_getOtherVert(e, v); VertDataAdd(q, VERT_getCo(oV, curLvl)); } @@ -2035,7 +2166,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { VertDataMulN(q, (float) 1/sharpCount); if (sharpCount!=2 || allSharp) { - // q = q + (co-q)*avgSharpness + // q = q + (co-q) * avgSharpness VertDataCopy(r, co); VertDataSub(r, q); VertDataMulN(r, avgSharpness); @@ -2048,7 +2179,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { VertDataMulN(q, 0.25f); VertDataAdd(r, q); - // nCo = nCo + (r-nCo)*avgSharpness + // nCo = nCo + (r-nCo) * avgSharpness VertDataSub(r, nCo); VertDataMulN(r, avgSharpness); VertDataAdd(nCo, r); @@ -2058,35 +2189,35 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { } if (ss->useAgeCounts) { - for (i=0; i<numEffectedV; i++) { + for (i = 0; i < numEffectedV; i++) { CCGVert *v = effectedV[i]; byte *userData = ccgSubSurf_getVertUserData(ss, v); *((int*) &userData[ss->vertUserAgeOffset]) = ss->currentAge; } - for (i=0; i<numEffectedE; i++) { + for (i = 0; i < numEffectedE; i++) { CCGEdge *e = effectedE[i]; byte *userData = ccgSubSurf_getEdgeUserData(ss, e); *((int*) &userData[ss->edgeUserAgeOffset]) = ss->currentAge; } - for (i=0; i<numEffectedF; i++) { + for (i = 0; i < numEffectedF; i++) { CCGFace *f = effectedF[i]; byte *userData = ccgSubSurf_getFaceUserData(ss, f); *((int*) &userData[ss->faceUserAgeOffset]) = ss->currentAge; } } - for (i=0; i<numEffectedE; i++) { + for (i = 0; i < numEffectedE; i++) { CCGEdge *e = effectedE[i]; VertDataCopy(EDGE_getCo(e, nextLvl, 0), VERT_getCo(e->v0, nextLvl)); VertDataCopy(EDGE_getCo(e, nextLvl, 2), VERT_getCo(e->v1, nextLvl)); } - for (i=0; i<numEffectedF; i++) { + for (i = 0; i < numEffectedF; i++) { CCGFace *f = effectedF[i]; - for (S=0; S<f->numVerts; S++) { + for (S = 0; S < f->numVerts; S++) { CCGEdge *e = FACE_getEdges(f)[S]; - CCGEdge *prevE = FACE_getEdges(f)[(S+f->numVerts-1)%f->numVerts]; + CCGEdge *prevE = FACE_getEdges(f)[(S + f->numVerts - 1) % f->numVerts]; VertDataCopy(FACE_getIFCo(f, nextLvl, S, 0, 0), FACE_getCenterData(f)); VertDataCopy(FACE_getIECo(f, nextLvl, S, 0), FACE_getCenterData(f)); @@ -2098,7 +2229,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { } } - for (curLvl=1; curLvl<subdivLevels; curLvl++) { + for (curLvl = 1; curLvl < subdivLevels; curLvl++) { ccgSubSurf__calcSubdivLevel(ss, effectedV, effectedE, effectedF, numEffectedV, numEffectedE, numEffectedF, curLvl); @@ -2109,11 +2240,11 @@ static void ccgSubSurf__sync(CCGSubSurf *ss) { effectedV, effectedE, effectedF, numEffectedV, numEffectedE, numEffectedF); - for (ptrIdx=0; ptrIdx<numEffectedV; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedV; ptrIdx++) { CCGVert *v = effectedV[ptrIdx]; v->flags = 0; } - for (ptrIdx=0; ptrIdx<numEffectedE; ptrIdx++) { + for (ptrIdx = 0; ptrIdx < numEffectedE; ptrIdx++) { CCGEdge *e = effectedE[ptrIdx]; e->flags = 0; } @@ -2128,10 +2259,10 @@ static void ccgSubSurf__allFaces(CCGSubSurf *ss, CCGFace ***faces, int *numFaces CCGFace **array; int i, num; - if(!*faces) { - array = MEM_mallocN(sizeof(*array)*ss->fMap->numEntries, "CCGSubsurf allFaces"); + if (!*faces) { + array = MEM_mallocN(sizeof(*array) * ss->fMap->numEntries, "CCGSubsurf allFaces"); num = 0; - for (i=0; i<ss->fMap->curSize; i++) { + for (i = 0; i < ss->fMap->curSize; i++) { CCGFace *f = (CCGFace*) ss->fMap->buckets[i]; for (; f; f = f->next) @@ -2140,10 +2271,11 @@ static void ccgSubSurf__allFaces(CCGSubSurf *ss, CCGFace ***faces, int *numFaces *faces = array; *numFaces = num; - *freeFaces= 1; + *freeFaces = 1; + } + else { + *freeFaces = 0; } - else - *freeFaces= 0; } static void ccgSubSurf__effectedFaceNeighbours(CCGSubSurf *ss, CCGFace **faces, int numFaces, CCGVert ***verts, int *numVerts, CCGEdge ***edges, int *numEdges) @@ -2152,39 +2284,39 @@ static void ccgSubSurf__effectedFaceNeighbours(CCGSubSurf *ss, CCGFace **faces, CCGEdge **arrayE; int numV, numE, i, j; - arrayV = MEM_mallocN(sizeof(*arrayV)*ss->vMap->numEntries, "CCGSubsurf arrayV"); - arrayE = MEM_mallocN(sizeof(*arrayE)*ss->eMap->numEntries, "CCGSubsurf arrayV"); + arrayV = MEM_mallocN(sizeof(*arrayV) * ss->vMap->numEntries, "CCGSubsurf arrayV"); + arrayE = MEM_mallocN(sizeof(*arrayE) * ss->eMap->numEntries, "CCGSubsurf arrayV"); numV = numE = 0; - for (i=0; i<numFaces; i++) { + for (i = 0; i < numFaces; i++) { CCGFace *f = faces[i]; f->flags |= Face_eEffected; } - for (i=0; i<ss->vMap->curSize; i++) { + for (i = 0; i < ss->vMap->curSize; i++) { CCGVert *v = (CCGVert*) ss->vMap->buckets[i]; for (; v; v = v->next) { - for(j=0; j<v->numFaces; j++) - if(!(v->faces[j]->flags & Face_eEffected)) + for (j = 0; j < v->numFaces; j++) + if (!(v->faces[j]->flags & Face_eEffected)) break; - if(j == v->numFaces) { + if (j == v->numFaces) { arrayV[numV++] = v; v->flags |= Vert_eEffected; } } } - for (i=0; i<ss->eMap->curSize; i++) { + for (i = 0; i < ss->eMap->curSize; i++) { CCGEdge *e = (CCGEdge*) ss->eMap->buckets[i]; for (; e; e = e->next) { - for(j=0; j<e->numFaces; j++) - if(!(e->faces[j]->flags & Face_eEffected)) + for (j = 0; j < e->numFaces; j++) + if (!(e->faces[j]->flags & Face_eEffected)) break; - if(j == e->numFaces) { + if (j == e->numFaces) { e->flags |= Edge_eEffected; arrayE[numE++] = e; } @@ -2205,33 +2337,33 @@ CCGError ccgSubSurf_updateFromFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF subdivLevels = ss->subdivLevels; lvl = (lvl)? lvl: subdivLevels; - gridSize = 1 + (1<<(lvl-1)); - cornerIdx = gridSize-1; + gridSize = 1 + (1 << (lvl - 1)); + cornerIdx = gridSize - 1; ccgSubSurf__allFaces(ss, &effectedF, &numEffectedF, &freeF); - for (i=0; i<numEffectedF; i++) { + for (i = 0; i < numEffectedF; i++) { CCGFace *f = effectedF[i]; - for (S=0; S<f->numVerts; S++) { + for (S = 0; S < f->numVerts; S++) { CCGEdge *e = FACE_getEdges(f)[S]; - CCGEdge *prevE = FACE_getEdges(f)[(S+f->numVerts-1)%f->numVerts]; + CCGEdge *prevE = FACE_getEdges(f)[(S + f->numVerts - 1) % f->numVerts]; VertDataCopy(FACE_getCenterData(f), FACE_getIFCo(f, lvl, S, 0, 0)); VertDataCopy(VERT_getCo(FACE_getVerts(f)[S], lvl), FACE_getIFCo(f, lvl, S, cornerIdx, cornerIdx)); - for (x=0; x<gridSize; x++) + for (x = 0; x < gridSize; x++) VertDataCopy(FACE_getIECo(f, lvl, S, x), FACE_getIFCo(f, lvl, S, x, 0)); - for (x=0; x<gridSize; x++) { - int eI = gridSize-1-x; + for (x = 0; x < gridSize; x++) { + int eI = gridSize - 1 - x; VertDataCopy(_edge_getCoVert(e, FACE_getVerts(f)[S], lvl, eI,vertDataSize), FACE_getIFCo(f, lvl, S, cornerIdx, x)); VertDataCopy(_edge_getCoVert(prevE, FACE_getVerts(f)[S], lvl, eI,vertDataSize), FACE_getIFCo(f, lvl, S, x, cornerIdx)); } } } - if(freeF) MEM_freeN(effectedF); + if (freeF) MEM_freeN(effectedF); return eCCGError_None; } @@ -2244,26 +2376,26 @@ CCGError ccgSubSurf_updateToFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, subdivLevels = ss->subdivLevels; lvl = (lvl)? lvl: subdivLevels; - gridSize = 1 + (1<<(lvl-1)); - cornerIdx = gridSize-1; + gridSize = 1 + (1 << (lvl - 1)); + cornerIdx = gridSize - 1; ccgSubSurf__allFaces(ss, &effectedF, &numEffectedF, &freeF); - for (i=0; i<numEffectedF; i++) { + for (i = 0; i < numEffectedF; i++) { CCGFace *f = effectedF[i]; - for (S=0; S<f->numVerts; S++) { - int prevS = (S+f->numVerts-1)%f->numVerts; + for (S = 0; S < f->numVerts; S++) { + int prevS = (S + f->numVerts - 1) % f->numVerts; CCGEdge *e = FACE_getEdges(f)[S]; CCGEdge *prevE = FACE_getEdges(f)[prevS]; - for (x=0; x<gridSize; x++) { - int eI = gridSize-1-x; + for (x = 0; x < gridSize; x++) { + int eI = gridSize - 1 - x; VertDataCopy(FACE_getIFCo(f, lvl, S, cornerIdx, x), _edge_getCoVert(e, FACE_getVerts(f)[S], lvl, eI,vertDataSize)); VertDataCopy(FACE_getIFCo(f, lvl, S, x, cornerIdx), _edge_getCoVert(prevE, FACE_getVerts(f)[S], lvl, eI,vertDataSize)); } - for (x=1; x<gridSize-1; x++) { + for (x = 1; x < gridSize - 1; x++) { VertDataCopy(FACE_getIFCo(f, lvl, S, 0, x), FACE_getIECo(f, lvl, prevS, x)); VertDataCopy(FACE_getIFCo(f, lvl, S, x, 0), FACE_getIECo(f, lvl, S, x)); } @@ -2273,7 +2405,7 @@ CCGError ccgSubSurf_updateToFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, } } - if(freeF) MEM_freeN(effectedF); + if (freeF) MEM_freeN(effectedF); return eCCGError_None; } @@ -2290,41 +2422,41 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in subdivLevels = ss->subdivLevels; lvl = (lvl)? lvl: subdivLevels; - gridSize = 1 + (1<<(lvl-1)); - edgeSize = 1 + (1<<lvl); - cornerIdx = gridSize-1; + gridSize = 1 + (1 << (lvl - 1)); + edgeSize = 1 + (1 << lvl); + cornerIdx = gridSize - 1; ccgSubSurf__allFaces(ss, &effectedF, &numEffectedF, &freeF); ccgSubSurf__effectedFaceNeighbours(ss, effectedF, numEffectedF, &effectedV, &numEffectedV, &effectedE, &numEffectedE); /* zero */ - for (i=0; i<numEffectedV; i++) { + for (i = 0; i < numEffectedV; i++) { CCGVert *v = effectedV[i]; - if(v->numFaces) + if (v->numFaces) VertDataZero(VERT_getCo(v, lvl)); } - for (i=0; i<numEffectedE; i++) { + for (i = 0; i < numEffectedE; i++) { CCGEdge *e = effectedE[i]; - if(e->numFaces) - for (x=0; x<edgeSize; x++) + if (e->numFaces) + for (x = 0; x < edgeSize; x++) VertDataZero(EDGE_getCo(e, lvl, x)); } /* add */ - for (i=0; i<numEffectedF; i++) { + for (i = 0; i < numEffectedF; i++) { CCGFace *f = effectedF[i]; VertDataZero(FACE_getCenterData(f)); - for (S=0; S<f->numVerts; S++) - for (x=0; x<gridSize; x++) + for (S = 0; S < f->numVerts; S++) + for (x = 0; x < gridSize; x++) VertDataZero(FACE_getIECo(f, lvl, S, x)); - for (S=0; S<f->numVerts; S++) { - int prevS = (S+f->numVerts-1)%f->numVerts; + for (S = 0; S < f->numVerts; S++) { + int prevS = (S + f->numVerts - 1) % f->numVerts; CCGEdge *e = FACE_getEdges(f)[S]; CCGEdge *prevE = FACE_getEdges(f)[prevS]; @@ -2332,90 +2464,91 @@ CCGError ccgSubSurf_stitchFaces(CCGSubSurf *ss, int lvl, CCGFace **effectedF, in if (FACE_getVerts(f)[S]->flags&Vert_eEffected) VertDataAdd(VERT_getCo(FACE_getVerts(f)[S], lvl), FACE_getIFCo(f, lvl, S, cornerIdx, cornerIdx)); - for (x=1; x<gridSize-1; x++) { + for (x = 1; x < gridSize - 1; x++) { VertDataAdd(FACE_getIECo(f, lvl, S, x), FACE_getIFCo(f, lvl, S, x, 0)); VertDataAdd(FACE_getIECo(f, lvl, prevS, x), FACE_getIFCo(f, lvl, S, 0, x)); } - for (x=0; x<gridSize-1; x++) { - int eI = gridSize-1-x; + for (x = 0; x < gridSize - 1; x++) { + int eI = gridSize - 1 - x; if (FACE_getEdges(f)[S]->flags&Edge_eEffected) VertDataAdd(_edge_getCoVert(e, FACE_getVerts(f)[S], lvl, eI,vertDataSize), FACE_getIFCo(f, lvl, S, cornerIdx, x)); if (FACE_getEdges(f)[prevS]->flags&Edge_eEffected) - if(x != 0) + if (x != 0) VertDataAdd(_edge_getCoVert(prevE, FACE_getVerts(f)[S], lvl, eI,vertDataSize), FACE_getIFCo(f, lvl, S, x, cornerIdx)); } } } /* average */ - for (i=0; i<numEffectedV; i++) { + for (i = 0; i < numEffectedV; i++) { CCGVert *v = effectedV[i]; - if(v->numFaces) + if (v->numFaces) VertDataMulN(VERT_getCo(v, lvl), 1.0f/v->numFaces); } - for (i=0; i<numEffectedE; i++) { + for (i = 0; i < numEffectedE; i++) { CCGEdge *e = effectedE[i]; VertDataCopy(EDGE_getCo(e, lvl, 0), VERT_getCo(e->v0, lvl)); - VertDataCopy(EDGE_getCo(e, lvl, edgeSize-1), VERT_getCo(e->v1, lvl)); + VertDataCopy(EDGE_getCo(e, lvl, edgeSize - 1), VERT_getCo(e->v1, lvl)); - if(e->numFaces) - for (x=1; x<edgeSize-1; x++) + if (e->numFaces) + for (x = 1; x < edgeSize - 1; x++) VertDataMulN(EDGE_getCo(e, lvl, x), 1.0f/e->numFaces); } /* copy */ - for (i=0; i<numEffectedF; i++) { + for (i = 0; i < numEffectedF; i++) { CCGFace *f = effectedF[i]; VertDataMulN(FACE_getCenterData(f), 1.0f/f->numVerts); - for (S=0; S<f->numVerts; S++) - for (x=1; x<gridSize-1; x++) + for (S = 0; S < f->numVerts; S++) + for (x = 1; x < gridSize - 1; x++) VertDataMulN(FACE_getIECo(f, lvl, S, x), 0.5f); - for (S=0; S<f->numVerts; S++) { - int prevS = (S+f->numVerts-1)%f->numVerts; + for (S = 0; S < f->numVerts; S++) { + int prevS = (S + f->numVerts - 1) % f->numVerts; CCGEdge *e = FACE_getEdges(f)[S]; CCGEdge *prevE = FACE_getEdges(f)[prevS]; VertDataCopy(FACE_getIFCo(f, lvl, S, 0, 0), FACE_getCenterData(f)); VertDataCopy(FACE_getIFCo(f, lvl, S, cornerIdx, cornerIdx), VERT_getCo(FACE_getVerts(f)[S], lvl)); - for (x=1; x<gridSize-1; x++) { + for (x = 1; x < gridSize - 1; x++) { VertDataCopy(FACE_getIFCo(f, lvl, S, x, 0), FACE_getIECo(f, lvl, S, x)); VertDataCopy(FACE_getIFCo(f, lvl, S, 0, x), FACE_getIECo(f, lvl, prevS, x)); } - for (x=0; x<gridSize-1; x++) { - int eI = gridSize-1-x; + for (x = 0; x < gridSize - 1; x++) { + int eI = gridSize - 1 - x; VertDataCopy(FACE_getIFCo(f, lvl, S, cornerIdx, x), _edge_getCoVert(e, FACE_getVerts(f)[S], lvl, eI,vertDataSize)); VertDataCopy(FACE_getIFCo(f, lvl, S, x, cornerIdx), _edge_getCoVert(prevE, FACE_getVerts(f)[S], lvl, eI,vertDataSize)); } VertDataCopy(FACE_getIECo(f, lvl, S, 0), FACE_getCenterData(f)); - VertDataCopy(FACE_getIECo(f, lvl, S, gridSize-1), FACE_getIFCo(f, lvl, S, gridSize-1, 0)); + VertDataCopy(FACE_getIECo(f, lvl, S, gridSize - 1), FACE_getIFCo(f, lvl, S, gridSize - 1, 0)); } } - for (i=0; i<numEffectedV; i++) + for (i = 0; i < numEffectedV; i++) effectedV[i]->flags = 0; - for (i=0; i<numEffectedE; i++) + for (i = 0; i < numEffectedE; i++) effectedE[i]->flags = 0; - for (i=0; i<numEffectedF; i++) + for (i = 0; i < numEffectedF; i++) effectedF[i]->flags = 0; MEM_freeN(effectedE); MEM_freeN(effectedV); - if(freeF) MEM_freeN(effectedF); + if (freeF) MEM_freeN(effectedF); return eCCGError_None; } /* update normals for specified faces */ -CCGError ccgSubSurf_updateNormals(CCGSubSurf *ss, CCGFace **effectedF, int numEffectedF) { +CCGError ccgSubSurf_updateNormals(CCGSubSurf *ss, CCGFace **effectedF, int numEffectedF) +{ CCGVert **effectedV; CCGEdge **effectedE; int i, numEffectedV, numEffectedE, freeF; @@ -2429,16 +2562,16 @@ CCGError ccgSubSurf_updateNormals(CCGSubSurf *ss, CCGFace **effectedF, int numEf effectedV, effectedE, effectedF, numEffectedV, numEffectedE, numEffectedF); - for (i=0; i<numEffectedV; i++) + for (i = 0; i < numEffectedV; i++) effectedV[i]->flags = 0; - for (i=0; i<numEffectedE; i++) + for (i = 0; i < numEffectedE; i++) effectedE[i]->flags = 0; - for (i=0; i<numEffectedF; i++) + for (i = 0; i < numEffectedF; i++) effectedF[i]->flags = 0; MEM_freeN(effectedE); MEM_freeN(effectedV); - if(freeF) MEM_freeN(effectedF); + if (freeF) MEM_freeN(effectedF); return eCCGError_None; } @@ -2457,22 +2590,22 @@ CCGError ccgSubSurf_updateLevels(CCGSubSurf *ss, int lvl, CCGFace **effectedF, i ccgSubSurf__effectedFaceNeighbours(ss, effectedF, numEffectedF, &effectedV, &numEffectedV, &effectedE, &numEffectedE); - for (curLvl=lvl; curLvl<subdivLevels; curLvl++) { + for (curLvl = lvl; curLvl < subdivLevels; curLvl++) { ccgSubSurf__calcSubdivLevel(ss, effectedV, effectedE, effectedF, numEffectedV, numEffectedE, numEffectedF, curLvl); } - for (i=0; i<numEffectedV; i++) + for (i = 0; i < numEffectedV; i++) effectedV[i]->flags = 0; - for (i=0; i<numEffectedE; i++) + for (i = 0; i < numEffectedE; i++) effectedE[i]->flags = 0; - for (i=0; i<numEffectedF; i++) + for (i = 0; i < numEffectedF; i++) effectedF[i]->flags = 0; MEM_freeN(effectedE); MEM_freeN(effectedV); - if(freeF) MEM_freeN(effectedF); + if (freeF) MEM_freeN(effectedF); return eCCGError_None; } @@ -2484,272 +2617,352 @@ CCGError ccgSubSurf_updateLevels(CCGSubSurf *ss, int lvl, CCGFace **effectedF, i /*** External API accessor functions ***/ -int ccgSubSurf_getNumVerts(const CCGSubSurf *ss) { +int ccgSubSurf_getNumVerts(const CCGSubSurf *ss) +{ return ss->vMap->numEntries; } -int ccgSubSurf_getNumEdges(const CCGSubSurf *ss) { +int ccgSubSurf_getNumEdges(const CCGSubSurf *ss) +{ return ss->eMap->numEntries; } -int ccgSubSurf_getNumFaces(const CCGSubSurf *ss) { +int ccgSubSurf_getNumFaces(const CCGSubSurf *ss) +{ return ss->fMap->numEntries; } -CCGVert *ccgSubSurf_getVert(CCGSubSurf *ss, CCGVertHDL v) { +CCGVert *ccgSubSurf_getVert(CCGSubSurf *ss, CCGVertHDL v) +{ return (CCGVert*) _ehash_lookup(ss->vMap, v); } -CCGEdge *ccgSubSurf_getEdge(CCGSubSurf *ss, CCGEdgeHDL e) { +CCGEdge *ccgSubSurf_getEdge(CCGSubSurf *ss, CCGEdgeHDL e) +{ return (CCGEdge*) _ehash_lookup(ss->eMap, e); } -CCGFace *ccgSubSurf_getFace(CCGSubSurf *ss, CCGFaceHDL f) { +CCGFace *ccgSubSurf_getFace(CCGSubSurf *ss, CCGFaceHDL f) +{ return (CCGFace*) _ehash_lookup(ss->fMap, f); } -int ccgSubSurf_getSubdivisionLevels(const CCGSubSurf *ss) { +int ccgSubSurf_getSubdivisionLevels(const CCGSubSurf *ss) +{ return ss->subdivLevels; } -int ccgSubSurf_getEdgeSize(const CCGSubSurf *ss) { +int ccgSubSurf_getEdgeSize(const CCGSubSurf *ss) +{ return ccgSubSurf_getEdgeLevelSize(ss, ss->subdivLevels); } -int ccgSubSurf_getEdgeLevelSize(const CCGSubSurf *ss, int level) { - if (level<1 || level>ss->subdivLevels) { +int ccgSubSurf_getEdgeLevelSize(const CCGSubSurf *ss, int level) +{ + if (level<1 || level > ss->subdivLevels) { return -1; - } else { - return 1 + (1<<level); + } + else { + return 1 + (1 << level); } } -int ccgSubSurf_getGridSize(const CCGSubSurf *ss) { +int ccgSubSurf_getGridSize(const CCGSubSurf *ss) +{ return ccgSubSurf_getGridLevelSize(ss, ss->subdivLevels); } -int ccgSubSurf_getGridLevelSize(const CCGSubSurf *ss, int level) { - if (level<1 || level>ss->subdivLevels) { +int ccgSubSurf_getGridLevelSize(const CCGSubSurf *ss, int level) +{ + if (level<1 || level > ss->subdivLevels) { return -1; - } else { - return 1 + (1<<(level-1)); + } + else { + return 1 + (1 << (level - 1)); } } /* Vert accessors */ -CCGVertHDL ccgSubSurf_getVertVertHandle(CCGVert *v) { +CCGVertHDL ccgSubSurf_getVertVertHandle(CCGVert *v) +{ return v->vHDL; } -int ccgSubSurf_getVertAge(CCGSubSurf *ss, CCGVert *v) { +int ccgSubSurf_getVertAge(CCGSubSurf *ss, CCGVert *v) +{ if (ss->useAgeCounts) { byte *userData = ccgSubSurf_getVertUserData(ss, v); return ss->currentAge - *((int*) &userData[ss->vertUserAgeOffset]); - } else { + } + else { return 0; } } -void *ccgSubSurf_getVertUserData(CCGSubSurf *ss, CCGVert *v) { - return VERT_getLevelData(v) + ss->meshIFC.vertDataSize*(ss->subdivLevels+1); +void *ccgSubSurf_getVertUserData(CCGSubSurf *ss, CCGVert *v) +{ + return VERT_getLevelData(v) + ss->meshIFC.vertDataSize * (ss->subdivLevels + 1); } -int ccgSubSurf_getVertNumFaces(CCGVert *v) { +int ccgSubSurf_getVertNumFaces(CCGVert *v) +{ return v->numFaces; } -CCGFace *ccgSubSurf_getVertFace(CCGVert *v, int index) { +CCGFace *ccgSubSurf_getVertFace(CCGVert *v, int index) +{ if (index<0 || index>=v->numFaces) { return NULL; - } else { + } + else { return v->faces[index]; } } -int ccgSubSurf_getVertNumEdges(CCGVert *v) { +int ccgSubSurf_getVertNumEdges(CCGVert *v) +{ return v->numEdges; } -CCGEdge *ccgSubSurf_getVertEdge(CCGVert *v, int index) { +CCGEdge *ccgSubSurf_getVertEdge(CCGVert *v, int index) +{ if (index<0 || index>=v->numEdges) { return NULL; - } else { + } + else { return v->edges[index]; } } -void *ccgSubSurf_getVertData(CCGSubSurf *ss, CCGVert *v) { +void *ccgSubSurf_getVertData(CCGSubSurf *ss, CCGVert *v) +{ return ccgSubSurf_getVertLevelData(ss, v, ss->subdivLevels); } -void *ccgSubSurf_getVertLevelData(CCGSubSurf *ss, CCGVert *v, int level) { - if (level<0 || level>ss->subdivLevels) { +void *ccgSubSurf_getVertLevelData(CCGSubSurf *ss, CCGVert *v, int level) +{ + if (level<0 || level > ss->subdivLevels) { return NULL; - } else { + } + else { return _vert_getCo(v, level, ss->meshIFC.vertDataSize); } } /* Edge accessors */ -CCGEdgeHDL ccgSubSurf_getEdgeEdgeHandle(CCGEdge *e) { +CCGEdgeHDL ccgSubSurf_getEdgeEdgeHandle(CCGEdge *e) +{ return e->eHDL; } -int ccgSubSurf_getEdgeAge(CCGSubSurf *ss, CCGEdge *e) { +int ccgSubSurf_getEdgeAge(CCGSubSurf *ss, CCGEdge *e) +{ if (ss->useAgeCounts) { byte *userData = ccgSubSurf_getEdgeUserData(ss, e); return ss->currentAge - *((int*) &userData[ss->edgeUserAgeOffset]); - } else { + } + else { return 0; } } -void *ccgSubSurf_getEdgeUserData(CCGSubSurf *ss, CCGEdge *e) { - return EDGE_getLevelData(e) + ss->meshIFC.vertDataSize *((ss->subdivLevels+1) + (1<<(ss->subdivLevels+1))-1); +void *ccgSubSurf_getEdgeUserData(CCGSubSurf *ss, CCGEdge *e) +{ + return EDGE_getLevelData(e) + ss->meshIFC.vertDataSize * ((ss->subdivLevels + 1) + (1 << (ss->subdivLevels + 1)) - 1); } -int ccgSubSurf_getEdgeNumFaces(CCGEdge *e) { +int ccgSubSurf_getEdgeNumFaces(CCGEdge *e) +{ return e->numFaces; } -CCGFace *ccgSubSurf_getEdgeFace(CCGEdge *e, int index) { +CCGFace *ccgSubSurf_getEdgeFace(CCGEdge *e, int index) +{ if (index<0 || index>=e->numFaces) { return NULL; - } else { + } + else { return e->faces[index]; } } -CCGVert *ccgSubSurf_getEdgeVert0(CCGEdge *e) { +CCGVert *ccgSubSurf_getEdgeVert0(CCGEdge *e) +{ return e->v0; } -CCGVert *ccgSubSurf_getEdgeVert1(CCGEdge *e) { +CCGVert *ccgSubSurf_getEdgeVert1(CCGEdge *e) +{ return e->v1; } -void *ccgSubSurf_getEdgeDataArray(CCGSubSurf *ss, CCGEdge *e) { +void *ccgSubSurf_getEdgeDataArray(CCGSubSurf *ss, CCGEdge *e) +{ return ccgSubSurf_getEdgeData(ss, e, 0); } -void *ccgSubSurf_getEdgeData(CCGSubSurf *ss, CCGEdge *e, int x) { +void *ccgSubSurf_getEdgeData(CCGSubSurf *ss, CCGEdge *e, int x) +{ return ccgSubSurf_getEdgeLevelData(ss, e, x, ss->subdivLevels); } -void *ccgSubSurf_getEdgeLevelData(CCGSubSurf *ss, CCGEdge *e, int x, int level) { - if (level<0 || level>ss->subdivLevels) { +void *ccgSubSurf_getEdgeLevelData(CCGSubSurf *ss, CCGEdge *e, int x, int level) +{ + if (level<0 || level > ss->subdivLevels) { return NULL; - } else { + } + else { return _edge_getCo(e, level, x, ss->meshIFC.vertDataSize); } } -float ccgSubSurf_getEdgeCrease(CCGEdge *e) { +float ccgSubSurf_getEdgeCrease(CCGEdge *e) +{ return e->crease; } /* Face accessors */ -CCGFaceHDL ccgSubSurf_getFaceFaceHandle(CCGSubSurf *UNUSED(ss), CCGFace *f) { +CCGFaceHDL ccgSubSurf_getFaceFaceHandle(CCGSubSurf *UNUSED(ss), CCGFace *f) +{ return f->fHDL; } -int ccgSubSurf_getFaceAge(CCGSubSurf *ss, CCGFace *f) { +int ccgSubSurf_getFaceAge(CCGSubSurf *ss, CCGFace *f) +{ if (ss->useAgeCounts) { byte *userData = ccgSubSurf_getFaceUserData(ss, f); return ss->currentAge - *((int*) &userData[ss->faceUserAgeOffset]); - } else { + } + else { return 0; } } -void *ccgSubSurf_getFaceUserData(CCGSubSurf *ss, CCGFace *f) { - int maxGridSize = 1 + (1<<(ss->subdivLevels-1)); - return FACE_getCenterData(f) + ss->meshIFC.vertDataSize *(1 + f->numVerts*maxGridSize + f->numVerts*maxGridSize*maxGridSize); +void *ccgSubSurf_getFaceUserData(CCGSubSurf *ss, CCGFace *f) +{ + int maxGridSize = 1 + (1 << (ss->subdivLevels - 1)); + return FACE_getCenterData(f) + ss->meshIFC.vertDataSize * (1 + f->numVerts * maxGridSize + f->numVerts * maxGridSize * maxGridSize); } -int ccgSubSurf_getFaceNumVerts(CCGFace *f) { +int ccgSubSurf_getFaceNumVerts(CCGFace *f) +{ return f->numVerts; } -CCGVert *ccgSubSurf_getFaceVert(CCGSubSurf *UNUSED(ss), CCGFace *f, int index) { +CCGVert *ccgSubSurf_getFaceVert(CCGSubSurf *UNUSED(ss), CCGFace *f, int index) +{ if (index<0 || index>=f->numVerts) { return NULL; - } else { + } + else { return FACE_getVerts(f)[index]; } } -CCGEdge *ccgSubSurf_getFaceEdge(CCGSubSurf *UNUSED(ss), CCGFace *f, int index) { +CCGEdge *ccgSubSurf_getFaceEdge(CCGSubSurf *UNUSED(ss), CCGFace *f, int index) +{ if (index<0 || index>=f->numVerts) { return NULL; - } else { + } + else { return FACE_getEdges(f)[index]; } } -int ccgSubSurf_getFaceEdgeIndex(CCGFace *f, CCGEdge *e) { +int ccgSubSurf_getFaceEdgeIndex(CCGFace *f, CCGEdge *e) +{ int i; - for (i=0; i<f->numVerts; i++) - if (FACE_getEdges(f)[i]==e) + for (i = 0; i < f->numVerts; i++) { + if (FACE_getEdges(f)[i] == e) { return i; - + } + } return -1; } -void *ccgSubSurf_getFaceCenterData(CCGFace *f) { +void *ccgSubSurf_getFaceCenterData(CCGFace *f) +{ return FACE_getCenterData(f); } -void *ccgSubSurf_getFaceGridEdgeDataArray(CCGSubSurf *ss, CCGFace *f, int gridIndex) { +void *ccgSubSurf_getFaceGridEdgeDataArray(CCGSubSurf *ss, CCGFace *f, int gridIndex) +{ return ccgSubSurf_getFaceGridEdgeData(ss, f, gridIndex, 0); } -void *ccgSubSurf_getFaceGridEdgeData(CCGSubSurf *ss, CCGFace *f, int gridIndex, int x) { +void *ccgSubSurf_getFaceGridEdgeData(CCGSubSurf *ss, CCGFace *f, int gridIndex, int x) +{ return _face_getIECo(f, ss->subdivLevels, gridIndex, x, ss->subdivLevels, ss->meshIFC.vertDataSize); } -void *ccgSubSurf_getFaceGridDataArray(CCGSubSurf *ss, CCGFace *f, int gridIndex) { +void *ccgSubSurf_getFaceGridDataArray(CCGSubSurf *ss, CCGFace *f, int gridIndex) +{ return ccgSubSurf_getFaceGridData(ss, f, gridIndex, 0, 0); } -void *ccgSubSurf_getFaceGridData(CCGSubSurf *ss, CCGFace *f, int gridIndex, int x, int y) { +void *ccgSubSurf_getFaceGridData(CCGSubSurf *ss, CCGFace *f, int gridIndex, int x, int y) +{ return _face_getIFCo(f, ss->subdivLevels, gridIndex, x, y, ss->subdivLevels, ss->meshIFC.vertDataSize); } /*** External API iterator functions ***/ -CCGVertIterator *ccgSubSurf_getVertIterator(CCGSubSurf *ss) { +CCGVertIterator *ccgSubSurf_getVertIterator(CCGSubSurf *ss) +{ return (CCGVertIterator*) _ehashIterator_new(ss->vMap); } -CCGEdgeIterator *ccgSubSurf_getEdgeIterator(CCGSubSurf *ss) { +CCGEdgeIterator *ccgSubSurf_getEdgeIterator(CCGSubSurf *ss) +{ return (CCGEdgeIterator*) _ehashIterator_new(ss->eMap); } -CCGFaceIterator *ccgSubSurf_getFaceIterator(CCGSubSurf *ss) { +CCGFaceIterator *ccgSubSurf_getFaceIterator(CCGSubSurf *ss) +{ return (CCGFaceIterator*) _ehashIterator_new(ss->fMap); } -CCGVert *ccgVertIterator_getCurrent(CCGVertIterator *vi) { +CCGVert *ccgVertIterator_getCurrent(CCGVertIterator *vi) +{ return (CCGVert*) _ehashIterator_getCurrent((EHashIterator*) vi); } -int ccgVertIterator_isStopped(CCGVertIterator *vi) { +int ccgVertIterator_isStopped(CCGVertIterator *vi) +{ return _ehashIterator_isStopped((EHashIterator*) vi); } -void ccgVertIterator_next(CCGVertIterator *vi) { +void ccgVertIterator_next(CCGVertIterator *vi) +{ _ehashIterator_next((EHashIterator*) vi); } -void ccgVertIterator_free(CCGVertIterator *vi) { +void ccgVertIterator_free(CCGVertIterator *vi) +{ _ehashIterator_free((EHashIterator*) vi); } -CCGEdge *ccgEdgeIterator_getCurrent(CCGEdgeIterator *vi) { +CCGEdge *ccgEdgeIterator_getCurrent(CCGEdgeIterator *vi) +{ return (CCGEdge*) _ehashIterator_getCurrent((EHashIterator*) vi); } -int ccgEdgeIterator_isStopped(CCGEdgeIterator *vi) { +int ccgEdgeIterator_isStopped(CCGEdgeIterator *vi) +{ return _ehashIterator_isStopped((EHashIterator*) vi); } -void ccgEdgeIterator_next(CCGEdgeIterator *vi) { +void ccgEdgeIterator_next(CCGEdgeIterator *vi) +{ _ehashIterator_next((EHashIterator*) vi); } -void ccgEdgeIterator_free(CCGEdgeIterator *vi) { +void ccgEdgeIterator_free(CCGEdgeIterator *vi) +{ _ehashIterator_free((EHashIterator*) vi); } -CCGFace *ccgFaceIterator_getCurrent(CCGFaceIterator *vi) { +CCGFace *ccgFaceIterator_getCurrent(CCGFaceIterator *vi) +{ return (CCGFace*) _ehashIterator_getCurrent((EHashIterator*) vi); } -int ccgFaceIterator_isStopped(CCGFaceIterator *vi) { +int ccgFaceIterator_isStopped(CCGFaceIterator *vi) +{ return _ehashIterator_isStopped((EHashIterator*) vi); } -void ccgFaceIterator_next(CCGFaceIterator *vi) { +void ccgFaceIterator_next(CCGFaceIterator *vi) +{ _ehashIterator_next((EHashIterator*) vi); } -void ccgFaceIterator_free(CCGFaceIterator *vi) { +void ccgFaceIterator_free(CCGFaceIterator *vi) +{ _ehashIterator_free((EHashIterator*) vi); } /*** Extern API final vert/edge/face interface ***/ -int ccgSubSurf_getNumFinalVerts(const CCGSubSurf *ss) { - int edgeSize = 1 + (1<<ss->subdivLevels); - int gridSize = 1 + (1<<(ss->subdivLevels-1)); - int numFinalVerts = ss->vMap->numEntries + ss->eMap->numEntries*(edgeSize-2) + ss->fMap->numEntries + ss->numGrids*((gridSize-2) + ((gridSize-2)*(gridSize-2))); +int ccgSubSurf_getNumFinalVerts(const CCGSubSurf *ss) +{ + int edgeSize = 1 + (1 << ss->subdivLevels); + int gridSize = 1 + (1 << (ss->subdivLevels - 1)); + int numFinalVerts = (ss->vMap->numEntries + + ss->eMap->numEntries * (edgeSize - 2) + + ss->fMap->numEntries + + ss->numGrids * ((gridSize - 2) + ((gridSize - 2) * (gridSize - 2)))); + return numFinalVerts; } -int ccgSubSurf_getNumFinalEdges(const CCGSubSurf *ss) { - int edgeSize = 1 + (1<<ss->subdivLevels); - int gridSize = 1 + (1<<(ss->subdivLevels-1)); - int numFinalEdges = ss->eMap->numEntries*(edgeSize-1) + ss->numGrids*((gridSize-1) + 2*((gridSize-2)*(gridSize-1))); +int ccgSubSurf_getNumFinalEdges(const CCGSubSurf *ss) +{ + int edgeSize = 1 + (1 << ss->subdivLevels); + int gridSize = 1 + (1 << (ss->subdivLevels - 1)); + int numFinalEdges = (ss->eMap->numEntries * (edgeSize - 1) + + ss->numGrids * ((gridSize - 1) + 2 * ((gridSize - 2) * (gridSize - 1)))); + return numFinalEdges; } -int ccgSubSurf_getNumFinalFaces(const CCGSubSurf *ss) { - int gridSize = 1 + (1<<(ss->subdivLevels-1)); - int numFinalFaces = ss->numGrids*((gridSize-1)*(gridSize-1)); +int ccgSubSurf_getNumFinalFaces(const CCGSubSurf *ss) +{ + int gridSize = 1 + (1 << (ss->subdivLevels - 1)); + int numFinalFaces = ss->numGrids * ((gridSize - 1) * (gridSize - 1)); return numFinalFaces; } |