Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 6477 in orxonox.OLD for trunk/src


Ignore:
Timestamp:
Jan 11, 2006, 3:27:35 PM (19 years ago)
Author:
bensch
Message:

trunk: uint to unsigned int

Location:
trunk/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/graphics/importer/vertex_array_model.cc

    r6471 r6477  
    8787
    8888  int prim;
    89   uint v1, v2, v3;
     89  unsigned int v1, v2, v3;
    9090
    9191  actcBeginOutput(tc);

  • trunk/src/subprojects/importer/tc.cc

    r6311 r6477  
    4747typedef struct TableIterator {
    4848    int i1, i2, i3;
    49     uint i;
     49    unsigned int i;
    5050    TableLevel3 *CurLevel3;
    5151    int CheckLevel1, CheckLevel2;
    … …  
    7070}
    7171
    72 int tableRetrieve(uint a, TableRoot *table, void **ref)
     72int tableRetrieve(unsigned int a, TableRoot *table, void **ref)
    7373{
    7474    int i1 = a / (LEVEL2COUNT * LEVEL3COUNT);
    … …  
    8787}
    8888
    89 int tableInsert(uint a, TableRoot *table, void *ref)
     89int tableInsert(unsigned int a, TableRoot *table, void *ref)
    9090{
    9191    int i1 = a / (LEVEL2COUNT * LEVEL3COUNT);
    … …  
    9494
    9595    if(table->Table[i1] == NULL) {
    96         chartedSetLabel("table level 2");
     96        chartedSetLabel("table level 2");
    9797        table->Table[i1] = (TableLevel2 *)calloc(1, sizeof(TableLevel2));
    98         table->TotalAllocatedBytes += sizeof(TableLevel2);
     98        table->TotalAllocatedBytes += sizeof(TableLevel2);
    9999        if(table->Table[i1] == NULL)
    100100            return 0;
    101101    }
    102102    if(table->Table[i1]->Table[i2] == NULL) {
    103         chartedSetLabel("table level 3");
     103        chartedSetLabel("table level 3");
    104104        table->Table[i1]->Table[i2] =
    105             (TableLevel3 *)calloc(1, sizeof(TableLevel3));
    106         table->TotalAllocatedBytes += sizeof(TableLevel3);
     105            (TableLevel3 *)calloc(1, sizeof(TableLevel3));
     106        table->TotalAllocatedBytes += sizeof(TableLevel3);
    107107        if(table->Table[i1]->Table[i2] == NULL)
    108108            return 0;
    109         table->Table[i1]->EntryCount++;
    110         table->TotalEntryCount += LEVEL3COUNT;
    111         table->EmptyEntryCount += LEVEL3COUNT;
     109        table->Table[i1]->EntryCount++;
     110        table->TotalEntryCount += LEVEL3COUNT;
     111        table->EmptyEntryCount += LEVEL3COUNT;
    112112    }
    113113    if(!table->Table[i1]->Table[i2]->IsSet[i3]) {
    114         table->Table[i1]->Table[i2]->EntryCount++;
    115         table->EmptyEntryCount --;
    116         table->Table[i1]->Table[i2]->IsSet[i3] = 1;
     114        table->Table[i1]->Table[i2]->EntryCount++;
     115        table->EmptyEntryCount --;
     116        table->Table[i1]->Table[i2]->IsSet[i3] = 1;
    117117    }
    118118    table->Table[i1]->Table[i2]->Table[i3] = ref;
    … …  
    120120}
    121121
    122 int tableRemove(uint a, TableRoot *table, void **wasref)
     122int tableRemove(unsigned int a, TableRoot *table, void **wasref)
    123123{
    124124    int i1 = a / (LEVEL2COUNT * LEVEL3COUNT);
    … …  
    127127
    128128    if(table->Table[i1] == NULL)
    129         return 0;
     129        return 0;
    130130    if(table->Table[i1]->Table[i2] == NULL)
    131         return 0;
     131        return 0;
    132132    if(!table->Table[i1]->Table[i2]->IsSet[i3])
    133133        return 0;
    … …  
    137137    table->EmptyEntryCount ++;
    138138    if(--table->Table[i1]->Table[i2]->EntryCount == 0) {
    139         table->EmptyEntryCount -= LEVEL3COUNT;
    140         table->TotalEntryCount -= LEVEL3COUNT;
    141         free(table->Table[i1]->Table[i2]);
    142         table->TotalAllocatedBytes -= sizeof(TableLevel3);
    143         table->Table[i1]->Table[i2] = NULL;
    144         if(--table->Table[i1]->EntryCount == 0) {
    145             table->TotalAllocatedBytes -= sizeof(TableLevel2);
    146             free(table->Table[i1]);
    147             table->Table[i1] = NULL;
    148         }
     139        table->EmptyEntryCount -= LEVEL3COUNT;
     140        table->TotalEntryCount -= LEVEL3COUNT;
     141        free(table->Table[i1]->Table[i2]);
     142        table->TotalAllocatedBytes -= sizeof(TableLevel3);
     143        table->Table[i1]->Table[i2] = NULL;
     144        if(--table->Table[i1]->EntryCount == 0) {
     145            table->TotalAllocatedBytes -= sizeof(TableLevel2);
     146            free(table->Table[i1]);
     147            table->Table[i1] = NULL;
     148        }
    149149    }
    150150    return 1;
    … …  
    161161}
    162162
    163 int tableIterate(TableRoot *table, TableIterator *ti, uint *i, void **ref)
     163int tableIterate(TableRoot *table, TableIterator *ti, unsigned int *i, void **ref)
    164164{
    165165    int done;
    … …  
    168168    while(ti->i1 < LEVEL1COUNT) {
    169169        if(ti->CheckLevel1 && table->Table[ti->i1] == NULL) {
    170             ti->i += LEVEL2COUNT * LEVEL3COUNT;
    171             ti->i1++;
    172             continue;
    173         } else
    174             ti->CheckLevel1 = 0;
     170            ti->i += LEVEL2COUNT * LEVEL3COUNT;
     171            ti->i1++;
     172            continue;
     173        } else
     174            ti->CheckLevel1 = 0;
    175175        if(ti->CheckLevel2 && table->Table[ti->i1]->Table[ti->i2] == NULL) {
    176             ti->i += LEVEL3COUNT;
    177             if(++ti->i2 >= LEVEL2COUNT) {
    178                 ti->i2 = 0;
    179                 ti->i1++;
    180                 ti->CheckLevel1 = 1;
    181             }
    182             continue;
    183         } else
    184             ti->CheckLevel2 = 0;
    185         if(ti->i3 == 0)
    186             ti->CurLevel3 = table->Table[ti->i1]->Table[ti->i2];
    187         if(ti->CurLevel3->IsSet[ti->i3]) {
    188             if(ref != NULL)
    189                 *ref = ti->CurLevel3->Table[ti->i3];
    190             if(i != NULL)
    191                 *i = ti->i;
    192             done = 1;
    193         }
    194         ti->i++;
    195         if(++ti->i3 >= LEVEL3COUNT) {
    196             ti->i3 = 0;
    197             ti->CheckLevel2 = 1;
    198             if(++ti->i2 >= LEVEL2COUNT) {
    199                 ti->i2 = 0;
    200                 ti->i1++;
    201                 ti->CheckLevel1 = 1;
    202             }
    203         }
    204         if(done)
    205             return 1;
     176            ti->i += LEVEL3COUNT;
     177            if(++ti->i2 >= LEVEL2COUNT) {
     178                ti->i2 = 0;
     179                ti->i1++;
     180                ti->CheckLevel1 = 1;
     181            }
     182            continue;
     183        } else
     184            ti->CheckLevel2 = 0;
     185        if(ti->i3 == 0)
     186            ti->CurLevel3 = table->Table[ti->i1]->Table[ti->i2];
     187        if(ti->CurLevel3->IsSet[ti->i3]) {
     188            if(ref != NULL)
     189                *ref = ti->CurLevel3->Table[ti->i3];
     190            if(i != NULL)
     191                *i = ti->i;
     192            done = 1;
     193        }
     194        ti->i++;
     195        if(++ti->i3 >= LEVEL3COUNT) {
     196            ti->i3 = 0;
     197            ti->CheckLevel2 = 1;
     198            if(++ti->i2 >= LEVEL2COUNT) {
     199                ti->i2 = 0;
     200                ti->i1++;
     201                ti->CheckLevel1 = 1;
     202            }
     203        }
     204        if(done)
     205            return 1;
    206206    }
    207207    return 0;
    … …  
    214214    for(i1 = 0; i1 < LEVEL1COUNT; i1++) {
    215215        if(table->Table[i1] != NULL) {
    216             for(i2 = 0; i2 < LEVEL2COUNT; i2++) {
    217                 if(table->Table[i1]->Table[i2] != NULL) {
    218                     for(i3 = 0; i3 < LEVEL3COUNT; i3++) {
    219                         if(table->Table[i1]->Table[i2]->IsSet[i3])
    220                             datumDelete(table->Table[i1]->Table[i2]->Table[i3]);
    221                     }
    222                     free(table->Table[i1]->Table[i2]);
    223                 }
    224             }
    225             free(table->Table[i1]);
    226             table->Table[i1] = NULL;
    227         }
     216            for(i2 = 0; i2 < LEVEL2COUNT; i2++) {
     217                if(table->Table[i1]->Table[i2] != NULL) {
     218                    for(i3 = 0; i3 < LEVEL3COUNT; i3++) {
     219                        if(table->Table[i1]->Table[i2]->IsSet[i3])
     220                            datumDelete(table->Table[i1]->Table[i2]->Table[i3]);
     221                    }
     222                    free(table->Table[i1]->Table[i2]);
     223                }
     224            }
     225            free(table->Table[i1]);
     226            table->Table[i1] = NULL;
     227        }
    228228    }
    229229    table->TotalEntryCount = 0;
    … …  
    270270    { \
    271271        int theErrorNow; \
    272         theErrorNow = (a); \
    273         if(theErrorNow < 0) \
    274             return theErrorNow; \
     272        theErrorNow = (a); \
     273        if(theErrorNow < 0) \
     274            return theErrorNow; \
    275275    }
    276276
    … …  
    287287
    288288typedef struct ACTCVertex {
    289     uint V;
     289    unsigned int V;
    290290    int Count;
    291291    struct ACTCVertex **PointsToMe;
    … …  
    296296
    297297/* private tokens */
    298 #define ACTC_NO_MATCHING_VERT           -0x3000
    299 #define ACTC_FWD_ORDER                  0
    300 #define ACTC_REV_ORDER                  1
    301 
    302 #define MAX_STATIC_VERTS                10000000 /* buh? */
     298#define ACTC_NO_MATCHING_VERT           -0x3000
     299#define ACTC_FWD_ORDER                  0
     300#define ACTC_REV_ORDER                  1
     301
     302#define MAX_STATIC_VERTS                10000000 /* buh? */
    303303
    304304struct _ACTCData {
    … …  
    315315    ACTCVertex *StaticVerts;
    316316    int UsingStaticVerts;
    317     uint VertRange;
     317    unsigned int VertRange;
    318318
    319319    /* During consolidation */
    … …  
    330330
    331331    /* actcParam-settable parameters */
    332     uint MinInputVert;
    333     uint MaxInputVert;
     332    unsigned int MinInputVert;
     333    unsigned int MaxInputVert;
    334334    int MaxVertShare;
    335335    int MaxEdgeShare;
    … …  
    349349    c = fprintf(fp, "      %d triangles: ");
    350350    for(i = 0; i < e->TriangleCount; i++) {
    351         if(c + 1 + sprintf(v, "%u", e->Triangles[i].FinalVert) > 78) {
    352             fputs("\n", fp);
    353             c = fprintf(fp, "        ");
    354         }
    355         c += fprintf(fp, " %s", v);
     351        if(c + 1 + sprintf(v, "%u", e->Triangles[i].FinalVert) > 78) {
     352            fputs("\n", fp);
     353            c = fprintf(fp, "        ");
     354        }
     355        c += fprintf(fp, " %s", v);
    356356    }
    357357    fputs("\n", fp);
    … …  
    365365
    366366    for(i = 0; i < vert->EdgeCount; i++) {
    367         fprintf(fp, "    %u->%u (%d times)\n", vert->V, vert->Edges[i].V2->V,
    368             vert->Edges[i].Count);
    369         dumpTriangles(&vert->Edges[i], fp);
     367        fprintf(fp, "    %u->%u (%d times)\n", vert->V, vert->Edges[i].V2->V,
     368            vert->Edges[i].Count);
     369        dumpTriangles(&vert->Edges[i], fp);
    370370    }
    371371    fputs("\n", fp);
    … …  
    383383    if(tc->UsingStaticVerts) {
    384384        for(i = 0; i < tc->VertRange; i++) {
    385             v = &tc->StaticVerts[i];
    386             if(v->Count > 0) {
    387                 fprintf(fp, "  vertex %u, valence %d, %d edges\n", v->V,
    388                     v->Count, v->EdgeCount);
    389                 dumpEdges(v, fp);
    390             }
    391         }
     385            v = &tc->StaticVerts[i];
     386            if(v->Count > 0) {
     387                fprintf(fp, "  vertex %u, valence %d, %d edges\n", v->V,
     388                    v->Count, v->EdgeCount);
     389                dumpEdges(v, fp);
     390            }
     391        }
    392392    } else {
    393         for(i = 0; i < tc->VertexCount; i++) {
    394             if(tableIterate(tc->Vertices, tc->VertexIterator, NULL,
    395                 (void **)&v) == 0) {
    396                 fprintf(fp, "ACTC::dumpVertices : fewer vertices in the table "
    397                     "than we expected!\n");
    398                 fprintf(stderr, "ACTC::dumpVertices : fewer vertices in the table "
    399                     "than we expected!\n");
    400             }
    401             if(v == NULL) {
    402                 fprintf(fp, "ACTC::dumpVertices : did not expect to get a NULL"
    403                     "Vertex from the table iterator!\n");
    404                 fprintf(stderr, "ACTC::dumpVertices : did not expect to get a NULL"
    405                     "Vertex from the table iterator!\n");
    406             }
    407             fprintf(fp, "  vertex %u, valence %d, %d edges\n", v->V, v->Count,
    408                 v->EdgeCount);
    409             dumpEdges(v, fp);
    410         }
     393        for(i = 0; i < tc->VertexCount; i++) {
     394            if(tableIterate(tc->Vertices, tc->VertexIterator, NULL,
     395                (void **)&v) == 0) {
     396                fprintf(fp, "ACTC::dumpVertices : fewer vertices in the table "
     397                    "than we expected!\n");
     398                fprintf(stderr, "ACTC::dumpVertices : fewer vertices in the table "
     399                    "than we expected!\n");
     400            }
     401            if(v == NULL) {
     402                fprintf(fp, "ACTC::dumpVertices : did not expect to get a NULL"
     403                    "Vertex from the table iterator!\n");
     404                fprintf(stderr, "ACTC::dumpVertices : did not expect to get a NULL"
     405                    "Vertex from the table iterator!\n");
     406            }
     407            fprintf(fp, "  vertex %u, valence %d, %d edges\n", v->V, v->Count,
     408                v->EdgeCount);
     409            dumpEdges(v, fp);
     410        }
    411411    }
    412412}
    … …  
    422422    if(tc->VertexBins == NULL) {
    423423        fprintf(fp, "        empty.\n");
    424         return;
     424        return;
    425425    }
    426426    for(i = 1; i <= tc->CurMaxVertValence; i++) {
    427427        cur = tc->VertexBins[i];
    428         c = fprintf(fp, "        bin %d -> ", i);
    429         while(cur != NULL) {
    430             if(c + 1 + sprintf(v, "%ux%d", cur->V, cur->Count) > 78) {
    431                 fputs("\n", fp);
    432                 c = fprintf(fp, "          ");
    433             }
    434             c += fprintf(fp, " %s", v);
    435             cur = cur->Next;
    436         }
    437         fputs("\n", fp);
     428        c = fprintf(fp, "        bin %d -> ", i);
     429        while(cur != NULL) {
     430            if(c + 1 + sprintf(v, "%ux%d", cur->V, cur->Count) > 78) {
     431                fputs("\n", fp);
     432                c = fprintf(fp, "          ");
     433            }
     434            c += fprintf(fp, " %s", v);
     435            cur = cur->Next;
     436        }
     437        fputs("\n", fp);
    438438    }
    439439}
    … …  
    464464}
    465465
    466 static void *reallocAndAppend(void **ptr, uint *itemCount, size_t itemBytes,
     466static void *reallocAndAppend(void **ptr, unsigned int *itemCount, size_t itemBytes,
    467467    void *append)
    468468{
    … …  
    471471    t = realloc(*ptr, itemBytes * (*itemCount + 1));
    472472    if(t == NULL)
    473         return NULL;
     473        return NULL;
    474474    *ptr = t;
    475475
    … …  
    487487 * going to be less than the number of vertices.)
    488488 */
    489 static int incVertexValence(ACTCData *tc, uint v, ACTCVertex **found)
     489static int incVertexValence(ACTCData *tc, unsigned int v, ACTCVertex **found)
    490490{
    491491    ACTCVertex *vertex;
    … …  
    493493    if(tc->UsingStaticVerts) {
    494494        vertex = &tc->StaticVerts[v];
    495         vertex->Count++;
    496         if(vertex->Count == 1) {
    497             vertex->V = v;
    498             tc->VertexCount++;
    499         }
     495        vertex->Count++;
     496        if(vertex->Count == 1) {
     497            vertex->V = v;
     498            tc->VertexCount++;
     499        }
    500500    } else {
    501         if(tableRetrieve(v, tc->Vertices, (void **)&vertex) == 1) {
    502             if(vertex->V != v) {
    503                 ACTC_DEBUG(
    504                     fprintf(stderr, "ACTC::incVertexValence : Got vertex %d when "
    505                         "looking for vertex %d?!?\n", vertex->V, v);
    506                     abortWithOptionalDump(tc);
    507                 )
    508                 return tc->Error = ACTC_DATABASE_CORRUPT;
    509             }
    510             vertex->Count++;
    511         } else {
    512             chartedSetLabel("new Vertex");
    513             vertex = (ACTCVertex *)malloc(sizeof(ACTCVertex));
    514             vertex->V = v;
    515             vertex->Count = 1;
    516             vertex->Edges = NULL;
    517             vertex->EdgeCount = 0;
    518             if(tableInsert(v, tc->Vertices, vertex) == 0) {
    519                 ACTC_DEBUG(fprintf(stderr, "ACTC::incVertexValence : Failed "
    520                     "to insert vertex into table\n");)
    521                 return tc->Error = ACTC_ALLOC_FAILED;
    522             }
    523             tc->VertexCount++;
    524         }
     501        if(tableRetrieve(v, tc->Vertices, (void **)&vertex) == 1) {
     502            if(vertex->V != v) {
     503                ACTC_DEBUG(
     504                    fprintf(stderr, "ACTC::incVertexValence : Got vertex %d when "
     505                        "looking for vertex %d?!?\n", vertex->V, v);
     506                    abortWithOptionalDump(tc);
     507                )
     508                return tc->Error = ACTC_DATABASE_CORRUPT;
     509            }
     510            vertex->Count++;
     511        } else {
     512            chartedSetLabel("new Vertex");
     513            vertex = (ACTCVertex *)malloc(sizeof(ACTCVertex));
     514            vertex->V = v;
     515            vertex->Count = 1;
     516            vertex->Edges = NULL;
     517            vertex->EdgeCount = 0;
     518            if(tableInsert(v, tc->Vertices, vertex) == 0) {
     519                ACTC_DEBUG(fprintf(stderr, "ACTC::incVertexValence : Failed "
     520                    "to insert vertex into table\n");)
     521                return tc->Error = ACTC_ALLOC_FAILED;
     522            }
     523            tc->VertexCount++;
     524        }
    525525    }
    526526    if(vertex->Count > tc->CurMaxVertValence)
    527         tc->CurMaxVertValence = vertex->Count;
     527        tc->CurMaxVertValence = vertex->Count;
    528528
    529529    *found = vertex;
    … …  
    538538    v->Count--;
    539539    if(v->Count < 0) {
    540         ACTC_DEBUG(
    541             fprintf(stderr, "ACTC::decVertexValence : Valence went "
    542                 "negative?!?\n");
    543             abortWithOptionalDump(tc);
    544         )
    545         return tc->Error = ACTC_DATABASE_CORRUPT;
     540        ACTC_DEBUG(
     541            fprintf(stderr, "ACTC::decVertexValence : Valence went "
     542                "negative?!?\n");
     543            abortWithOptionalDump(tc);
     544        )
     545        return tc->Error = ACTC_DATABASE_CORRUPT;
    546546    }
    547547
    548548    if(v->PointsToMe != NULL) {
    549         *v->PointsToMe = v->Next;
    550         if(v->Next != NULL)
    551             v->Next->PointsToMe = v->PointsToMe;
    552         v->Next = NULL;
     549        *v->PointsToMe = v->Next;
     550        if(v->Next != NULL)
     551            v->Next->PointsToMe = v->PointsToMe;
     552        v->Next = NULL;
    553553    }
    554554
    555555    if(v->Count == 0) {
    556         tc->VertexCount--;
    557         if(v->Edges != NULL)
    558             free(v->Edges);
     556        tc->VertexCount--;
     557        if(v->Edges != NULL)
     558            free(v->Edges);
    559559        if(!tc->UsingStaticVerts) {
    560             tableRemove(v->V, tc->Vertices, NULL);
    561             free(v);
    562         }
    563         *vptr = NULL;
     560            tableRemove(v->V, tc->Vertices, NULL);
     561            free(v);
     562        }
     563        *vptr = NULL;
    564564    } else {
    565         if(tc->VertexBins != NULL) {
    566             v->Next = tc->VertexBins[v->Count];
    567             v->PointsToMe = &tc->VertexBins[v->Count];
    568             if(v->Next != NULL)
    569                 v->Next->PointsToMe = &v->Next;
    570             tc->VertexBins[v->Count] = v;
    571             if(v->Count < tc->CurMinVertValence)
    572                 tc->CurMinVertValence = v->Count;
    573         }
     565        if(tc->VertexBins != NULL) {
     566            v->Next = tc->VertexBins[v->Count];
     567            v->PointsToMe = &tc->VertexBins[v->Count];
     568            if(v->Next != NULL)
     569                v->Next->PointsToMe = &v->Next;
     570            tc->VertexBins[v->Count] = v;
     571            if(v->Count < tc->CurMinVertValence)
     572                tc->CurMinVertValence = v->Count;
     573        }
    574574    }
    575575
    … …  
    580580{
    581581    if(tc->CurMaxVertValence < tc->MinFanVerts) {
    582         return ACTC_NO_MATCHING_VERT;
     582        return ACTC_NO_MATCHING_VERT;
    583583    }
    584584    while(tc->VertexBins[tc->CurMaxVertValence] == NULL) {
    585         tc->CurMaxVertValence--;
    586         if(tc->CurMaxVertValence < tc->CurMinVertValence) {
    587             if(tc->VertexCount > 0) {
    588                 ACTC_DEBUG(fprintf(stderr, "tc::findNextFanVertex : no more "
    589                     "vertices in bins but VertexCount > 0\n");)
    590                 return tc->Error = ACTC_DATABASE_CORRUPT;
    591             }
    592             return ACTC_NO_MATCHING_VERT;
    593         }
     585        tc->CurMaxVertValence--;
     586        if(tc->CurMaxVertValence < tc->CurMinVertValence) {
     587            if(tc->VertexCount > 0) {
     588                ACTC_DEBUG(fprintf(stderr, "tc::findNextFanVertex : no more "
     589                    "vertices in bins but VertexCount > 0\n");)
     590                return tc->Error = ACTC_DATABASE_CORRUPT;
     591            }
     592            return ACTC_NO_MATCHING_VERT;
     593        }
    594594    }
    595595    *vert = tc->VertexBins[tc->CurMaxVertValence];
    … …  
    600600{
    601601    while(tc->VertexBins[tc->CurMinVertValence] == NULL) {
    602         tc->CurMinVertValence++;
    603         if(tc->CurMinVertValence > tc->CurMaxVertValence) {
    604             if(tc->VertexCount > 0) {
    605                 ACTC_DEBUG(fprintf(stderr, "tc::findNextStripVertex : no more "
    606                     "vertices in bins but VertexCount > 0\n");)
    607                 return tc->Error = ACTC_DATABASE_CORRUPT;
    608             }
    609             return ACTC_NO_MATCHING_VERT;
    610         }
     602        tc->CurMinVertValence++;
     603        if(tc->CurMinVertValence > tc->CurMaxVertValence) {
     604            if(tc->VertexCount > 0) {
     605                ACTC_DEBUG(fprintf(stderr, "tc::findNextStripVertex : no more "
     606                    "vertices in bins but VertexCount > 0\n");)
     607                return tc->Error = ACTC_DATABASE_CORRUPT;
     608            }
     609            return ACTC_NO_MATCHING_VERT;
     610        }
    611611    }
    612612    *vert = tc->VertexBins[tc->CurMinVertValence];
    … …  
    621621{
    622622    if(tc->IsOutputting) {
    623         ACTC_DEBUG(fprintf(stderr, "actcBeginInput : called within "
    624             "BeginOutput/EndOutput\n");)
    625         return tc->Error = ACTC_DURING_INPUT;
     623        ACTC_DEBUG(fprintf(stderr, "actcBeginInput : called within "
     624            "BeginOutput/EndOutput\n");)
     625        return tc->Error = ACTC_DURING_INPUT;
    626626    }
    627627
    628628    if(tc->IsInputting) {
    629         ACTC_DEBUG(fprintf(stderr, "actcBeginInput : called within "
    630             "BeginInput/EndInput\n");)
    631         return tc->Error = ACTC_DURING_INPUT;
     629        ACTC_DEBUG(fprintf(stderr, "actcBeginInput : called within "
     630            "BeginInput/EndInput\n");)
     631        return tc->Error = ACTC_DURING_INPUT;
    632632    }
    633633
    … …  
    636636
    637637    if(tc->MaxInputVert < MAX_STATIC_VERTS - 1) {
    638         size_t byteCount;
    639         tc->UsingStaticVerts = 1;
    640         tc->VertRange = tc->MaxInputVert + 1;
    641         byteCount = sizeof(ACTCVertex) * tc->VertRange;
    642         chartedSetLabel("static verts");
    643         tc->StaticVerts = (ACTCVertex *)calloc(sizeof(ACTCVertex), tc->VertRange);
    644         if(tc->StaticVerts == NULL) {
    645             ACTC_INFO(printf("Couldn't allocate static %d vert block of %u "
    646                 "bytes\n", tc->VertRange, byteCount);)
    647             tc->UsingStaticVerts = 0;
    648         }
     638        size_t byteCount;
     639        tc->UsingStaticVerts = 1;
     640        tc->VertRange = tc->MaxInputVert + 1;
     641        byteCount = sizeof(ACTCVertex) * tc->VertRange;
     642        chartedSetLabel("static verts");
     643        tc->StaticVerts = (ACTCVertex *)calloc(sizeof(ACTCVertex), tc->VertRange);
     644        if(tc->StaticVerts == NULL) {
     645            ACTC_INFO(printf("Couldn't allocate static %d vert block of %u "
     646                "bytes\n", tc->VertRange, byteCount);)
     647            tc->UsingStaticVerts = 0;
     648        }
    649649    } else
    650         tc->UsingStaticVerts = 0;
     650        tc->UsingStaticVerts = 0;
    651651
    652652    return ACTC_NO_ERROR;
    … …  
    656656{
    657657    if(tc->IsOutputting) {
    658         ACTC_DEBUG(fprintf(stderr, "actcEndInput : called within "
    659             "BeginOutput/EndOutput\n");)
    660         return tc->Error = ACTC_DURING_OUTPUT;
     658        ACTC_DEBUG(fprintf(stderr, "actcEndInput : called within "
     659            "BeginOutput/EndOutput\n");)
     660        return tc->Error = ACTC_DURING_OUTPUT;
    661661    }
    662662
    663663    if(!tc->IsInputting) {
    664         ACTC_DEBUG(fprintf(stderr, "actcEndInput : called outside "
    665             "BeginInput/EndInput\n");)
    666         return tc->Error = ACTC_IDLE;
     664        ACTC_DEBUG(fprintf(stderr, "actcEndInput : called outside "
     665            "BeginInput/EndInput\n");)
     666        return tc->Error = ACTC_IDLE;
    667667    }
    668668
    … …  
    682682
    683683    if(tc->IsInputting) {
    684         ACTC_DEBUG(fprintf(stderr, "actcBeginOutput : called within "
    685             "BeginInput/EndInput\n");)
    686         return tc->Error = ACTC_DURING_INPUT;
     684        ACTC_DEBUG(fprintf(stderr, "actcBeginOutput : called within "
     685            "BeginInput/EndInput\n");)
     686        return tc->Error = ACTC_DURING_INPUT;
    687687    }
    688688
    689689    if(tc->IsOutputting) {
    690         ACTC_DEBUG(fprintf(stderr, "actcBeginOutput : called within "
    691             "BeginOutput/EndOutput\n");)
    692         return tc->Error = ACTC_DURING_OUTPUT;
     690        ACTC_DEBUG(fprintf(stderr, "actcBeginOutput : called within "
     691            "BeginOutput/EndOutput\n");)
     692        return tc->Error = ACTC_DURING_OUTPUT;
    693693    }
    694694
    … …  
    699699    tc->VertexBins = (ACTCVertex **)calloc(sizeof(ACTCVertex *), tc->CurMaxVertValence + 1);
    700700    if(tc->VertexBins == NULL) {
    701         ACTC_DEBUG(fprintf(stderr, "actcBeginOutput : couldn't allocate %d bytes "
    702             "for Vertex Bins\n",
    703             sizeof(ACTCVertex *) * tc->CurMaxVertValence);)
    704         return tc->Error = ACTC_ALLOC_FAILED;
     701        ACTC_DEBUG(fprintf(stderr, "actcBeginOutput : couldn't allocate %d bytes "
     702            "for Vertex Bins\n",
     703            sizeof(ACTCVertex *) * tc->CurMaxVertValence);)
     704        return tc->Error = ACTC_ALLOC_FAILED;
    705705    }
    706706
    707707    if(tc->UsingStaticVerts) {
    708708        double edgeTotal;
    709         for(i = 0; i < tc->VertRange; i++) {
    710             v = &tc->StaticVerts[i];
    711             if(v->Count > 0) {
    712                 v->Next = tc->VertexBins[v->Count];
    713                 v->PointsToMe = &tc->VertexBins[v->Count];
    714                 tc->VertexBins[v->Count] = v;
    715                 if(v->Next != NULL)
    716                     v->Next->PointsToMe = &v->Next;
    717                 if(v->Count < tc->CurMinVertValence)
    718                     tc->CurMinVertValence = v->Count;
    719                 edgeTotal += v->EdgeCount;
    720             }
    721         }
     709        for(i = 0; i < tc->VertRange; i++) {
     710            v = &tc->StaticVerts[i];
     711            if(v->Count > 0) {
     712                v->Next = tc->VertexBins[v->Count];
     713                v->PointsToMe = &tc->VertexBins[v->Count];
     714                tc->VertexBins[v->Count] = v;
     715                if(v->Next != NULL)
     716                    v->Next->PointsToMe = &v->Next;
     717                if(v->Count < tc->CurMinVertValence)
     718                    tc->CurMinVertValence = v->Count;
     719                edgeTotal += v->EdgeCount;
     720            }
     721        }
    722722    } else {
    723         tableResetIterator(tc->VertexIterator);
    724         for(i = 0; i < tc->VertexCount; i++) {
    725             if(tableIterate(tc->Vertices, tc->VertexIterator, NULL, (void **)&v)
    726                 == 0) {
    727                 ACTC_DEBUG(fprintf(stderr, "actcBeginOutput : fewer vertices in "
    728                     "the table than we expected!\n");)
    729                 return tc->Error = ACTC_DATABASE_CORRUPT;
    730             }
    731             v->Next = tc->VertexBins[v->Count];
    732             v->PointsToMe = &tc->VertexBins[v->Count];
    733             tc->VertexBins[v->Count] = v;
    734             if(v->Next != NULL)
    735                 v->Next->PointsToMe = &v->Next;
    736             if(v->Count < tc->CurMinVertValence)
    737                 tc->CurMinVertValence = v->Count;
    738         }
     723        tableResetIterator(tc->VertexIterator);
     724        for(i = 0; i < tc->VertexCount; i++) {
     725            if(tableIterate(tc->Vertices, tc->VertexIterator, NULL, (void **)&v)
     726                == 0) {
     727                ACTC_DEBUG(fprintf(stderr, "actcBeginOutput : fewer vertices in "
     728                    "the table than we expected!\n");)
     729                return tc->Error = ACTC_DATABASE_CORRUPT;
     730            }
     731            v->Next = tc->VertexBins[v->Count];
     732            v->PointsToMe = &tc->VertexBins[v->Count];
     733            tc->VertexBins[v->Count] = v;
     734            if(v->Next != NULL)
     735                v->Next->PointsToMe = &v->Next;
     736            if(v->Count < tc->CurMinVertValence)
     737                tc->CurMinVertValence = v->Count;
     738        }
    739739    }
    740740
    … …  
    745745{
    746746    if(tc->IsInputting) {
    747         ACTC_DEBUG(fprintf(stderr, "actcEndOutput : called within "
    748             "BeginInput/EndInput\n");)
    749         return tc->Error = ACTC_DURING_INPUT;
     747        ACTC_DEBUG(fprintf(stderr, "actcEndOutput : called within "
     748            "BeginInput/EndInput\n");)
     749        return tc->Error = ACTC_DURING_INPUT;
    750750    }
    751751
    752752    if(!tc->IsOutputting) {
    753         ACTC_DEBUG(fprintf(stderr, "actcEndOutput : called outside "
    754             "BeginOutput/EndOutput\n");)
    755         return tc->Error = ACTC_IDLE;
     753        ACTC_DEBUG(fprintf(stderr, "actcEndOutput : called outside "
     754            "BeginOutput/EndOutput\n");)
     755        return tc->Error = ACTC_IDLE;
    756756    }
    757757
    … …  
    759759
    760760    if(tc->UsingStaticVerts) {
    761         free(tc->StaticVerts);
    762         tc->StaticVerts = NULL;
    763         tc->UsingStaticVerts = 0;
     761        free(tc->StaticVerts);
     762        tc->StaticVerts = NULL;
     763        tc->UsingStaticVerts = 0;
    764764    }
    765765
    … …  
    777777
    778778    if(!didPrintVersion) {
    779         int verMinor, verMajor;
    780         didPrintVersion = 1;
     779        int verMinor, verMajor;
     780        didPrintVersion = 1;
    781781
    782782        actcGetParami(tc, ACTC_MAJOR_VERSION, &verMajor);
    783783        actcGetParami(tc, ACTC_MINOR_VERSION, &verMinor);
    784         fprintf(stderr, "TC Version %d.%d\n", verMajor, verMinor);
     784        fprintf(stderr, "TC Version %d.%d\n", verMajor, verMinor);
    785785    }
    786786#endif /* defined(DEBUG) || defined(INFO) */
    … …  
    790790
    791791    if(tc == NULL) {
    792         ACTC_DEBUG(fprintf(stderr, "actcNew : couldn't allocate %d bytes "
    793             "for new ACTCData\n", sizeof(*tc));)
    794         return NULL;
     792        ACTC_DEBUG(fprintf(stderr, "actcNew : couldn't allocate %d bytes "
     793            "for new ACTCData\n", sizeof(*tc));)
     794        return NULL;
    795795    }
    796796
    … …  
    822822    size = sizeof(ACTCEdge) * vert->EdgeCount;
    823823    for(i = 0; i < vert->EdgeCount; i++) {
    824         size += allocatedForTriangles(&vert->Edges[i]);
     824        size += allocatedForTriangles(&vert->Edges[i]);
    825825    }
    826826    return size;
    … …  
    839839        size = tc->VertRange * sizeof(ACTCVertex);
    840840        for(i = 0; i < tc->VertRange; i++) {
    841             v = &tc->StaticVerts[i];
    842             if(v->Count > 0)
    843                 size += allocatedForEdges(v);
    844         }
     841            v = &tc->StaticVerts[i];
     842            if(v->Count > 0)
     843                size += allocatedForEdges(v);
     844        }
    845845    } else {
    846         for(i = 0; i < tc->VertexCount; i++) {
    847             tableIterate(tc->Vertices, tc->VertexIterator, NULL, (void **)&v);
    848             size += allocatedForEdges(v);
    849         }
     846        for(i = 0; i < tc->VertexCount; i++) {
     847            tableIterate(tc->Vertices, tc->VertexIterator, NULL, (void **)&v);
     848            size += allocatedForEdges(v);
     849        }
    850850    }
    851851    return size;
    … …  
    882882    if(tc->VertexBins != NULL) {
    883883        free(tc->VertexBins);
    884         tc->VertexBins = NULL;
     884        tc->VertexBins = NULL;
    885885    }
    886886    tc->IsOutputting = 0;
    … …  
    900900{
    901901    if(tc->IsInputting) {
    902         ACTC_DEBUG(fprintf(stderr, "actcParami : within BeginInput/"
    903             "EndInput\n");)
    904         return tc->Error = ACTC_DURING_INPUT;
     902        ACTC_DEBUG(fprintf(stderr, "actcParami : within BeginInput/"
     903            "EndInput\n");)
     904        return tc->Error = ACTC_DURING_INPUT;
    905905    }
    906906    if(tc->IsOutputting) {
    907         ACTC_DEBUG(fprintf(stderr, "actcParami : within BeginOutput/"
    908             "EndOutput\n");)
    909         return tc->Error = ACTC_DURING_OUTPUT;
     907        ACTC_DEBUG(fprintf(stderr, "actcParami : within BeginOutput/"
     908            "EndOutput\n");)
     909        return tc->Error = ACTC_DURING_OUTPUT;
    910910    }
    911911    switch(param) {
    912         case ACTC_OUT_MIN_FAN_VERTS:
    913             tc->MinFanVerts = value;
    914             break;
    915 
    916         case ACTC_IN_MAX_VERT:
    917             if(value < tc->MinInputVert) {
    918                 ACTC_DEBUG(fprintf(stderr, "actcParami : tried to set "
    919                     "MAX_INPUT_VERT to %d, less than MIN_INPUT_VERT (%d)\n",
    920                     value, tc->MinInputVert);)
    921                 return tc->Error = ACTC_INVALID_VALUE;
    922             }
    923             tc->MaxInputVert = value;
    924             break;
    925 
    926         case ACTC_IN_MIN_VERT:
    927             if(value > tc->MaxInputVert) {
    928                 ACTC_DEBUG(fprintf(stderr, "actcParami : tried to set "
    929                     "MIN_INPUT_VERT to %d, greater than MAX_INPUT_VERT (%d)\n",
    930                     value, tc->MaxInputVert);)
    931                 return tc->Error = ACTC_INVALID_VALUE;
    932             }
    933             tc->MinInputVert = value;
    934             break;
    935 
    936         case ACTC_IN_MAX_EDGE_SHARING:
    937             tc->MaxEdgeShare = value;
    938             break;
    939 
    940         case ACTC_IN_MAX_VERT_SHARING:
    941             tc->MaxVertShare = value;
    942             break;
    943 
    944         case ACTC_OUT_HONOR_WINDING:
    945             tc->HonorWinding = value;
    946             break;
    947 
    948         case ACTC_OUT_MAX_PRIM_VERTS:
    949             if(value < 3) {
    950                 ACTC_DEBUG(fprintf(stderr, "actcParami : tried to set "
    951                     "MAX_PRIM_VERTS to %d (needed to be 3 or more)\n", value);)
    952                 return tc->Error = ACTC_INVALID_VALUE;
    953             }
    954             tc->MaxPrimVerts = value;
    955             break;
    956 
    957     }
    958     return ACTC_NO_ERROR;
    959 }
    960 
    961 int actcParamu(ACTCData *tc, int param, uint value)
     912        case ACTC_OUT_MIN_FAN_VERTS:
     913            tc->MinFanVerts = value;
     914            break;
     915
     916        case ACTC_IN_MAX_VERT:
     917            if(value < tc->MinInputVert) {
     918                ACTC_DEBUG(fprintf(stderr, "actcParami : tried to set "
     919                    "MAX_INPUT_VERT to %d, less than MIN_INPUT_VERT (%d)\n",
     920                    value, tc->MinInputVert);)
     921                return tc->Error = ACTC_INVALID_VALUE;
     922            }
     923            tc->MaxInputVert = value;
     924            break;
     925
     926        case ACTC_IN_MIN_VERT:
     927            if(value > tc->MaxInputVert) {
     928                ACTC_DEBUG(fprintf(stderr, "actcParami : tried to set "
     929                    "MIN_INPUT_VERT to %d, greater than MAX_INPUT_VERT (%d)\n",
     930                    value, tc->MaxInputVert);)
     931                return tc->Error = ACTC_INVALID_VALUE;
     932            }
     933            tc->MinInputVert = value;
     934            break;
     935
     936        case ACTC_IN_MAX_EDGE_SHARING:
     937            tc->MaxEdgeShare = value;
     938            break;
     939
     940        case ACTC_IN_MAX_VERT_SHARING:
     941            tc->MaxVertShare = value;
     942            break;
     943
     944        case ACTC_OUT_HONOR_WINDING:
     945            tc->HonorWinding = value;
     946            break;
     947
     948        case ACTC_OUT_MAX_PRIM_VERTS:
     949            if(value < 3) {
     950                ACTC_DEBUG(fprintf(stderr, "actcParami : tried to set "
     951                    "MAX_PRIM_VERTS to %d (needed to be 3 or more)\n", value);)
     952                return tc->Error = ACTC_INVALID_VALUE;
     953            }
     954            tc->MaxPrimVerts = value;
     955            break;
     956
     957    }
     958    return ACTC_NO_ERROR;
     959}
     960
     961int actcParamu(ACTCData *tc, int param, unsigned int value)
    962962{
    963963    /*
    … …  
    972972{
    973973    switch(param) {
    974         case ACTC_MAJOR_VERSION:
    975             *value = 1;
    976             break;
    977 
    978         case ACTC_MINOR_VERSION:
    979             *value = 1;
    980             break;
    981 
    982         case ACTC_IN_MAX_VERT:
    983             *value = tc->MaxInputVert;
    984             break;
    985 
    986         case ACTC_IN_MIN_VERT:
    987             *value = tc->MinInputVert;
    988             break;
    989 
    990         case ACTC_IN_MAX_EDGE_SHARING:
    991             *value = tc->MaxEdgeShare;
    992             break;
    993 
    994         case ACTC_IN_MAX_VERT_SHARING:
    995             *value = tc->MaxVertShare;
    996             break;
    997 
    998         case ACTC_OUT_MIN_FAN_VERTS:
    999             *value = tc->MinFanVerts;
    1000             break;
    1001 
    1002         case ACTC_OUT_HONOR_WINDING:
    1003             *value = tc->HonorWinding;
    1004             break;
    1005 
    1006         case ACTC_OUT_MAX_PRIM_VERTS:
    1007             *value = tc->MaxPrimVerts;
    1008             break;
    1009 
    1010         default:
    1011             *value = 0;
    1012             return tc->Error = ACTC_INVALID_VALUE;
    1013             /* break; */
    1014     }
    1015     return ACTC_NO_ERROR;
    1016 }
    1017 
    1018 int actcGetParamu(ACTCData *tc, int param, uint *value)
     974        case ACTC_MAJOR_VERSION:
     975            *value = 1;
     976            break;
     977
     978        case ACTC_MINOR_VERSION:
     979            *value = 1;
     980            break;
     981
     982        case ACTC_IN_MAX_VERT:
     983            *value = tc->MaxInputVert;
     984            break;
     985
     986        case ACTC_IN_MIN_VERT:
     987            *value = tc->MinInputVert;
     988            break;
     989
     990        case ACTC_IN_MAX_EDGE_SHARING:
     991            *value = tc->MaxEdgeShare;
     992            break;
     993
     994        case ACTC_IN_MAX_VERT_SHARING:
     995            *value = tc->MaxVertShare;
     996            break;
     997
     998        case ACTC_OUT_MIN_FAN_VERTS:
     999            *value = tc->MinFanVerts;
     1000            break;
     1001
     1002        case ACTC_OUT_HONOR_WINDING:
     1003            *value = tc->HonorWinding;
     1004            break;
     1005
     1006        case ACTC_OUT_MAX_PRIM_VERTS:
     1007            *value = tc->MaxPrimVerts;
     1008            break;
     1009
     1010        default:
     1011            *value = 0;
     1012            return tc->Error = ACTC_INVALID_VALUE;
     1013            /* break; */
     1014    }
     1015    return ACTC_NO_ERROR;
     1016}
     1017
     1018int actcGetParamu(ACTCData *tc, int param, unsigned int *value)
    10191019{
    10201020    return actcGetParami(tc, param, (int *)value);
    … …  
    10281028    tmp.FinalVert = v3;
    10291029    chartedSetLabel("triangle list");
    1030     r = reallocAndAppend((void **)&edge->Triangles, (uint*)&edge->TriangleCount,
     1030    r = reallocAndAppend((void **)&edge->Triangles, (unsigned int*)&edge->TriangleCount,
    10311031        sizeof(tmp), &tmp);
    10321032    if(r == NULL) {
    1033         ACTC_DEBUG(fprintf(stderr, "ACTC::mapEdgeTriangle : Couldn't allocate "
    1034             "%d bytes for triangles\n", sizeof(tmp) *
    1035             (edge->TriangleCount + 1));)
    1036         return tc->Error = ACTC_ALLOC_FAILED;
     1033        ACTC_DEBUG(fprintf(stderr, "ACTC::mapEdgeTriangle : Couldn't allocate "
     1034            "%d bytes for triangles\n", sizeof(tmp) *
     1035            (edge->TriangleCount + 1));)
     1036        return tc->Error = ACTC_ALLOC_FAILED;
    10371037    }
    10381038
    … …  
    10451045
    10461046    for(i = 0; i < edge->TriangleCount; i++)
    1047         if(edge->Triangles[i].FinalVert == v3)
    1048             break;
     1047        if(edge->Triangles[i].FinalVert == v3)
     1048            break;
    10491049
    10501050    if(i == edge->TriangleCount) {
    1051         ACTC_DEBUG(
    1052             fprintf(stderr, "ACTC::unmapEdgeTriangle : Couldn't find third vertex"
    1053                 " from edge in order to delete it?!?\n");
    1054             abortWithOptionalDump(tc);
    1055         )
    1056         return tc->Error = ACTC_DATABASE_CORRUPT;
     1051        ACTC_DEBUG(
     1052            fprintf(stderr, "ACTC::unmapEdgeTriangle : Couldn't find third vertex"
     1053                " from edge in order to delete it?!?\n");
     1054            abortWithOptionalDump(tc);
     1055        )
     1056        return tc->Error = ACTC_DATABASE_CORRUPT;
    10571057    }
    10581058
    … …  
    10651065static int mapVertexEdge(ACTCData *tc, ACTCVertex *v1, ACTCVertex *v2, ACTCEdge **edge)
    10661066{
    1067     uint i;
     1067    unsigned int i;
    10681068    ACTCEdge tmp;
    10691069    void *r;
    … …  
    10711071    for(i = 0; i < v1->EdgeCount; i++)
    10721072        if(v1->Edges[i].V2 == v2) {
    1073             v1->Edges[i].Count++;
    1074             break;
    1075         }
     1073            v1->Edges[i].Count++;
     1074            break;
     1075        }
    10761076
    10771077    if(i == v1->EdgeCount) {
    10781078
    1079         tmp.V2 = v2;
    1080         tmp.Count = 1;
    1081         tmp.Triangles = NULL;
    1082         tmp.TriangleCount = 0;
    1083 
    1084         chartedSetLabel("vert-to-edge mapping");
    1085         r = reallocAndAppend((void **)&v1->Edges, (uint*)&v1->EdgeCount,
    1086             sizeof(tmp), &tmp);
    1087         if(r == NULL) {
    1088             ACTC_DEBUG(fprintf(stderr, "ACTC::mapVertexEdge : Couldn't reallocate "
    1089                 "to %d bytes for vertex's edge list\n", sizeof(tmp) *
    1090                 v1->EdgeCount);)
    1091             return tc->Error = ACTC_ALLOC_FAILED;
    1092         }
     1079        tmp.V2 = v2;
     1080        tmp.Count = 1;
     1081        tmp.Triangles = NULL;
     1082        tmp.TriangleCount = 0;
     1083
     1084        chartedSetLabel("vert-to-edge mapping");
     1085        r = reallocAndAppend((void **)&v1->Edges, (unsigned int*)&v1->EdgeCount,
     1086            sizeof(tmp), &tmp);
     1087        if(r == NULL) {
     1088            ACTC_DEBUG(fprintf(stderr, "ACTC::mapVertexEdge : Couldn't reallocate "
     1089                "to %d bytes for vertex's edge list\n", sizeof(tmp) *
     1090                v1->EdgeCount);)
     1091            return tc->Error = ACTC_ALLOC_FAILED;
     1092        }
    10931093    }
    10941094    *edge = &v1->Edges[i];
    … …  
    11021102
    11031103    for(i = 0; i < v1->EdgeCount; i++)
    1104         if(v1->Edges[i].V2 == v2)
    1105             break;
     1104        if(v1->Edges[i].V2 == v2)
     1105            break;
    11061106
    11071107    if(i == v1->EdgeCount) {
    1108         ACTC_DEBUG(
    1109             fprintf(stderr, "ACTC::unmapVertexEdge : Couldn't find edge %d,%d"
    1110                 " from vertex in order to unmap it?!?\n", v1->V, v2->V);
    1111             abortWithOptionalDump(tc);
    1112         )
    1113         return tc->Error = ACTC_DATABASE_CORRUPT;
     1108        ACTC_DEBUG(
     1109            fprintf(stderr, "ACTC::unmapVertexEdge : Couldn't find edge %d,%d"
     1110                " from vertex in order to unmap it?!?\n", v1->V, v2->V);
     1111            abortWithOptionalDump(tc);
     1112        )
     1113        return tc->Error = ACTC_DATABASE_CORRUPT;
    11141114    }
    11151115
    … …  
    11171117    if(v1->Edges[i].Count == 0) {
    11181118        if(v1->Edges[i].Triangles != NULL)
    1119             free(v1->Edges[i].Triangles);
    1120         v1->Edges[i] = v1->Edges[v1->EdgeCount - 1];
    1121         v1->EdgeCount --;
    1122     }
    1123 
    1124     return ACTC_NO_ERROR;
    1125 }
    1126 
    1127 int actcAddTriangle(ACTCData *tc, uint v1, uint v2, uint v3)
     1119            free(v1->Edges[i].Triangles);
     1120        v1->Edges[i] = v1->Edges[v1->EdgeCount - 1];
     1121        v1->EdgeCount --;
     1122    }
     1123
     1124    return ACTC_NO_ERROR;
     1125}
     1126
     1127int actcAddTriangle(ACTCData *tc, unsigned int v1, unsigned int v2, unsigned int v3)
    11281128{
    11291129    ACTCVertex *vertexRec1;
    … …  
    11361136
    11371137    if(tc->IsOutputting) {
    1138         ACTC_DEBUG(fprintf(stderr, "actcAddTriangle : inside "
    1139             "BeginOutput/EndOutput\n");)
    1140         return tc->Error = ACTC_IDLE;
     1138        ACTC_DEBUG(fprintf(stderr, "actcAddTriangle : inside "
     1139            "BeginOutput/EndOutput\n");)
     1140        return tc->Error = ACTC_IDLE;
    11411141    }
    11421142    if(!tc->IsInputting) {
    1143         ACTC_DEBUG(fprintf(stderr, "actcAddTriangle : outside "
    1144             "BeginInput/EndInput\n");)
    1145         return tc->Error = ACTC_DURING_INPUT;
     1143        ACTC_DEBUG(fprintf(stderr, "actcAddTriangle : outside "
     1144            "BeginInput/EndInput\n");)
     1145        return tc->Error = ACTC_DURING_INPUT;
    11461146    }
    11471147
    … …  
    11911191}
    11921192
    1193 int actcStartNextPrim(ACTCData *tc, uint *v1Return, uint *v2Return)
     1193int actcStartNextPrim(ACTCData *tc, unsigned int *v1Return, unsigned int *v2Return)
    11941194{
    11951195    ACTCVertex *v1 = NULL;
    … …  
    11981198
    11991199    if(tc->IsInputting) {
    1200         ACTC_DEBUG(fprintf(stderr, "actcStartNextPrim : within "
    1201             "BeginInput/EndInput\n");)
    1202         return tc->Error = ACTC_DURING_INPUT;
     1200        ACTC_DEBUG(fprintf(stderr, "actcStartNextPrim : within "
     1201            "BeginInput/EndInput\n");)
     1202        return tc->Error = ACTC_DURING_INPUT;
    12031203    }
    12041204    if(!tc->IsOutputting) {
    1205         ACTC_DEBUG(fprintf(stderr, "actcStartNextPrim : outside "
    1206             "BeginOutput/EndOutput\n");)
    1207         return tc->Error = ACTC_IDLE;
     1205        ACTC_DEBUG(fprintf(stderr, "actcStartNextPrim : outside "
     1206            "BeginOutput/EndOutput\n");)
     1207        return tc->Error = ACTC_IDLE;
    12081208    }
    12091209
    12101210    findResult = findNextFanVertex(tc, &v1);
    12111211    if(findResult == ACTC_NO_ERROR)
    1212         tc->PrimType = ACTC_PRIM_FAN;
     1212        tc->PrimType = ACTC_PRIM_FAN;
    12131213    else if(findResult != ACTC_NO_MATCHING_VERT) {
    1214         ACTC_DEBUG(fprintf(stderr, "actcStartNextPrim : internal "
    1215             "error finding next appropriate vertex\n");)
    1216         return tc->Error = findResult;
     1214        ACTC_DEBUG(fprintf(stderr, "actcStartNextPrim : internal "
     1215            "error finding next appropriate vertex\n");)
     1216        return tc->Error = findResult;
    12171217    } else {
    1218         findResult = findNextStripVertex(tc, &v1);
    1219         if(findResult != ACTC_NO_ERROR && findResult != ACTC_NO_MATCHING_VERT) {
    1220             ACTC_DEBUG(fprintf(stderr, "actcStartNextPrim : internal "
    1221                 "error finding next appropriate vertex\n");)
    1222             return tc->Error = findResult;
    1223         }
    1224         tc->PrimType = ACTC_PRIM_STRIP;
     1218        findResult = findNextStripVertex(tc, &v1);
     1219        if(findResult != ACTC_NO_ERROR && findResult != ACTC_NO_MATCHING_VERT) {
     1220            ACTC_DEBUG(fprintf(stderr, "actcStartNextPrim : internal "
     1221                "error finding next appropriate vertex\n");)
     1222            return tc->Error = findResult;
     1223        }
     1224        tc->PrimType = ACTC_PRIM_STRIP;
    12251225    }
    12261226
    12271227    if(findResult == ACTC_NO_MATCHING_VERT) {
    1228         *v1Return = -1;
    1229         *v2Return = -1;
    1230         return tc->Error = ACTC_DATABASE_EMPTY;
     1228        *v1Return = -1;
     1229        *v2Return = -1;
     1230        return tc->Error = ACTC_DATABASE_EMPTY;
    12311231    }
    12321232
    … …  
    12531253    for(i = 0; i < v1->EdgeCount; i++)
    12541254        if(v1->Edges[i].V2 == v2) {
    1255             *edge = &v1->Edges[i];
    1256             return 1;
    1257         }
     1255            *edge = &v1->Edges[i];
     1256            return 1;
     1257        }
    12581258    return 0;
    12591259}
    … …  
    12691269}
    12701270
    1271 int actcGetNextVert(ACTCData *tc, uint *vertReturn)
     1271int actcGetNextVert(ACTCData *tc, unsigned int *vertReturn)
    12721272{
    12731273    ACTCEdge *edge;
    … …  
    12771277
    12781278    if(tc->IsInputting) {
    1279         ACTC_DEBUG(fprintf(stderr, "actcGetNextVert : within BeginInput/"
    1280             "EndInput\n");)
    1281         return tc->Error = ACTC_DURING_INPUT;
     1279        ACTC_DEBUG(fprintf(stderr, "actcGetNextVert : within BeginInput/"
     1280            "EndInput\n");)
     1281        return tc->Error = ACTC_DURING_INPUT;
    12821282    }
    12831283    if(!tc->IsOutputting) {
    1284         ACTC_DEBUG(fprintf(stderr, "actcGetNextVert : outside BeginOutput/"
    1285             "EndOutput\n");)
    1286         return tc->Error = ACTC_IDLE;
     1284        ACTC_DEBUG(fprintf(stderr, "actcGetNextVert : outside BeginOutput/"
     1285            "EndOutput\n");)
     1286        return tc->Error = ACTC_IDLE;
    12871287    }
    12881288    if(tc->PrimType == -1) {
    1289         ACTC_DEBUG(fprintf(stderr, "actcGetNextVert : Asked for next vertex "
    1290             "without a primitive (got last\n    vertex already?)\n");)
    1291         return tc->Error = ACTC_INVALID_VALUE;
     1289        ACTC_DEBUG(fprintf(stderr, "actcGetNextVert : Asked for next vertex "
     1290            "without a primitive (got last\n    vertex already?)\n");)
     1291        return tc->Error = ACTC_INVALID_VALUE;
    12921292    }
    12931293
    12941294    if(tc->VerticesSoFar >= tc->MaxPrimVerts) {
    1295         tc->PrimType = -1;
    1296         return tc->Error = ACTC_PRIM_COMPLETE;
     1295        tc->PrimType = -1;
     1296        return tc->Error = ACTC_PRIM_COMPLETE;
    12971297    }
    12981298
    12991299    if(tc->V1 == NULL || tc->V2 == NULL) {
    1300         tc->PrimType = -1;
    1301         return tc->Error = ACTC_PRIM_COMPLETE;
     1300        tc->PrimType = -1;
     1301        return tc->Error = ACTC_PRIM_COMPLETE;
    13021302    }
    13031303
    … …  
    13071307
    13081308    if(findEdge(tc->V1, tc->V2, &edge) != 0) {
    1309         wasEdgeFound = 1;
     1309        wasEdgeFound = 1;
    13101310    } else if(!tc->HonorWinding) {
    1311         wasFoundReversed = 1;
    1312         if(findEdge(tc->V2, tc->V1, &edge) != 0) {
    1313             wasEdgeFound = 1;
    1314         }
     1311        wasFoundReversed = 1;
     1312        if(findEdge(tc->V2, tc->V1, &edge) != 0) {
     1313            wasEdgeFound = 1;
     1314        }
    13151315    }
    13161316
    13171317    if(!wasEdgeFound) {
    1318         tc->PrimType = -1;
    1319         return tc->Error = ACTC_PRIM_COMPLETE;
     1318        tc->PrimType = -1;
     1319        return tc->Error = ACTC_PRIM_COMPLETE;
    13201320    }
    13211321
    … …  
    13261326
    13271327    if(wasFoundReversed) {
    1328         ACTC_CHECK(unmapEdgeTriangle(tc, edge, thirdVertex));
    1329         ACTC_CHECK(unmapEdgeTriangleByVerts(tc, tc->V1, thirdVertex, tc->V2));
    1330         ACTC_CHECK(unmapEdgeTriangleByVerts(tc, thirdVertex, tc->V2, tc->V1));
    1331         ACTC_CHECK(unmapVertexEdge(tc, tc->V2, tc->V1));
    1332         ACTC_CHECK(unmapVertexEdge(tc, tc->V1, thirdVertex));
    1333         ACTC_CHECK(unmapVertexEdge(tc, thirdVertex, tc->V2));
     1328        ACTC_CHECK(unmapEdgeTriangle(tc, edge, thirdVertex));
     1329        ACTC_CHECK(unmapEdgeTriangleByVerts(tc, tc->V1, thirdVertex, tc->V2));
     1330        ACTC_CHECK(unmapEdgeTriangleByVerts(tc, thirdVertex, tc->V2, tc->V1));
     1331        ACTC_CHECK(unmapVertexEdge(tc, tc->V2, tc->V1));
     1332        ACTC_CHECK(unmapVertexEdge(tc, tc->V1, thirdVertex));
     1333        ACTC_CHECK(unmapVertexEdge(tc, thirdVertex, tc->V2));
    13341334    } else {
    1335         ACTC_CHECK(unmapEdgeTriangle(tc, edge, thirdVertex));
    1336         ACTC_CHECK(unmapEdgeTriangleByVerts(tc, tc->V2, thirdVertex, tc->V1));
    1337         ACTC_CHECK(unmapEdgeTriangleByVerts(tc, thirdVertex, tc->V1, tc->V2));
    1338         ACTC_CHECK(unmapVertexEdge(tc, tc->V1, tc->V2));
    1339         ACTC_CHECK(unmapVertexEdge(tc, tc->V2, thirdVertex));
    1340         ACTC_CHECK(unmapVertexEdge(tc, thirdVertex, tc->V1));
     1335        ACTC_CHECK(unmapEdgeTriangle(tc, edge, thirdVertex));
     1336        ACTC_CHECK(unmapEdgeTriangleByVerts(tc, tc->V2, thirdVertex, tc->V1));
     1337        ACTC_CHECK(unmapEdgeTriangleByVerts(tc, thirdVertex, tc->V1, tc->V2));
     1338        ACTC_CHECK(unmapVertexEdge(tc, tc->V1, tc->V2));
     1339        ACTC_CHECK(unmapVertexEdge(tc, tc->V2, thirdVertex));
     1340        ACTC_CHECK(unmapVertexEdge(tc, thirdVertex, tc->V1));
    13411341    }
    13421342    ACTC_CHECK(decVertexValence(tc, &tc->V1));
    … …  
    13471347        tc->V2 = thirdVertex;
    13481348    } else /* PRIM_STRIP */ {
    1349         if(tc->CurWindOrder == ACTC_FWD_ORDER)
    1350             tc->V1 = thirdVertex;
    1351         else
    1352             tc->V2 = thirdVertex;
    1353         tc->CurWindOrder = !tc->CurWindOrder;
     1349        if(tc->CurWindOrder == ACTC_FWD_ORDER)
     1350            tc->V1 = thirdVertex;
     1351        else
     1352            tc->V2 = thirdVertex;
     1353        tc->CurWindOrder = !tc->CurWindOrder;
    13541354    }
    13551355
    … …  
    13591359
    13601360int actcTrianglesToPrimitives(ACTCData *tc, int triangleCount,
    1361     uint (*triangles)[3], int primTypes[], int primLengths[], uint vertices[],
     1361    unsigned int (*triangles)[3], int primTypes[], int primLengths[], unsigned int vertices[],
    13621362    int maxBatchSize)
    13631363{
    … …  
    13651365    int curTriangle;
    13661366    int curPrimitive;
    1367     uint curVertex;
     1367    unsigned int curVertex;
    13681368    int prim;
    1369     uint v1, v2, v3;
     1369    unsigned int v1, v2, v3;
    13701370    int lastPrim;
    13711371    int passesWithoutPrims;
    … …  
    13731373
    13741374    if(tc->IsInputting) {
    1375         ACTC_DEBUG(fprintf(stderr, "actcTrianglesToPrimitives : within BeginInput/"
    1376             "EndInput\n");)
    1377         return tc->Error = ACTC_DURING_INPUT;
     1375        ACTC_DEBUG(fprintf(stderr, "actcTrianglesToPrimitives : within BeginInput/"
     1376            "EndInput\n");)
     1377        return tc->Error = ACTC_DURING_INPUT;
    13781378    }
    13791379    if(tc->IsOutputting) {
    1380         ACTC_DEBUG(fprintf(stderr, "actcTrianglesToPrimitives : within"
    1381             "BeginOutput/EndOutput\n");)
    1382         return tc->Error = ACTC_DURING_OUTPUT;
     1380        ACTC_DEBUG(fprintf(stderr, "actcTrianglesToPrimitives : within"
     1381            "BeginOutput/EndOutput\n");)
     1382        return tc->Error = ACTC_DURING_OUTPUT;
    13831383    }
    13841384    curTriangle = 0;
    … …  
    13921392    trisSoFar = 0;
    13931393    while(curTriangle < triangleCount) {
    1394         r = actcAddTriangle(tc, triangles[curTriangle][0],
    1395             triangles[curTriangle][1], triangles[curTriangle][2]);
    1396         trisSoFar++;
    1397         curTriangle++;
    1398         if((trisSoFar >= maxBatchSize) ||
    1399             (r == ACTC_ALLOC_FAILED && curTriangle != triangleCount) ||
    1400             (r == ACTC_NO_ERROR && curTriangle == triangleCount)) {
    1401 
    1402             /* drain what we got */
    1403             trisSoFar = 0;
    1404             ACTC_CHECK(actcEndInput(tc));
    1405             ACTC_CHECK(actcBeginOutput(tc));
    1406             lastPrim = curPrimitive;
    1407             while((prim = actcStartNextPrim(tc, &v1, &v2)) != ACTC_DATABASE_EMPTY) {
    1408                 ACTC_CHECK(prim);
    1409                 primTypes[curPrimitive] = prim;
    1410                 primLengths[curPrimitive] = 2;
    1411                 vertices[curVertex++] = v1;
    1412                 vertices[curVertex++] = v2;
    1413                 while((r = actcGetNextVert(tc, &v3)) != ACTC_PRIM_COMPLETE) {
    1414                     ACTC_CHECK(r);
    1415                     vertices[curVertex++] = v3;
    1416                     primLengths[curPrimitive]++;
    1417                 }
    1418                 curPrimitive++;
    1419             }
    1420             ACTC_CHECK(actcEndOutput(tc));
    1421             if(r == ACTC_ALLOC_FAILED && curPrimitive == lastPrim) {
    1422                 if(passesWithoutPrims == 0) {
    1423                     /* not enough memory to add a triangle and */
    1424                     /* nothing in the database, better free everything */
    1425                     /* and try again */
    1426                     actcMakeEmpty(tc);
    1427                 } else {
    1428                     /* cleaned up and STILL couldn't get a triangle in; */
    1429                     /* give up */
    1430                     return tc->Error = ACTC_ALLOC_FAILED;
    1431                 }
    1432                 passesWithoutPrims++;
    1433             }
    1434             ACTC_CHECK(actcBeginInput(tc));
    1435         } else
    1436             ACTC_CHECK(r);
    1437         if(r == ACTC_ALLOC_FAILED)
    1438             curTriangle--;
     1394        r = actcAddTriangle(tc, triangles[curTriangle][0],
     1395            triangles[curTriangle][1], triangles[curTriangle][2]);
     1396        trisSoFar++;
     1397        curTriangle++;
     1398        if((trisSoFar >= maxBatchSize) ||
     1399            (r == ACTC_ALLOC_FAILED && curTriangle != triangleCount) ||
     1400            (r == ACTC_NO_ERROR && curTriangle == triangleCount)) {
     1401
     1402            /* drain what we got */
     1403            trisSoFar = 0;
     1404            ACTC_CHECK(actcEndInput(tc));
     1405            ACTC_CHECK(actcBeginOutput(tc));
     1406            lastPrim = curPrimitive;
     1407            while((prim = actcStartNextPrim(tc, &v1, &v2)) != ACTC_DATABASE_EMPTY) {
     1408                ACTC_CHECK(prim);
     1409                primTypes[curPrimitive] = prim;
     1410                primLengths[curPrimitive] = 2;
     1411                vertices[curVertex++] = v1;
     1412                vertices[curVertex++] = v2;
     1413                while((r = actcGetNextVert(tc, &v3)) != ACTC_PRIM_COMPLETE) {
     1414                    ACTC_CHECK(r);
     1415                    vertices[curVertex++] = v3;
     1416                    primLengths[curPrimitive]++;
     1417                }
     1418                curPrimitive++;
     1419            }
     1420            ACTC_CHECK(actcEndOutput(tc));
     1421            if(r == ACTC_ALLOC_FAILED && curPrimitive == lastPrim) {
     1422                if(passesWithoutPrims == 0) {
     1423                    /* not enough memory to add a triangle and */
     1424                    /* nothing in the database, better free everything */
     1425                    /* and try again */
     1426                    actcMakeEmpty(tc);
     1427                } else {
     1428                    /* cleaned up and STILL couldn't get a triangle in; */
     1429                    /* give up */
     1430                    return tc->Error = ACTC_ALLOC_FAILED;
     1431                }
     1432                passesWithoutPrims++;
     1433            }
     1434            ACTC_CHECK(actcBeginInput(tc));
     1435        } else
     1436            ACTC_CHECK(r);
     1437        if(r == ACTC_ALLOC_FAILED)
     1438            curTriangle--;
    14391439    }
    14401440    ACTC_CHECK(actcEndInput(tc));
Note: See TracChangeset for help on using the changeset viewer.