Changeset 1559


Ignore:
Timestamp:
10/03/06 12:35:03 (18 years ago)
Author:
gumbau
Message:
 
Location:
GTP/trunk/Lib/Geom/shared/GTGeometry
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoMeshStripifier.h

    r993 r1559  
    399399                        void Last_Edge(int *id1, int *id2, int *id3, BOOL save); 
    400400 
    401                         void preserve_strip_orientation_with_normal(FILE        *output, 
     401                        void preserve_strip_orientation_with_normal( 
    402402                                        int             vertex1, 
    403403                                        int             normal1, 
     
    407407                                        int             normal3); 
    408408 
    409                         void preserve_strip_orientation_with_texture(   FILE    *output, 
     409                        void preserve_strip_orientation_with_texture( 
    410410                                        int             vertex1, 
    411411                                        int             texture1, 
     
    415415                                        int texture3); 
    416416 
    417                         void  preserve_strip_orientation_with_texture_and_normal(       FILE    *output, 
     417                        void  preserve_strip_orientation_with_texture_and_normal( 
    418418                                        int             vertex1, 
    419419                                        int             texture1, 
     
    426426                                        int             normal3); 
    427427 
    428                         void preserve_strip_orientation(FILE *output, 
     428                        void preserve_strip_orientation( 
    429429                                        int vertex1, 
    430430                                        int vertex2, 
     
    438438                        /**     local.h 
    439439                        */ 
    440                         void Find_StripsEx(     FILE *output,   int *ties, 
    441                                         int  tie,                       int triangulate, 
    442                                         int  swaps,             int *next_id); 
    443                         void SGI_Strip(int num_faces,FILE *output, int ties,int triangulate); 
     440                        void Find_StripsEx(int *ties, int  tie, int triangulate, int  swaps, int *next_id); 
     441                        void SGI_Strip(int num_faces,int ties,int triangulate); 
    444442 
    445443                        /**     outputex.h 
    446444                        */ 
    447                         void Output_TriEx(int id1, int id2, int id3, FILE *output,  
    448                                         int flag,int where); 
    449                         void Extend_BackwardsEx(int face_id, FILE *output, int *ties,  
     445                        void Output_TriEx(int id1, int id2, int id3, int flag,int where); 
     446                        void Extend_BackwardsEx(int face_id, int *ties,  
    450447                                        int tie, int triangulate,  
    451448                                        int swaps,int *next_id); 
    452449                        void Polygon_OutputEx(P_ADJACENCIES temp,int face_id,int bucket, 
    453                                         ListHead *pListHead, FILE *output, 
     450                                        ListHead *pListHead, 
    454451                                        int *ties, int tie,int triangulate, int swaps, 
    455452                                        int *next_id, int where); 
     
    460457                        void Build_SGI_Table(int num_faces); 
    461458                        void Non_Blind_Triangulate(     int size,int *index, 
    462                                         FILE *output,int next_face_id, 
     459                                        int next_face_id, 
    463460                                        int face_id,int where, 
    464461                                        int color1,int color2,int color3); 
     
    472469                                        int in_edge1,   int in_edge2, 
    473470                                        int size,                       int *index, 
    474                                         FILE *output,   int reversed, 
     471                                        int reversed, 
    475472                                        int face_id,    int where, 
    476473                                        int color1,             int color2, 
     
    479476                        void Triangulate(       int out_edge1,int out_edge2,int in_edge1, 
    480477                                        int in_edge2,int size,int *index, 
    481                                         FILE *output,int reversed,int face_id, int where, 
     478                                        int reversed,int face_id, int where, 
    482479                                        int color1, int color2,int color3);     //      static. 
    483480 
     
    576573                        void Triangulate_PolygonEx(     int out_edge1,int out_edge2,int in_edge1, 
    577574                                        int in_edge2,int size,int *index, 
    578                                         FILE *fp,int reversed,int face_id, 
     575                                        int reversed,int face_id, 
    579576                                        int where); 
    580577                        void Non_Blind_TriangulateEx(   int size,int *index, 
    581                                         FILE *output,int next_face_id, 
     578                                        int next_face_id, 
    582579                                        int face_id,int where); 
    583580                        void Rearrange_IndexEx(int *index, int size); 
     
    590587                                        int in_edge1, int in_edge2, 
    591588                                        int size,                       int *index, 
    592                                         FILE *output,   int reversed, 
     589                                        int reversed, 
    593590                                        int face_id,    int where);     //      static. 
    594591 
     
    620617                        */ 
    621618                        void Partial_Triangulate(int size,              int *index, 
    622                                         FILE *output,   int next_face_id, 
     619                                        int next_face_id, 
    623620                                        int face_id,    int *next_id, 
    624621                                        ListHead *pListHead, 
     
    640637                                        int in_edge1, int in_edge2, 
    641638                                        int size,               int *index, 
    642                                         FILE *fp,                 int reversed, 
     639                                        int reversed, 
    643640                                        int face_id,    int *next_id, 
    644641                                        ListHead *pListHead, 
     
    647644                        void P_Triangulate(     int out_edge1,int out_edge2,int in_edge1, 
    648645                                        int in_edge2,   int size,                       int *index, 
    649                                         FILE *output,   int reversed,   int face_id, 
     646                                        int reversed,   int face_id, 
    650647                                        int *next_id,   ListHead *pListHead,  
    651648                                        P_ADJACENCIES temp,int where);  //      static. 
     
    657654                        /**     output.h 
    658655                        */ 
    659                         int Finished(int *swap, FILE *output, int startnewstrip); 
     656                        int Finished(int *swap, int startnewstrip); 
    660657                        void Output_Tri(int id1, int id2, int id3,BOOL end); 
    661                         int Extend_Face(int face_id,int e1,int e2,int *swaps,FILE *bands, 
     658                        int Extend_Face(int face_id,int e1,int e2,int *swaps, 
    662659                                        int color1,int color2,int color3,int *vert_norm, 
    663660                                        int normals,int *vert_texture,int texture); 
     
    665662                                        int bucket,                             ListHead *pListHead, 
    666663                                        BOOL first,                             int *swaps, 
    667                                         FILE *bands,                            int color1, 
    668                                         int color2,                                     int color3, 
     664                                        int color1,                                     int color2,                                      
     665                                        int color3, 
    669666                                        BOOL global,                    BOOL end);      //      static. 
    670667                        /**     free.h 
     
    679676                        /**     newpolve.h 
    680677                        */ 
    681                         void Find_Bands(int numfaces, FILE *output_file, int *swaps, int *bands,  
     678                        void Find_Bands(int numfaces, int *swaps, int *bands,  
    682679                                        int *cost, int *tri, int norms, int *vert_norms, 
    683680                                        int texture, int *vert_texture); 
     
    698695                        void Mark_Face( PF_FACES temp2,                 int color1, 
    699696                                        int color2,                     int color3, 
    700                                         FILE *output_file,      BOOL end, 
     697                                        BOOL end, 
    701698                                        int *edge1,                                     int *edge2, 
    702699                                        int *face_id,                           int norms, 
     
    709706                                        int north,int last_north, 
    710707                                        int orientation,int last_left, 
    711                                         FILE *output_file,int color1, 
     708                                        int color1, 
    712709                                        int color2,int color3, 
    713710                                        BOOL start);    //      static. 
     
    715712                                        int north,int last_north, 
    716713                                        int orientation,int last_left, 
    717                                         FILE *output_file,int color1, 
     714                                        int color1, 
    718715                                        int color2,int color3, 
    719716                                        BOOL start, int *swaps_added, 
     
    722719                        /**     auxiliar.h 
    723720                        */ 
    724                         FILE *OpenOutputFile(char *fname); 
     721//                      FILE *OpenOutputFile(char *fname); 
    725722                        void AllocateStruct(int num_faces, 
    726723                                        int num_vert, 
    727724                                        int num_nvert, 
    728725                                        int num_texture); 
    729                         void miReadFile(char *fname, char *file_open, FILE *bands,Geometry::SubMesh *geoSubMesh); 
     726                        void miReadFile(char *fname, char *file_open, Geometry::SubMesh *geoSubMesh); 
    730727                        int stripify(   char                                            *fname, 
    731728                                                                                Geometry::Mesh  *geoMesh); 
  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshStripifier.cpp

    r1530 r1559  
    790790 
    791791///     preserve_strip_orientation_with_normal: 
    792 void CustomStripifier::preserve_strip_orientation_with_normal(FILE *output, int vertex1, int normal1, int vertex2, int normal2, int vertex3, int normal3) 
     792void CustomStripifier::preserve_strip_orientation_with_normal(int vertex1, int normal1, int vertex2, int normal2, int vertex3, int normal3) 
    793793{ 
    794794  int original_vertex[3]; 
     
    796796  find_triangle_orientation(vertex1,vertex2,vertex3, original_vertex); 
    797797   
    798   if ( ( original_vertex[0] == vertex3 && original_vertex[1] == vertex2 && original_vertex[2] == vertex1) || 
     798/*  if ( ( original_vertex[0] == vertex3 && original_vertex[1] == vertex2 && original_vertex[2] == vertex1) || 
    799799       ( original_vertex[0] == vertex2 && original_vertex[1] == vertex1 && original_vertex[2] == vertex3   ) || 
    800800       ( original_vertex[0] == vertex1 && original_vertex[1] == vertex3 && original_vertex[2] == vertex2   ))  { 
    801801        // New Triangle is in an opposite orientation.  Add vertex2 to correct it 
    802802        fprintf(output," %d//%d",vertex2,normal2); 
    803   } 
     803  }*/ 
    804804 
    805805} 
    806806 
    807807///     preserve_strip_orientation_with_texture: 
    808 void CustomStripifier::preserve_strip_orientation_with_texture(FILE *output, 
     808void CustomStripifier::preserve_strip_orientation_with_texture( 
    809809                                             int vertex1, int texture1, 
    810810                                             int vertex2, int texture2, 
     
    816816                            original_vertex); 
    817817   
    818   if ( ( original_vertex[0] == vertex3 && 
     818/*  if ( ( original_vertex[0] == vertex3 && 
    819819         original_vertex[1] == vertex2 && 
    820820         original_vertex[2] == vertex1   ) || 
     
    825825         original_vertex[1] == vertex3 && 
    826826         original_vertex[2] == vertex2   ) ) { 
    827     /* New Triangle is in an opposite orientation */ 
    828     /* Add vertex2 to correct it */ 
     827    // New Triangle is in an opposite orientation  
     828    // Add vertex2 to correct it 
    829829    fprintf(output," %d/%d",vertex2,texture2); 
    830   } 
     830  }*/ 
    831831} 
    832832 
    833833///     preserve_strip_orientation_with_texture_and_normal: 
    834 void  CustomStripifier::preserve_strip_orientation_with_texture_and_normal(FILE *output, 
     834void  CustomStripifier::preserve_strip_orientation_with_texture_and_normal( 
    835835                                                         int vertex1, int texture1, int normal1, 
    836836                                                         int vertex2, int texture2, int normal2, 
     
    842842                            original_vertex); 
    843843   
    844   if ( ( original_vertex[0] == vertex3 && 
     844 /* if ( ( original_vertex[0] == vertex3 && 
    845845         original_vertex[1] == vertex2 && 
    846846         original_vertex[2] == vertex1   ) || 
     
    851851         original_vertex[1] == vertex3 && 
    852852         original_vertex[2] == vertex2   ) ) { 
    853     /* New Triangle is in an opposite orientation */ 
    854     /* Add vertex2 to correct it */ 
     853    // New Triangle is in an opposite orientation  
     854    // Add vertex2 to correct it 
    855855    fprintf(output," %d/%d/%d",vertex2,texture2,normal2); 
    856   } 
     856  }*/ 
    857857} 
    858858 
    859859///     preserve_strip_orientation: 
    860 void CustomStripifier::preserve_strip_orientation(FILE *output,int vertex1, int vertex2,int vertex3) 
     860void CustomStripifier::preserve_strip_orientation(int vertex1, int vertex2,int vertex3) 
    861861{  
    862862  int original_vertex[3]; 
     
    874874         original_vertex[1] == vertex3 && 
    875875         original_vertex[2] == vertex2   ))  { 
    876     /* New Triangle is in an opposite orientation */ 
    877     /* Add vertex2 to correct it */ 
    878     fprintf(output," %d",vertex2); 
     876    // New Triangle is in an opposite orientation  
     877    // Add vertex2 to correct it 
     878 //   fprintf(output," %d",vertex2); 
    879879        mi_vector[num_tiras].push_back(vertex2-1); 
    880880  } 
     
    882882 
    883883///     Output_TriEx: 
    884 void CustomStripifier::Output_TriEx(int id1, int id2, int id3, FILE *output,  
    885                   int flag, int where) 
     884void CustomStripifier::Output_TriEx(int id1, int id2, int id3, int flag, int where) 
    886885{ 
    887886  /*   We will save everything into a list, rather than output at once, 
     
    911910     */ 
    912911  { 
    913                 fprintf(output,"\nt"); 
     912//              fprintf(output,"\nt"); 
    914913          mi_vector_tipo nada; 
    915914          mi_vector.push_back(nada); 
    916915          num_tiras++; 
    917     tri = tri + Finished(&swap,output,1); 
     916    tri = tri + Finished(&swap,1); 
    918917    total = total + swap; 
    919918    strips++; 
     
    931930 
    932931///     Extend_BackwardsEx: 
    933 void CustomStripifier::Extend_BackwardsEx(int face_id, FILE *output, int *ties, 
     932void CustomStripifier::Extend_BackwardsEx(int face_id, int *ties, 
    934933                        int tie, int triangulate, 
    935934                        int swaps,int *next_id) 
     
    981980                  Last_Edge(&z,&y,&x,1); 
    982981                  Polygon_OutputEx(temp,temp->face_id,bucket,pListFace, 
    983                                    output,ties,tie,triangulate, 
     982                                   ties,tie,triangulate, 
    984983                                   swaps,next_id,0); 
    985984                  return; 
     
    10111010                  Last_Edge(&z,&y,&x,1); 
    10121011                  Polygon_OutputEx(temp,temp->face_id,bucket,pListFace, 
    1013                                    output,ties,tie,triangulate, 
     1012                                   ties,tie,triangulate, 
    10141013                                   swaps,next_id,0); 
    10151014                  return; 
     
    10281027///     Polygon_OutputEx: 
    10291028void CustomStripifier::Polygon_OutputEx(P_ADJACENCIES temp,int face_id,int bucket, 
    1030                       ListHead *pListHead, FILE *output, 
     1029                      ListHead *pListHead,  
    10311030                      int *ties, int tie,  
    10321031                      int triangulate, int swaps, 
     
    10691068            } 
    10701069           
    1071           Output_TriEx(e2,e3,next_face_id,NULL,begin,where); 
     1070          Output_TriEx(e2,e3,next_face_id,begin,where); 
    10721071          if (face_array[temp->face_id].head == pListHead) 
    10731072            face_array[temp->face_id].pfNode = NULL; 
     
    10981097          if (next_face_id == -1) 
    10991098            { 
    1100               Polygon_OutputEx(temp,face_id,0,pListHead,output,ties,tie,  
     1099              Polygon_OutputEx(temp,face_id,0,pListHead,ties,tie,  
    11011100                               triangulate,swaps,next_id,where); 
    11021101              return; 
     
    11311130              else 
    11321131                { 
    1133                   Polygon_OutputEx(temp,face_id,0,pListHead,output, 
     1132                  Polygon_OutputEx(temp,face_id,0,pListHead, 
    11341133                                   ties,tie,triangulate,swaps,next_id,where); 
    11351134                  return; 
     
    11471146                { 
    11481147                  /* Degenerate triangle just return*/ 
    1149                   Output_TriEx(other1,other2,e3,NULL,begin,where); 
     1148                  Output_TriEx(other1,other2,e3,begin,where); 
    11501149                  if (face_array[temp->face_id].head == pListHead) 
    11511150                    face_array[temp->face_id].pfNode = NULL; 
     
    11711170               have the next polygon id  
    11721171          */ 
    1173           Output_TriEx(other1,other2,e3,NULL,begin,where); 
     1172          Output_TriEx(other1,other2,e3,begin,where); 
    11741173          if (face_array[temp->face_id].head == pListHead) 
    11751174            face_array[temp->face_id].pfNode = NULL; 
     
    11891188            } 
    11901189          Polygon_OutputEx(lpListInfo,next_face_id,next_bucket, 
    1191                            pListHead, output,ties,tie, 
     1190                           pListHead, ties,tie, 
    11921191                           triangulate,swaps,next_id,where); 
    11931192           
     
    12421241                { 
    12431242                  /*  There is no sequential face to go to, end the strip */ 
    1244                   Polygon_OutputEx(temp,face_id,0,pListHead,output, 
     1243                  Polygon_OutputEx(temp,face_id,0,pListHead, 
    12451244                                   ties,tie,triangulate,swaps,next_id,where); 
    12461245                  return; 
     
    12511250                next_face_id = Get_Next_Face(tie,face_id,triangulate); 
    12521251              Non_Blind_TriangulateEx(face->nPolSize,face->pPolygon, 
    1253                                       output,next_face_id,face_id,where); 
     1252                                      next_face_id,face_id,where); 
    12541253               
    12551254              if (face_array[temp->face_id].head == pListHead)           
     
    12701269                next_face_id = Get_Next_Face(tie,face_id,triangulate); 
    12711270              Partial_Triangulate(face->nPolSize,face->pPolygon, 
    1272                                   output,next_face_id,face_id,next_id, 
     1271                                  next_face_id,face_id,next_id, 
    12731272                                  pListHead,temp,where); 
    12741273              /*    Check the next bucket again ,maybe it changed  
     
    13101309            } 
    13111310          Polygon_OutputEx(lpListInfo,next_face_id,next_bucket, 
    1312                            pListHead, output,ties,tie, 
     1311                           pListHead, ties,tie, 
    13131312                           triangulate,swaps,next_id,where); 
    13141313        } 
     
    13381337          if (Done(next_face_id,&next_bucket) == NULL) 
    13391338            { 
    1340               Polygon_OutputEx(temp,face_id,0,pListHead,output,ties,tie,  
     1339              Polygon_OutputEx(temp,face_id,0,pListHead,ties,tie,  
    13411340                               triangulate,swaps,next_id,where); 
    13421341              /*    Because maybe there was more than 2 polygons on the edge */ 
     
    13491348           
    13501349          Non_Blind_TriangulateEx(face->nPolSize,face->pPolygon,  
    1351                                   output,next_face_id,face_id,where); 
     1350                                  next_face_id,face_id,where); 
    13521351           
    13531352          if (face_array[temp->face_id].head == pListHead) 
     
    13651364            } 
    13661365          Polygon_OutputEx(lpListInfo,next_face_id,next_bucket, 
    1367                            pListHead, output,ties,tie, 
     1366                           pListHead, ties,tie, 
    13681367                           triangulate,swaps,next_id,where); 
    13691368        } 
     
    16961695                                                                                                                                                                                int in_edge1,   int in_edge2, 
    16971696                                                                                                                                                                                int size,                       int *index, 
    1698                                                                                                                                                                                 FILE *output,   int reversed, 
     1697                                                                                                                                                                                int reversed, 
    16991698                                                                                                                                                                                int face_id,    int where, 
    17001699                                                                                                                                                                                int color1,             int color2, 
     
    17431742      Delete_From_List(out_edge2,index,&size); 
    17441743      Triangulate_Polygon(out_edge1,vertex4,in_edge2, 
    1745                           vertex4,size-1,index,output,reversed,face_id, 
     1744                          vertex4,size-1,index,reversed,face_id, 
    17461745                          where,color1,color2,color3); 
    17471746      memcpy(index,temp,sizeof(int)*size); 
     
    17801779      Delete_From_List(in_edge1,index,&size); 
    17811780      Triangulate_Polygon(out_edge1,out_edge2,in_edge2, 
    1782                           vertex4,size-1,index,output,!reversed,face_id, 
     1781                          vertex4,size-1,index,!reversed,face_id, 
    17831782                          where,color1,color2,color3); 
    17841783      memcpy(index,temp,sizeof(int)*size); 
     
    18061805      Delete_From_List(in_edge2,index,&size); 
    18071806      Triangulate_Polygon(out_edge1,out_edge2,in_edge1, 
    1808                           vertex4,size-1,index,output,reversed,face_id, 
     1807                          vertex4,size-1,index,reversed,face_id, 
    18091808                          where,color1,color2,color3); 
    18101809      memcpy(index,temp,sizeof(int)*size); 
     
    18211820      Delete_From_List(in_edge2,index,&size); 
    18221821      Triangulate_Polygon(out_edge1,out_edge2,in_edge1, 
    1823                           vertex4,size-1,index,output,reversed,face_id, 
     1822                          vertex4,size-1,index,reversed,face_id, 
    18241823                          where,color1,color2,color3); 
    18251824      memcpy(index,temp,sizeof(int)*size); 
     
    18351834      Delete_From_List(in_edge1,index,&size); 
    18361835      Triangulate_Polygon(out_edge1,out_edge2,vertex4, 
    1837                           in_edge2,size-1,index,output,reversed,face_id, 
     1836                          in_edge2,size-1,index,reversed,face_id, 
    18381837                          where,color1,color2,color3); 
    18391838      memcpy(index,temp,sizeof(int)*size); 
     
    18541853      Delete_From_List(in_edge1,index,&size); 
    18551854      Triangulate_Polygon(out_edge1,out_edge2,in_edge2, 
    1856                           vertex4,size-1,index,output,!reversed,face_id, 
     1855                          vertex4,size-1,index,!reversed,face_id, 
    18571856                          where,color1,color2,color3); 
    18581857      memcpy(index,temp,sizeof(int)*size); 
     
    18641863void CustomStripifier::Triangulate(int out_edge1,int out_edge2,int in_edge1, 
    18651864                        int in_edge2,int size,int *index, 
    1866                         FILE *output,int reversed,int face_id, int where, 
     1865                        int reversed,int face_id, int where, 
    18671866                        int color1, int color2,int color3) 
    18681867{ 
     
    18741873  else 
    18751874    Triangulate_Polygon(out_edge1,out_edge2,in_edge1,in_edge2,size, 
    1876                         index,output,reversed,face_id,where,color1,color2,color3); 
     1875                        index,reversed,face_id,where,color1,color2,color3); 
    18771876} 
    18781877 
    18791878///     Non_Blind_Triangulate: 
    18801879void CustomStripifier::Non_Blind_Triangulate(int size,int *index, 
    1881                            FILE *output,int next_face_id,int face_id,int where, 
    1882                            int color1,int color2,int color3) 
     1880                           int next_face_id,int face_id,int where,int color1,int color2,int color3) 
    18831881{ 
    18841882  int id1,id2,id3; 
     
    19081906     since we are at the beginning of a strip 
    19091907  */ 
    1910   Triangulate(nedge1,nedge2,id2,id3,size,index,output,reversed, 
     1908  Triangulate(nedge1,nedge2,id2,id3,size,index,reversed, 
    19111909              face_id, where,color1,color2,color3); 
    19121910} 
     
    40904088      vertex4 = AdjacentEx(out_edge1,out_edge2,index,size); 
    40914089      vertex5 = Get_Other_Vertex(vertex4,out_edge1,out_edge2,index); 
    4092       Output_TriEx(vertex5,vertex4,out_edge1,NULL,-1,where); 
    4093       Output_TriEx(vertex4,out_edge1,out_edge2,NULL,-1,where); 
     4090      Output_TriEx(vertex5,vertex4,out_edge1,-1,where); 
     4091      Output_TriEx(vertex4,out_edge1,out_edge2,-1,where); 
    40944092      return; 
    40954093    } 
     
    41084106      */ 
    41094107      vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge2,index); 
    4110       Output_TriEx(in_edge1,in_edge2,vertex4,NULL,-1,where); 
    4111       Output_TriEx(vertex4,in_edge2,out_edge2,NULL,-1,where); 
     4108      Output_TriEx(in_edge1,in_edge2,vertex4,-1,where); 
     4109      Output_TriEx(vertex4,in_edge2,out_edge2,-1,where); 
    41124110      return; 
    41134111    } 
     
    41264124      */ 
    41274125      vertex4 = Get_Other_Vertex(in_edge2,in_edge1,out_edge2,index); 
    4128       Output_TriEx(in_edge2,in_edge1,vertex4,NULL,-1,where); 
    4129       Output_TriEx(vertex4,in_edge1,out_edge2,NULL,-1,where); 
     4126      Output_TriEx(in_edge2,in_edge1,vertex4,-1,where); 
     4127      Output_TriEx(vertex4,in_edge1,out_edge2,-1,where); 
    41304128      return; 
    41314129    } 
     
    41354133    { 
    41364134      vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge1,index); 
    4137       Output_TriEx(in_edge2,in_edge1,vertex4,NULL,-1,where); 
    4138       Output_TriEx(vertex4,in_edge1,out_edge1,NULL,-1,where); 
     4135      Output_TriEx(in_edge2,in_edge1,vertex4,-1,where); 
     4136      Output_TriEx(vertex4,in_edge1,out_edge1,-1,where); 
    41394137      return; 
    41404138    } 
     
    41424140    { 
    41434141      vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge1,index); 
    4144       Output_TriEx(in_edge1,in_edge2,vertex4,NULL,-1,where); 
    4145       Output_TriEx(vertex4,in_edge2,out_edge1,NULL,-1,where); 
     4142      Output_TriEx(in_edge1,in_edge2,vertex4,-1,where); 
     4143      Output_TriEx(vertex4,in_edge2,out_edge1,-1,where); 
    41464144      return; 
    41474145    } 
     
    41594157                And also the output edge, so that we triangulate correctly. 
    41604158          */ 
    4161           Output_TriEx(in_edge1,in_edge2,out_edge2,NULL,-1,where); 
    4162           Output_TriEx(in_edge2,out_edge2,out_edge1,NULL,-1,where); 
     4159          Output_TriEx(in_edge1,in_edge2,out_edge2,-1,where); 
     4160          Output_TriEx(in_edge2,out_edge2,out_edge1,-1,where); 
    41634161        } 
    41644162      else 
     
    41674165               be reversed from above. 
    41684166          */ 
    4169           Output_TriEx(in_edge1,in_edge2,out_edge1,NULL,-1,where); 
    4170           Output_TriEx(in_edge2,out_edge1,out_edge2,NULL,-1,where); 
     4167          Output_TriEx(in_edge1,in_edge2,out_edge1,-1,where); 
     4168          Output_TriEx(in_edge2,out_edge1,out_edge2,-1,where); 
    41714169        } 
    41724170      return; 
     
    41784176                                                                                                                                                                                        int in_edge1, int in_edge2, 
    41794177                                                                                                                                                                                        int size,                       int *index, 
    4180                                                                                                                                                                                 FILE *fp,                       int reversed, 
     4178                                                                                                                                                                                int reversed, 
    41814179                                                                                                                                                                                        int face_id,  int where) 
    41824180{ 
     
    42244222      Triangulate_PolygonEx(out_edge1,vertex4,in_edge2, 
    42254223                            vertex4,size-1,index, 
    4226                             fp,reversed,face_id,where); 
     4224                            reversed,face_id,where); 
    42274225      memcpy(index,temp,sizeof(int)*size); 
    42284226      /*        Lastly do the triangle that comes out the output 
    42294227                edge. 
    42304228      */ 
    4231       Output_TriEx(vertex4,out_edge1,out_edge2,NULL,-1,where); 
     4229      Output_TriEx(vertex4,out_edge1,out_edge2,-1,where); 
    42324230      return; 
    42334231    } 
     
    42524250      */ 
    42534251      vertex4 = AdjacentEx(in_edge2,in_edge1,index,size); 
    4254       Output_TriEx(in_edge1,in_edge2,vertex4,NULL,-1,where); 
     4252      Output_TriEx(in_edge1,in_edge2,vertex4,-1,where); 
    42554253      /*        Create a new edgelist without the triangle that 
    42564254                was just outputted. 
     
    42604258      Delete_From_ListEx(in_edge1,index,size); 
    42614259      Triangulate_PolygonEx(out_edge1,out_edge2,in_edge2, 
    4262                             vertex4,size-1,index,fp, 
     4260                            vertex4,size-1,index, 
    42634261                            !reversed,face_id,where); 
    42644262      memcpy(index,temp,sizeof(int)*size); 
     
    42754273      /*        Get vertex adjacent to in_edge2, but is not in_edge1 */ 
    42764274      vertex4 = AdjacentEx(in_edge1,in_edge2,index,size); 
    4277       Output_TriEx(in_edge1,in_edge2,vertex4,fp,-1,where); 
     4275      Output_TriEx(in_edge1,in_edge2,vertex4,-1,where); 
    42784276      /*        Since that triangle goes out of the polygon (the 
    42794277                output edge of it), we can make our new input edge 
     
    42864284      Delete_From_ListEx(in_edge2,index,size); 
    42874285      Triangulate_PolygonEx(out_edge1,out_edge2,in_edge1, 
    4288                             vertex4,size-1,index,fp, 
     4286                            vertex4,size-1,index, 
    42894287                            reversed,face_id,where); 
    42904288      memcpy(index,temp,sizeof(int)*size); 
     
    42964294      /*        Get vertex adjacent to in_edge2, but is not in_edge1 */ 
    42974295      vertex4 = AdjacentEx(in_edge1,in_edge2,index,size); 
    4298       Output_TriEx(in_edge2,in_edge1,vertex4,fp,-1,where); 
     4296      Output_TriEx(in_edge2,in_edge1,vertex4,-1,where); 
    42994297      temp = (int *) malloc(sizeof(int) * size); 
    43004298      memcpy(temp,index,sizeof(int)*size); 
    43014299      Delete_From_ListEx(in_edge2,index,size); 
    43024300      Triangulate_PolygonEx(out_edge1,out_edge2,in_edge1, 
    4303                             vertex4,size-1,index,fp, 
     4301                            vertex4,size-1,index, 
    43044302                            reversed,face_id,where); 
    43054303      memcpy(index,temp,sizeof(int)*size); 
     
    43104308      /*        Get vertex adjacent to in_edge2, but is not in_edge1 */ 
    43114309      vertex4 = AdjacentEx(in_edge2,in_edge1,index,size); 
    4312       Output_TriEx(in_edge1,in_edge2,vertex4,fp,-1,where); 
     4310      Output_TriEx(in_edge1,in_edge2,vertex4,-1,where); 
    43134311      temp = (int *) malloc(sizeof(int) * size); 
    43144312      memcpy(temp,index,sizeof(int)*size); 
    43154313      Delete_From_ListEx(in_edge1,index,size); 
    43164314      Triangulate_PolygonEx(out_edge1,out_edge2,vertex4, 
    4317                             in_edge2,size-1,index,fp, 
     4315                            in_edge2,size-1,index, 
    43184316                            reversed,face_id,where); 
    43194317      memcpy(index,temp,sizeof(int)*size); 
     
    43294327    { 
    43304328      vertex4 = AdjacentEx(in_edge2,in_edge1,index,size); 
    4331       Output_TriEx(in_edge1,in_edge2,vertex4,fp,-1,where); 
     4329      Output_TriEx(in_edge1,in_edge2,vertex4,-1,where); 
    43324330      temp = (int *) malloc(sizeof(int) * size); 
    43334331      memcpy(temp,index,sizeof(int)*size); 
    43344332      Delete_From_ListEx(in_edge1,index,size); 
    43354333      Triangulate_PolygonEx(out_edge1,out_edge2,in_edge2, 
    4336                             vertex4,size-1,index,fp, 
     4334                            vertex4,size-1,index, 
    43374335                            !reversed,face_id,where); 
    43384336      memcpy(index,temp,sizeof(int)*size); 
     
    43444342void CustomStripifier::TriangulateEx(int out_edge1,int out_edge2,int in_edge1, 
    43454343                          int in_edge2,int size,int *index, 
    4346                           FILE *output,int reversed,int face_id, int where) 
     4344                          int reversed,int face_id, int where) 
    43474345{ 
    43484346  /*    We have the info we need to triangulate a polygon */ 
     
    43534351  else 
    43544352    Triangulate_PolygonEx(out_edge1,out_edge2,in_edge1,in_edge2,size, 
    4355                           index,output,reversed,face_id,where); 
     4353                          index,reversed,face_id,where); 
    43564354} 
    43574355 
    43584356///     Non_Blind_TriangulateEx: 
    43594357void CustomStripifier::Non_Blind_TriangulateEx(int size,int *index,  
    4360                              FILE *output,int next_face_id,int face_id,int where) 
     4358                             int next_face_id,int face_id,int where) 
    43614359{ 
    43624360  int id1,id2,id3; 
     
    43864384        since we are at the beginning of a strip 
    43874385  */ 
    4388   TriangulateEx(nedge1,nedge2,id2,id3,size,index,output,reversed, 
     4386  TriangulateEx(nedge1,nedge2,id2,id3,size,index,reversed, 
    43894387                face_id, where); 
    43904388} 
     
    45114509  if (( (!begin) && (*(index) == e2) ) || (begin)) 
    45124510    { 
    4513       Output_TriEx(*(index+0),*(index+1),*(index+size-1),NULL,-1,where); 
     4511      Output_TriEx(*(index+0),*(index+1),*(index+size-1),-1,where); 
    45144512      /*        If we have a quad, (chances are yes), then we know that 
    45154513                we can just add one diagonal and be done. (divide the 
     
    45184516      if (size == 4) 
    45194517        { 
    4520           Output_TriEx(*(index+1),*(index+size-1),*(index+2),NULL,-1,where); 
     4518          Output_TriEx(*(index+1),*(index+size-1),*(index+2),-1,where); 
    45214519          return; 
    45224520        } 
     
    45274525  else if (!begin) 
    45284526    { 
    4529       Output_TriEx(*(index+1),*(index+0),*(index+size-1),NULL,-1,where); 
     4527      Output_TriEx(*(index+1),*(index+0),*(index+size-1),-1,where); 
    45304528      if (size == 4) 
    45314529        { 
    4532           Output_TriEx(*(index+0),*(index+size-1),*(index+2),NULL,-1,where); 
     4530          Output_TriEx(*(index+0),*(index+size-1),*(index+2),-1,where); 
    45334531          return; 
    45344532        } 
    4535       Output_TriEx(*(index+0),*(index+size-1),*(index+2),NULL,-1,where); 
     4533      Output_TriEx(*(index+0),*(index+size-1),*(index+2),-1,where); 
    45364534      increasing = 2; 
    45374535      mode = 0; 
     
    45504548            { 
    45514549              Output_TriEx(*(index+increasing),*(index+decreasing), 
    4552                            *(index+increasing+1),NULL,-1,where); 
     4550                           *(index+increasing+1),-1,where); 
    45534551              increasing++; 
    45544552            } 
     
    45564554            { 
    45574555              Output_TriEx(*(index+decreasing),*(index+increasing), 
    4558                            *(index+decreasing-1),NULL,-1,where); 
     4556                           *(index+decreasing-1),-1,where); 
    45594557              decreasing--; 
    45604558            } 
     
    51075105 
    51085106///     Find_StripsEx: 
    5109 void CustomStripifier::Find_StripsEx(FILE *output,int *ties, 
     5107void CustomStripifier::Find_StripsEx(int *ties, 
    51105108                          int  tie, int triangulate, 
    51115109                          int  swaps,int *next_id) 
     
    51425140                                } 
    51435141 
    5144               Polygon_OutputEx(temp,temp->face_id,bucket,pListHead, output,ties,tie,triangulate,swaps,next_id,1); 
     5142              Polygon_OutputEx(temp,temp->face_id,bucket,pListHead,ties,tie,triangulate,swaps,next_id,1); 
    51455143              /*  Try to extend backwards, if the starting polygon in the 
    51465144                                                strip had 2 or more adjacencies to begin with 
    51475145              */ 
    51485146              if (bucket >= 2) 
    5149                                         Extend_BackwardsEx(temp->face_id,output,ties,tie, triangulate,swaps,next_id); 
     5147                                        Extend_BackwardsEx(temp->face_id,ties,tie, triangulate,swaps,next_id); 
    51505148 
    51515149                                break;   
     
    51625160    else 
    51635161                { 
    5164                         Output_TriEx(-1,-2,-3,output,-10,1); 
     5162                        Output_TriEx(-1,-2,-3,-10,1); 
    51655163                        Last_Edge(&dummy,&dummy,&dummy,1); 
    51665164                        cont++; 
     
    51715169 
    51725170///     SGI_Strip: 
    5173 void CustomStripifier::SGI_Strip(int    num_faces, 
    5174                                                                                                                                  FILE *output, 
    5175                                                                                                                                  int    ties, 
    5176                                                                                                                                  int    triangulate) 
     5171void CustomStripifier::SGI_Strip(int    num_faces, int  ties, int       triangulate) 
    51775172{ 
    51785173  int next_id = -1,t=0; 
     
    52035198  */ 
    52045199 
    5205   Find_StripsEx(output,&t,ties,triangulate,ON,&next_id); 
     5200  Find_StripsEx(&t,ties,triangulate,ON,&next_id); 
    52065201   
    52075202} 
     
    52415236      vertex4 = AdjacentEx(out_edge1,out_edge2,index,size); 
    52425237      vertex5 = Get_Other_Vertex(vertex4,out_edge1,out_edge2,index); 
    5243       Output_TriEx(vertex5,vertex4,out_edge1,NULL,-1,where); 
    5244       Output_TriEx(vertex4,out_edge1,out_edge2,NULL,-1,where); 
     5238      Output_TriEx(vertex5,vertex4,out_edge1,-1,where); 
     5239      Output_TriEx(vertex4,out_edge1,out_edge2,-1,where); 
    52455240      dummy = Update_AdjacenciesEx(face_id, &dummy, &dummy,&dummy,&dummy); 
    52465241       
     
    52635258      */ 
    52645259      vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge2,index); 
    5265       Output_TriEx(in_edge1,in_edge2,out_edge2,NULL,-1,where); 
     5260      Output_TriEx(in_edge1,in_edge2,out_edge2,-1,where); 
    52665261      /*        Now we have a triangle used, and a triangle that is 
    52675262                left for later. 
     
    52995294      */                                                 
    53005295      vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge2,index); 
    5301       Output_TriEx(in_edge2,in_edge1,out_edge2,NULL,-1,where); 
     5296      Output_TriEx(in_edge2,in_edge1,out_edge2,-1,where); 
    53025297      /*        Now we have a triangle used, and a triangle that is 
    53035298                left for later. 
     
    53275322    { 
    53285323      vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge1,index); 
    5329       Output_TriEx(in_edge2,in_edge1,out_edge1,NULL,-1,where); 
     5324      Output_TriEx(in_edge2,in_edge1,out_edge1,-1,where); 
    53305325      /*        Now we have a triangle used, and a triangle that is 
    53315326                left for later. 
     
    53535348    { 
    53545349      vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge1,index); 
    5355       Output_TriEx(in_edge1,in_edge2,out_edge1,NULL,-1,where); 
     5350      Output_TriEx(in_edge1,in_edge2,out_edge1,-1,where); 
    53565351      /*        Now we have a triangle used, and a triangle that is 
    53575352                left for later. 
     
    53915386                correctly. Does not need partial. 
    53925387          */ 
    5393           Output_TriEx(in_edge1,in_edge2,out_edge2,NULL,-1,where); 
    5394           Output_TriEx(in_edge2,out_edge2,out_edge1,NULL,-1,where); 
     5388          Output_TriEx(in_edge1,in_edge2,out_edge2,-1,where); 
     5389          Output_TriEx(in_edge2,out_edge2,out_edge1,-1,where); 
    53955390          dummy = Update_AdjacenciesEx(face_id, &dummy, &dummy,&dummy,&dummy); 
    53965391           
     
    54045399                  be reversed from above. 
    54055400          */ 
    5406           Output_TriEx(in_edge1,in_edge2,out_edge1,NULL,-1,where); 
    5407           Output_TriEx(in_edge2,out_edge1,out_edge2,NULL,-1,where); 
     5401          Output_TriEx(in_edge1,in_edge2,out_edge1,-1,where); 
     5402          Output_TriEx(in_edge2,out_edge1,out_edge2,-1,where); 
    54085403          dummy = Update_AdjacenciesEx(face_id, &dummy, &dummy,&dummy,&dummy); 
    54095404           
     
    54205415                                                                                                                                                                                        int in_edge1, int in_edge2, 
    54215416                                                                                                                                                                                        int size,               int *index, 
    5422                                                                                                                                                                                         FILE *fp,                 int reversed, 
     5417                                                                                                                                                                                        int reversed, 
    54235418                                                                                                                                                                                        int face_id,    int *next_id, 
    54245419                                                                                                                                                                                ListHead *pListHead, 
     
    54635458      */ 
    54645459      Triangulate_PolygonEx(vertex4,out_edge1,in_edge2, 
    5465                             vertex4,size-1,index,fp, 
     5460                            vertex4,size-1,index, 
    54665461                            reversed,face_id, 
    54675462                            where);  
     
    54705465                edge. 
    54715466      */ 
    5472       Output_TriEx(vertex4,out_edge1,out_edge2,NULL,-1,where); 
     5467      Output_TriEx(vertex4,out_edge1,out_edge2,-1,where); 
    54735468      /*        We were able to do the whole polygon, now we 
    54745469                can delete the whole thing from our data structure. 
     
    54905485  if (in_edge2 == out_edge1)  
    54915486    { 
    5492       Output_TriEx(in_edge1,out_edge1,out_edge2,NULL,-1,where); 
     5487      Output_TriEx(in_edge1,out_edge1,out_edge2,-1,where); 
    54935488       
    54945489      /*        Now delete the adjacencies by one for all the faces 
     
    55255520    { 
    55265521      /*        Get vertex adjacent to in_edge2, but is not in_edge1 */ 
    5527       Output_TriEx(in_edge2,in_edge1,out_edge2,NULL,-1,where); 
     5522      Output_TriEx(in_edge2,in_edge1,out_edge2,-1,where); 
    55285523       
    55295524      /*        Now delete the adjacencies by one for all the faces 
     
    55555550  else if (in_edge1 == out_edge2) 
    55565551    { 
    5557       Output_TriEx(in_edge2,in_edge1,out_edge1,NULL,-1,where); 
     5552      Output_TriEx(in_edge2,in_edge1,out_edge1,-1,where); 
    55585553       
    55595554      /*        Now delete the adjacencies by one for all the faces 
     
    55835578  else if (in_edge2 == out_edge2) 
    55845579    { 
    5585       Output_TriEx(in_edge1,in_edge2,out_edge1,NULL,-1,where); 
     5580      Output_TriEx(in_edge1,in_edge2,out_edge1,-1,where); 
    55865581       
    55875582      /*        Now delete the adjacencies by one for all the faces 
     
    56205615        { 
    56215616          vertex4 = AdjacentEx(in_edge2,in_edge1,index,size); 
    5622           Output_TriEx(in_edge1,in_edge2,vertex4,NULL,-1,where); 
     5617          Output_TriEx(in_edge1,in_edge2,vertex4,-1,where); 
    56235618           
    56245619          /*    Now delete the adjacencies by one for all the faces 
     
    56605655           
    56615656          P_Triangulate_Polygon(out_edge1,out_edge2,in_edge2, 
    5662                                 vertex4,size-1,index,fp,!reversed, 
     5657                                vertex4,size-1,index,!reversed, 
    56635658                                face_id,next_id,pListHead,temp2,where); 
    56645659        } 
     
    56665661        { 
    56675662          vertex4 = AdjacentEx(in_edge1,in_edge2,index,size); 
    5668           Output_TriEx(in_edge2,in_edge1,vertex4,NULL,-1,where); 
     5663          Output_TriEx(in_edge2,in_edge1,vertex4,-1,where); 
    56695664           
    56705665          /*    Now delete the adjacencies by one for all the faces 
     
    57075702           
    57085703          P_Triangulate_Polygon(out_edge1,out_edge2,vertex4, 
    5709                                 in_edge1,size-1,index,fp,!reversed, 
     5704                                in_edge1,size-1,index,!reversed, 
    57105705                                face_id,next_id,pListHead,temp2,where); 
    57115706        } 
     
    57175712void CustomStripifier::P_Triangulate(   int out_edge1,int out_edge2,int in_edge1, 
    57185713                                                                                                                                                int in_edge2,   int size,                       int *index, 
    5719                                                                                                                                                 FILE *output,   int reversed,   int face_id, 
     5714                                                                                                                                                int reversed,   int face_id, 
    57205715                                                                                                                                                int *next_id,   ListHead *pListHead,  
    57215716                                                                                                                                                P_ADJACENCIES temp,int where) 
     
    57285723  else 
    57295724    P_Triangulate_Polygon(out_edge1,out_edge2,in_edge1,in_edge2,size, 
    5730                           index,output,reversed,face_id,next_id, 
     5725                          index,reversed,face_id,next_id, 
    57315726                          pListHead,temp,where); 
    57325727} 
    57335728 
    57345729void CustomStripifier::Partial_Triangulate(int size,int *index,  
    5735                          FILE *output,int next_face_id,int face_id, 
     5730                         int next_face_id,int face_id, 
    57365731                         int *next_id,ListHead *pListHead, 
    57375732                         P_ADJACENCIES temp, int where) 
     
    57685763   
    57695764  /*    Do the triangulation */  
    5770   P_Triangulate(nedge1,nedge2,id2,id3,size,index,output,reversed, 
     5765  P_Triangulate(nedge1,nedge2,id2,id3,size,index,reversed, 
    57715766                face_id,next_id,pListHead,temp,where); 
    57725767} 
     
    57895784  if (vertex4 == output1) 
    57905785    { 
    5791       Output_TriEx(in_edge2,in_edge1,output1,NULL,-1,where); 
     5786      Output_TriEx(in_edge2,in_edge1,output1,-1,where); 
    57925787      /*        Now delete the adjacencies by one for all the faces 
    57935788                that are adjacent to the triangle that we just outputted. 
     
    58095804  else if (vertex5 == output1) 
    58105805    { 
    5811       Output_TriEx(in_edge1,in_edge2,vertex5,NULL,-1,where); 
     5806      Output_TriEx(in_edge1,in_edge2,vertex5,-1,where); 
    58125807      /*        Now delete the adjacencies by one for all the faces 
    58135808                that are adjacent to the triangle that we just outputted. 
     
    58685863 
    58695864///     Finished: 
    5870 int CustomStripifier::Finished(int *swap, FILE *output, int startnewstrip) 
     5865int CustomStripifier::Finished(int *swap, int startnewstrip) 
    58715866{ 
    58725867  /*   We have finished all the triangles, now is time to output to 
     
    59075902    if ((norm) && (!cptexture)) { 
    59085903                if (startnewstrip && orient) // If we want to keep orientation 
    5909                         preserve_strip_orientation_with_normal(output, temp3->face_id+1,vn[temp3->face_id]+1, 
     5904                        preserve_strip_orientation_with_normal(temp3->face_id+1,vn[temp3->face_id]+1, 
    59105905                                                temp2->face_id+1,vn[temp2->face_id]+1, temp1->face_id+1,vn[temp1->face_id]+1); 
    59115906                 
    5912                 fprintf(output," %d//%d %d//%d %d//%d", temp3->face_id+1,vn[temp3->face_id]+1, 
    5913                                         temp2->face_id+1,vn[temp2->face_id]+1, temp1->face_id+1,vn[temp1->face_id]+1); 
     5907/*              fprintf(output," %d//%d %d//%d %d//%d", temp3->face_id+1,vn[temp3->face_id]+1, 
     5908                                        temp2->face_id+1,vn[temp2->face_id]+1, temp1->face_id+1,vn[temp1->face_id]+1);*/ 
    59145909        } 
    59155910        else if ((cptexture) && (!norm)) { 
    59165911                if (startnewstrip && orient) /* If we want to keep orientation */ 
    5917                         preserve_strip_orientation_with_texture(output, temp3->face_id+1,vt[temp3->face_id]+1, 
     5912                        preserve_strip_orientation_with_texture(temp3->face_id+1,vt[temp3->face_id]+1, 
    59185913                                temp2->face_id+1,vt[temp2->face_id]+1,  temp1->face_id+1,vt[temp1->face_id]+1); 
    59195914                 
    5920                 fprintf(output," %d/%d %d/%d %d/%d", temp3->face_id+1,vt[temp3->face_id]+1, 
    5921                                         temp2->face_id+1,vt[temp2->face_id]+1, temp1->face_id+1,vt[temp1->face_id]+1); 
     5915/*              fprintf(output," %d/%d %d/%d %d/%d", temp3->face_id+1,vt[temp3->face_id]+1, 
     5916                                        temp2->face_id+1,vt[temp2->face_id]+1, temp1->face_id+1,vt[temp1->face_id]+1);*/ 
    59225917        } 
    59235918    else if ((cptexture)&& (norm)) { 
    59245919        if (startnewstrip && orient) /* If we want to keep orientation */ 
    5925           preserve_strip_orientation_with_texture_and_normal(output, temp3->face_id+1,vt[temp3->face_id]+1,vn[temp3->face_id]+1, 
     5920          preserve_strip_orientation_with_texture_and_normal(temp3->face_id+1,vt[temp3->face_id]+1,vn[temp3->face_id]+1, 
    59265921                                temp2->face_id+1,vt[temp2->face_id]+1,vn[temp2->face_id]+1, temp1->face_id+1,vt[temp1->face_id]+1,vn[temp1->face_id]+1); 
    59275922         
    5928         fprintf(output," %d/%d/%d %d/%d/%d %d/%d/%d", temp3->face_id+1,vt[temp3->face_id]+1,vn[temp3->face_id]+1, 
    5929                 temp2->face_id+1,vt[temp2->face_id]+1,vn[temp2->face_id]+1, temp1->face_id+1,vt[temp1->face_id]+1,vn[temp1->face_id]+1); 
     5923 /*       fprintf(output," %d/%d/%d %d/%d/%d %d/%d/%d", temp3->face_id+1,vt[temp3->face_id]+1,vn[temp3->face_id]+1, 
     5924                temp2->face_id+1,vt[temp2->face_id]+1,vn[temp2->face_id]+1, temp1->face_id+1,vt[temp1->face_id]+1,vn[temp1->face_id]+1);*/ 
    59305925    } 
    59315926    else  
    59325927    { 
    59335928                if (startnewstrip && orient) /* If we want to keep orientation */ 
    5934                         preserve_strip_orientation(output, temp3->face_id+1,temp2->face_id+1,temp1->face_id+1); 
    5935            
    5936                 fprintf(output," %d %d %d", temp3->face_id+1,temp2->face_id+1,temp1->face_id+1); 
     5929                        preserve_strip_orientation(temp3->face_id+1,temp2->face_id+1,temp1->face_id+1); 
     5930           
     5931//              fprintf(output," %d %d %d", temp3->face_id+1,temp2->face_id+1,temp1->face_id+1); 
    59375932                mi_vector[num_tiras].push_back(temp3->face_id); 
    59385933                mi_vector[num_tiras].push_back(temp2->face_id); 
     
    60035998        */ 
    60045999        if (orient && startnewstrip) // If we want to keep orientation 
    6005                 preserve_strip_orientation(output,vertex1+1,other1+1,other2+1); 
     6000                preserve_strip_orientation(vertex1+1,other1+1,other2+1); 
    60066001     
    6007     fprintf(output," %d %d %d",vertex1+1,other1+1,other2+1); 
     6002//    fprintf(output," %d %d %d",vertex1+1,other1+1,other2+1); 
    60086003        mi_vector[num_tiras].push_back(vertex1); 
    60096004        mi_vector[num_tiras].push_back(other1); 
     
    60246019    { 
    60256020                // If we used partial we might have a break in the middle of a strip 
    6026                 fprintf(output,"\nt"); 
     6021//              fprintf(output,"\nt"); 
    60276022        startnewstrip = 1; 
    60286023                mi_vector_tipo nada; 
     
    60546049        if ((!norm) && (!cptexture)) 
    60556050                { 
    6056             fprintf(output," %d",id[index]+1); 
     6051//            fprintf(output," %d",id[index]+1); 
    60576052                        mi_vector[num_tiras].push_back(id[index]); 
    60586053                } 
    6059         else if ((norm) && (!cptexture)) 
     6054  /*      else if ((norm) && (!cptexture)) 
    60606055            fprintf(output," %d//%d",id[index]+1,vn[id[index]]+1); 
    60616056        else if ((!norm) && (cptexture)) 
    60626057            fprintf(output," %d/%d",id[index]+1,vt[id[index]]+1); 
    60636058        else 
    6064             fprintf(output," %d/%d/%d", id[index]+1,vt[id[index]]+1,vn[id[index]]+1); 
     6059            fprintf(output," %d/%d/%d", id[index]+1,vt[id[index]]+1,vn[id[index]]+1);*/ 
    60656060 
    60666061        index = !index; 
     
    60726067    if ((!norm) && (!cptexture)) 
    60736068        { 
    6074         fprintf(output,"\nq %d",vertex2+1); 
     6069//        fprintf(output,"\nq %d",vertex2+1); 
    60756070                mi_vector[num_tiras].push_back(vertex2); 
    60766071        } 
    6077     else if ((norm) && (!cptexture)) 
     6072 /*   else if ((norm) && (!cptexture)) 
    60786073        fprintf(output,"\nq %d//%d",vertex2+1,vn[vertex2]+1); 
    60796074    else if ((!norm) && (cptexture)) 
     
    60816076    else 
    60826077        fprintf(output,"\nq %d/%d/%d",vertex2+1,vt[vertex2]+1,vn[vertex2]+1); 
    6083        
     6078  */     
    60846079    id[index] = vertex2; index = !index; 
    60856080       
     
    60936088  if ((text) && (vt[vertex2]==0)) 
    60946089  { 
    6095         if (cptexture) 
    6096                 fprintf(output,"\nq"); 
     6090/*      if (cptexture) 
     6091                fprintf(output,"\nq");*/ 
    60976092    cptexture = FALSE; 
    60986093  } 
     
    61006095  if ((!norm) && (!cptexture)) 
    61016096  { 
    6102     fprintf(output," %d",vertex2+1); 
     6097//    fprintf(output," %d",vertex2+1); 
    61036098        mi_vector[num_tiras].push_back(vertex2); 
    61046099  } 
    6105   else if ((norm) && (!cptexture)) 
     6100/*  else if ((norm) && (!cptexture)) 
    61066101    fprintf(output," %d//%d",vertex2+1,vn[vertex2]+1); 
    61076102  else if ((!norm) && (cptexture)) 
     
    61096104  else 
    61106105    fprintf(output," %d/%d/%d",vertex2+1,vt[vertex2]+1,vn[vertex2]+1); 
    6111    
     6106  */ 
    61126107  Free_Strips(); 
    61136108  return (num/3);        
     
    61456140                                                                                                                                                        int bucket,                             ListHead *pListHead, 
    61466141                                                                                                                                                        BOOL first,                             int *swaps, 
    6147                                                                                                                                                 FILE *bands,                            int color1, 
     6142                                                                                                                                                int color1, 
    61486143                                                                                                                                                        int color2,                                     int color3, 
    61496144                                                                                                                                                        BOOL global,                    BOOL end) 
     
    61846179        return 0; 
    61856180      else 
    6186         return (Finished(swaps,bands,0)); 
     6181        return (Finished(swaps,0)); 
    61876182    } 
    61886183   
     
    62126207            face_array[temp->face_id].pfNode = NULL; 
    62136208          RemoveList(pListHead,(PLISTINFO) temp); 
    6214           return (Finished(swaps,bands,0)); 
     6209          return (Finished(swaps,0)); 
    62156210        } 
    62166211       
     
    62406235                face_array[temp->face_id].pfNode = NULL; 
    62416236              RemoveList(pListHead,(PLISTINFO) temp); 
    6242               return (Finished(swaps,bands,0)); 
     6237              return (Finished(swaps,0)); 
    62436238            } 
    62446239           
     
    62906285                  face_array[temp->face_id].pfNode = NULL; 
    62916286                  RemoveList(pListHead,(PLISTINFO) temp); 
    6292                   return (Finished(swaps,bands,0)); 
     6287                  return (Finished(swaps,0)); 
    62936288                } 
    62946289               
     
    63116306              find an adj polygon */ 
    63126307          if (next_face_id == -1) 
    6313             return (Finished(swaps,bands,0)); 
     6308            return (Finished(swaps,0)); 
    63146309           
    63156310          if (Done(next_face_id,&next_bucket) == NULL) 
     
    63286323            } 
    63296324          return (Polygon_Output(lpListInfo,next_face_id,next_bucket, 
    6330                                  pListHead, FALSE, swaps,bands, 
     6325                                 pListHead, FALSE, swaps, 
    63316326                                 color1,color2,color3,global,end)); 
    63326327           
     
    63576352          /*      We will be at the beginning of the next strip. */ 
    63586353          face->nPolSize = 1; 
    6359           return (Finished(swaps,bands,0)); 
     6354          return (Finished(swaps,0)); 
    63606355        } 
    63616356       
     
    64056400              /*      We will be at the beginning of the next strip. */ 
    64066401              face->nPolSize = 1; 
    6407               return (Finished(swaps,bands,0)); 
     6402              return (Finished(swaps,0)); 
    64086403            } 
    64096404           
     
    64156410           
    64166411          Non_Blind_Triangulate(face->nPolSize,face->pPolygon,  
    6417                                 bands,next_face_id,face_id,1, 
     6412                                next_face_id,face_id,1, 
    64186413                                color1,color2,color3); 
    64196414           
     
    64326427            } 
    64336428          return (Polygon_Output(lpListInfo,next_face_id,next_bucket, 
    6434                                  pListHead, FALSE, swaps,bands, 
     6429                                 pListHead, FALSE, swaps, 
    64356430                                 color1,color2,color3,global,end)); 
    64366431        } 
     
    64446439                                                                                                                                        int             e2, 
    64456440                                                                                                                                        int             *swaps, 
    6446                                                                                                                                         FILE    *bands, 
    64476441                                                                                                                                        int             color1, 
    64486442                                                                                                                                        int             color2, 
     
    64856479  /*  Find a strip extending from the patch and return the cost */ 
    64866480  return (Polygon_Output(lpListInfo,face_id,next_bucket,pListHead,TRUE,swaps, 
    6487                          bands,color1,color2,color3,TRUE,TRUE)); 
     6481                         color1,color2,color3,TRUE,TRUE)); 
    64886482} 
    64896483 
     
    70277021void CustomStripifier::Mark_Face(       PF_FACES temp2,                 int color1, 
    70287022                                                                                                                                        int color2,                     int color3, 
    7029                                                                                                                                         FILE *output_file,      BOOL end, 
     7023                                                                                                                                        BOOL end, 
    70307024                                                                                                                                        int *edge1,                                     int *edge2, 
    70317025                                                                                                                int *face_id,                           int norms, 
     
    71207114          if ((!norms) && (!cptexture)) 
    71217115            { 
    7122               fprintf(output_file,"\nt"); 
     7116//            fprintf(output_file,"\nt"); 
    71237117              if (orient) /* If we want to preserve normal orientation */ 
    7124                 preserve_strip_orientation(output_file,x+1,y+1,saved[1]+1); 
     7118                preserve_strip_orientation(x+1,y+1,saved[1]+1); 
    71257119               
    7126               fprintf(output_file," %d %d %d",x+1,y+1,saved[1]+1); 
    7127               fprintf(output_file," %d",saved[0]+1); 
     7120//            fprintf(output_file," %d %d %d",x+1,y+1,saved[1]+1); 
     7121//            fprintf(output_file," %d",saved[0]+1); 
    71287122            } 
    71297123          else if ((norms) && (!cptexture)) 
    71307124            { 
    7131               fprintf(output_file,"\nt"); 
     7125//            fprintf(output_file,"\nt"); 
    71327126              if (orient) /* If we want to preserve normal orientation */ 
    7133                 preserve_strip_orientation_with_normal(output_file, 
     7127                preserve_strip_orientation_with_normal( 
    71347128                                                       x+1,vn[x] +1, 
    71357129                                                       y+1,vn[y] +1, 
    71367130                                                       saved[1]+1,vn[saved[1]]+1); 
    71377131               
    7138               fprintf(output_file," %d//%d %d//%d %d//%d", 
     7132/*            fprintf(output_file," %d//%d %d//%d %d//%d", 
    71397133                      x+1,vn[x] +1, 
    71407134                      y+1,vn[y] +1, 
    71417135                      saved[1]+1,vn[saved[1]]+1); 
    7142               fprintf(output_file," %d//%d",saved[0]+1,vn[saved[0]]+1); 
     7136              fprintf(output_file," %d//%d",saved[0]+1,vn[saved[0]]+1);*/ 
    71437137            } 
    71447138          else if ((cptexture) && (!norms)) 
    71457139            { 
    7146               fprintf(output_file,"\nt"); 
    7147               if (orient) /* If we want to preserve normal orientation */ 
    7148                 preserve_strip_orientation_with_texture(output_file, 
     7140//            fprintf(output_file,"\nt"); 
     7141              if (orient)  
     7142                preserve_strip_orientation_with_texture( 
    71497143                                                        x+1,vt[x] +1, 
    71507144                                                        y+1,vt[y] +1, 
    71517145                                                        saved[1]+1,vt[saved[1]]+1); 
    71527146               
    7153               fprintf(output_file," %d/%d %d/%d %d/%d", 
     7147/*            fprintf(output_file," %d/%d %d/%d %d/%d", 
    71547148                      x+1,vt[x] +1, 
    71557149                      y+1,vt[y] +1, 
    71567150                      saved[1]+1,vt[saved[1]]+1); 
    71577151               
    7158               fprintf(output_file," %d//%d",saved[0]+1,vt[saved[0]]+1); 
     7152              fprintf(output_file," %d//%d",saved[0]+1,vt[saved[0]]+1);*/ 
    71597153            } 
    71607154          else 
    71617155            { 
    7162               fprintf(output_file,"\nt"); 
    7163               if (orient) /* If we want to preserve normal orientation */ 
    7164                 preserve_strip_orientation_with_texture_and_normal(output_file, 
     7156//            fprintf(output_file,"\nt"); 
     7157              if (orient)  
     7158                preserve_strip_orientation_with_texture_and_normal( 
    71657159                                                                   x+1,vt[x]+1,vn[x] +1, 
    71667160                                                                   y+1,vt[y]+1,vn[y] +1, 
    71677161                                                                   saved[1]+1,vt[saved[1]]+1,vn[saved[1]]+1); 
    71687162               
    7169               fprintf(output_file," %d/%d/%d %d/%d/%d %d/%d/%d", 
     7163/*            fprintf(output_file," %d/%d/%d %d/%d/%d %d/%d/%d", 
    71707164                      x+1,vt[x]+1,vn[x] +1, 
    71717165                      y+1,vt[y]+1,vn[y] +1, 
     
    71737167               
    71747168              fprintf(output_file," %d/%d/%d", 
    7175                       saved[0]+1,vt[saved[0]]+1,vn[saved[0]]+1); 
     7169                      saved[0]+1,vt[saved[0]]+1,vn[saved[0]]+1);*/ 
    71767170            } 
    71777171           
     
    71847178          if ((texture) && ( (vt[x] == 0) || (vt[y]==0))) 
    71857179            { 
    7186               if (cptexture) 
    7187                 fprintf(output_file,"\nq"); 
     7180/*            if (cptexture) 
     7181                fprintf(output_file,"\nq");*/ 
    71887182              cptexture = FALSE; 
    71897183            } 
    71907184          if ((!norms) && (!cptexture)) 
    71917185            { 
    7192               fprintf(output_file," %d",x+1); 
    7193               fprintf(output_file," %d",y+1); 
     7186//            fprintf(output_file," %d",x+1); 
     7187//            fprintf(output_file," %d",y+1); 
    71947188            } 
    71957189          else if ((norms) && (!cptexture)) 
    71967190            { 
    7197               fprintf(output_file," %d//%d",x+1,vn[x]+1); 
    7198               fprintf(output_file," %d//%d",y+1,vn[y]+1); 
     7191//            fprintf(output_file," %d//%d",x+1,vn[x]+1); 
     7192//            fprintf(output_file," %d//%d",y+1,vn[y]+1); 
    71997193            } 
    72007194          else if ((cptexture) && (!norms)) 
    72017195            { 
    7202               fprintf(output_file," %d/%d",x+1,vt[x]+1); 
    7203               fprintf(output_file," %d/%d",y+1,vt[y]+1); 
     7196//            fprintf(output_file," %d/%d",x+1,vt[x]+1); 
     7197//            fprintf(output_file," %d/%d",y+1,vt[y]+1); 
    72047198            } 
    72057199          else 
    72067200            { 
    7207               fprintf(output_file," %d/%d/%d",x+1,vt[x]+1,vn[x]+1); 
    7208               fprintf(output_file," %d/%d/%d",y+1,vt[y]+1,vn[y]+1); 
     7201//            fprintf(output_file," %d/%d/%d",x+1,vt[x]+1,vn[x]+1); 
     7202//            fprintf(output_file," %d/%d/%d",y+1,vt[y]+1,vn[y]+1); 
    72097203            } 
    72107204           
     
    72247218          if ((!norms) && (!texture)) 
    72257219            { 
    7226               fprintf(output_file,"\nq %d",x+1); 
    7227               fprintf(output_file," %d",y+1); 
     7220//            fprintf(output_file,"\nq %d",x+1); 
     7221//            fprintf(output_file," %d",y+1); 
    72287222            } 
    72297223          else if ((norms) && (!texture)) 
    72307224            { 
    7231               fprintf(output_file,"\nq %d//%d",x+1,vn[x]+1); 
    7232               fprintf(output_file," %d//%d" ,y+1,vn[y]+1); 
     7225//            fprintf(output_file,"\nq %d//%d",x+1,vn[x]+1); 
     7226//            fprintf(output_file," %d//%d" ,y+1,vn[y]+1); 
    72337227            } 
    72347228          else if ((texture) && (!norms)) 
    72357229            { 
    7236               fprintf(output_file,"\nq %d/%d",x+1,vt[x]+1); 
    7237               fprintf(output_file," %d/%d",y+1,vt[y]+1); 
     7230//            fprintf(output_file,"\nq %d/%d",x+1,vt[x]+1); 
     7231//            fprintf(output_file," %d/%d",y+1,vt[y]+1); 
    72387232            } 
    72397233          else 
    72407234            { 
    7241               fprintf(output_file,"\nq %d/%d/%d",x+1,vt[x]+1,vn[x]+1); 
    7242               fprintf(output_file," %d/%d/%d",y+1,vt[y]+1,vn[y]+1); 
     7235//            fprintf(output_file,"\nq %d/%d/%d",x+1,vt[x]+1,vn[x]+1); 
     7236//            fprintf(output_file," %d/%d/%d",y+1,vt[y]+1,vn[y]+1); 
    72437237            } 
    72447238           
     
    75437537                                                                                                                                        int north,int last_north, 
    75447538                                                                                                                int orientation,int last_left, 
    7545                                                                                                                                         FILE *output_file,int color1, 
     7539                                                                                                                                        int color1, 
    75467540                                                                                                                                        int color2,int color3, 
    75477541                                                                                                                BOOL start) 
     
    75937587      if (start) 
    75947588        Reset_Max(temp2,face_id,orientation,last_left,north,last_north, 
    7595                   output_file,color1,color2,color3,FALSE);               
     7589                  color1,color2,color3,FALSE);           
    75967590       
    75977591      face_id = nextvert; 
     
    76797673    } 
    76807674  if (start) 
    7681     Reset_Max(temp2,face_id,orientation,last_left,north,last_north,output_file, 
     7675    Reset_Max(temp2,face_id,orientation,last_left,north,last_north, 
    76827676              color1,color2,color3,FALSE); 
    76837677  else if (nextvert != -1)        
     
    76907684                                                                                                                                int north,int last_north, 
    76917685                                                                                                                                int orientation,int last_left, 
    7692                                                                                                                                 FILE *output_file,int color1, 
     7686                                                                                                                                int color1, 
    76937687                                                                                                                                int color2,int color3, 
    76947688                                                                                                                BOOL start, int *swaps_added, 
     
    77447738      if (start) 
    77457739        tris += Peel_Max(temp2,face_id,orientation,last_left,north,last_north, 
    7746                          output_file,color1,color2,color3,FALSE,swaps_added, 
     7740                         color1,color2,color3,FALSE,swaps_added, 
    77477741                         norms,texture);                     
    77487742      else 
    7749         Mark_Face(temp2,color1,color2,color3,output_file,FALSE, 
     7743        Mark_Face(temp2,color1,color2,color3,FALSE, 
    77507744                  &dummy,&dummy,&face_id,norms,texture); 
    77517745       
     
    78287822  if (start) 
    78297823    tris += Peel_Max(temp2,face_id,orientation,last_left,north,last_north, 
    7830                      output_file,color1,color2,color3,FALSE,swaps_added, 
     7824                     color1,color2,color3,FALSE,swaps_added, 
    78317825                     norms,texture);     
    78327826  else 
    7833     Mark_Face(temp2,color1,color2,color3,output_file,FALSE, 
     7827    Mark_Face(temp2,color1,color2,color3,FALSE, 
    78347828              &dummy,&dummy,&face_id,norms,texture);/* do the last face */ 
    78357829   
     
    78377831   
    78387832  /*    Get the edge that we came out on the last strip of the patch */ 
    7839   Mark_Face(NULL,0,0,0,output_file,TRUE,&end1,&end2,&last_id,norms,texture); 
    7840   tris += Extend_Face(last_id,end1,end2,&s,output_file,color1,color2,color3, 
     7833  Mark_Face(NULL,0,0,0,TRUE,&end1,&end2,&last_id,norms,texture); 
     7834  tris += Extend_Face(last_id,end1,end2,&s,color1,color2,color3, 
    78417835                      vn,norms,vt,texture); 
    78427836  *swaps_added = *swaps_added + s; 
     
    78457839 
    78467840///     Find_Bands: 
    7847 void CustomStripifier::Find_Bands(int numfaces, FILE *output_file, 
    7848                                                                                                                                         int *swaps,             int *bands, 
     7841void CustomStripifier::Find_Bands(int numfaces,         int *swaps,             int *bands, 
    78497842                                                                                        int *cost,              int *tri, 
    78507843                                                                                                                                        int norms,              int *vert_norms, 
     
    79607953            { 
    79617954              total_tri += Peel_Max(temp,face_id,0,last_north,3,last_left, 
    7962                                     output_file,color1,color2,color3,TRUE, 
     7955                                    color1,color2,color3,TRUE, 
    79637956                                    &s,norms,texture); 
    79647957              Reset_Max(temp,face_id,0,last_north,3,last_left, 
    7965                         output_file,color1,color2,color3,TRUE); 
     7958                        color1,color2,color3,TRUE); 
    79667959              total_swaps += s; 
    79677960            } 
     
    79707963              reversed = TRUE; 
    79717964              total_tri += Peel_Max(temp,face_id,3,last_left,0,last_north, 
    7972                                     output_file,color1,color2,color3,TRUE, 
     7965                                    color1,color2,color3,TRUE, 
    79737966                                    &s,norms,texture); 
    7974               Reset_Max(temp,face_id,3,last_left,0,last_north,output_file, 
     7967              Reset_Max(temp,face_id,3,last_left,0,last_north, 
    79757968                        color1,color2,color3,TRUE); 
    79767969              reversed = FALSE; 
     
    79807973           
    79817974          /*    Get the edge that we came out on the last strip of the patch */ 
    7982           Mark_Face(NULL,0,0,0,NULL,TRUE,&end1,&end2,&last_id,norms,texture); 
    7983           total_tri += Extend_Face(last_id,end1,end2,&s,output_file, 
     7975          Mark_Face(NULL,0,0,0,TRUE,&end1,&end2,&last_id,norms,texture); 
     7976          total_tri += Extend_Face(last_id,end1,end2,&s, 
    79847977                                   color1,color2,color3,vn,norms,vt,texture); 
    7985           total_swaps += s; 
    7986            
     7978          total_swaps += s;        
    79877979        } 
    79887980      else 
     
    79917983            { 
    79927984              total_tri += Peel_Max(temp,face_id,2,last_north,1,last_left, 
    7993                                     output_file,color1,color2,color3,TRUE, 
     7985                                    color1,color2,color3,TRUE, 
    79947986                                    &s,norms,texture);  
    7995               Reset_Max(temp,face_id,2,last_north,1,last_left,output_file, 
     7987              Reset_Max(temp,face_id,2,last_north,1,last_left, 
    79967988                        color1,color2,color3,TRUE);  
    79977989              total_swaps += s; 
     
    80017993              reversed = TRUE; 
    80027994              total_tri += Peel_Max(temp,face_id,1,last_left,2,last_north, 
    8003                                     output_file,color1,color2,color3,TRUE, 
     7995                                    color1,color2,color3,TRUE, 
    80047996                                    &s,norms,texture); 
    8005               Reset_Max(temp,face_id,1,last_left,2,last_north,output_file, 
     7997              Reset_Max(temp,face_id,1,last_left,2,last_north, 
    80067998                        color1,color2,color3,TRUE); 
    80077999              reversed = FALSE; 
     
    80108002           
    80118003          /*    Get the edge that we came out on on the patch */ 
    8012           Mark_Face(NULL,0,0,0,NULL,TRUE,&end1,&end2,&last_id,norms,texture); 
    8013           total_tri += Extend_Face(last_id,end1,end2,&s,output_file, 
     8004          Mark_Face(NULL,0,0,0,TRUE,&end1,&end2,&last_id,norms,texture); 
     8005          total_tri += Extend_Face(last_id,end1,end2,&s, 
    80148006                                   color1,color2,color3,vn,norms,vt,texture); 
    80158007          total_swaps += s; 
     
    81158107} 
    81168108 
    8117 ///     OpenOutputFile: 
     8109/*///   OpenOutputFile: 
    81188110FILE *  CustomStripifier::OpenOutputFile(char *fname) 
    81198111{ 
     
    81428134   
    81438135  return        bands; 
    8144 } 
     8136}*/ 
    81458137 
    81468138///     AllocateStruct: Reserves memory for structures. 
     
    81888180 
    81898181///     miReadFile: Loads the object in memory. 
    8190 void CustomStripifier::miReadFile(char *fname, char *file_open, FILE *bands, Geometry::SubMesh *geoSubMesh) 
     8182void CustomStripifier::miReadFile(char *fname, char *file_open, Geometry::SubMesh *geoSubMesh) 
    81918183{ 
    81928184  int           face_id =       0; 
     
    82448236  BOOL                                                          quads = FALSE; 
    82458237        BOOL                                                            oddStrip; 
    8246         FILE                                                            *bands; 
     8238//      FILE                                                            *bands; 
    82478239        char                                                            *file_open; 
    82488240        int                                                                     i; 
     
    83168308 
    83178309                        // Open the output file. 
    8318                         bands   =       OpenOutputFile(fname); 
     8310//                      bands   =       OpenOutputFile(fname); 
    83198311 
    83208312                        //      2006-02-14. 
     
    83388330 
    83398331                        //      Load the object into memory. 
    8340                         miReadFile(fname,file_open,bands,geoSubMesh); 
     8332                        miReadFile(fname,file_open,geoSubMesh); 
    83418333 
    83428334                        //      2006-02-14. 
     
    83898381                        //----------------------- 
    83908382 
    8391                         SGI_Strip(num_faces,bands,t,tr); 
     8383                        SGI_Strip(num_faces,t,tr); 
    83928384 
    83938385                        //      2006-02-14. 
     
    84008392 
    84018393                        //      Get the total cost. 
    8402                         Output_TriEx(-1,-2,-3,NULL,-20,cost); 
     8394                        Output_TriEx(-1,-2,-3,-20,cost); 
    84038395 
    84048396                        End_Face_Struct(num_faces); 
    84058397                        End_Edge_Struct(num_vert); 
    8406                         fclose(bands); 
    84078398 
    84088399                        //      2006-02-14. 
Note: See TracChangeset for help on using the changeset viewer.