Ignore:
Timestamp:
04/30/07 08:16:31 (18 years ago)
Author:
gumbau
Message:
 
Location:
GTP/trunk/Lib/Geom/shared/GTGeometry/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMesh.cpp

    r2322 r2341  
    5959                mSubMesh[i].mType                                                                                               =       mesh.mSubMesh[i].mType; 
    6060 
     61                strcpy(mSubMesh[i].mName,mesh.mSubMesh[i].mName); 
    6162                strcpy(mSubMesh[i].mMaterialName,mesh.mSubMesh[i].mMaterialName); 
    6263                 
     
    202203                mSubMesh[i].mVertexBuffer->mVertexInfo  =       mesh.mSubMesh[i].mVertexBuffer->mVertexInfo; 
    203204                mSubMesh[i].mType                                                                                               =       mesh.mSubMesh[i].mType; 
     205 
     206                strcpy(mSubMesh[i].mName,mesh.mSubMesh[i].mName); 
    204207                strcpy(mSubMesh[i].mMaterialName,mesh.mSubMesh[i].mMaterialName); 
    205208 
     
    515518                mesh->mSubMesh[i].mType                                                         =       mSubMesh[i].mType; 
    516519                 
     520                strcpy(mesh->mSubMesh[i].mName,mSubMesh[i].mName); 
    517521                strcpy(mesh->mSubMesh[i].mMaterialName,mSubMesh[i].mMaterialName); 
    518522                 
  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshLoader.cpp

    r2127 r2341  
    1414#include        <cctype> 
    1515#include        <map> 
     16#include "GeoLodStripsLibrary.h" 
     17#include "GeoLodStripsConstructor.h" 
    1618 
    1719using namespace Geometry; 
     
    165167        unsigned        short   headerID; 
    166168        size_t                                  i; 
    167         //float                                         aux; 
    168169        size_t                                  k; 
    169170        bool                                            found; 
     
    462463        } 
    463464         
    464  
    465465        if (idx32bit) 
    466466        { 
     
    561561                } 
    562562        } 
    563  
    564563} 
    565564 
     
    597596                 
    598597                jumpChunk(f); 
    599  
    600598        } 
    601599} 
     
    606604void GeoMeshLoader::readSubMeshNameTable(FILE   *f, Mesh        *geoMesh) 
    607605{ 
    608                 unsigned        short   chunkID; 
    609                 unsigned        short   subMeshIndex; 
    610                 char                                            string[255]; 
    611  
     606        unsigned        short   chunkID; 
     607        unsigned        short   subMeshIndex; 
     608        char                                            string[255]; 
     609 
     610        if (!feof(f)) 
     611        { 
     612                chunkID =       readChunk(f); 
     613 
     614                while   (!feof(f) && (chunkID == M_SUBMESH_NAME_TABLE_ELEMENT)) 
     615                { 
     616                        //      Debug. 
     617                        cout    <<      "               M_SUBMESH_NAME_TABLE_ELEMENT" 
     618                                <<      endl; 
     619 
     620                        //      Read in the index of the submesh. 
     621                        fread(&subMeshIndex,sizeof(unsigned short),1,f); 
     622 
     623                        //      Read in the String and map it to its index. 
     624                        fgets(string,255,f); 
     625 
     626                        string[strlen(string) - 1]      =       '\0'; 
     627 
     628                        //      Gets the submesh name. 
     629                        strcpy(geoMesh->mSubMesh[subMeshIndex].mName,string); 
     630 
     631                        cout    <<      "--> SubMesh " 
     632                                <<      subMeshIndex 
     633                                <<      ": " 
     634                                <<      string 
     635                                <<      endl; 
     636 
     637                        // If we're not end of file get the next chunk ID. 
     638                        if (!feof(f)) 
     639                        { 
     640                                chunkID = readChunk(f); 
     641                        } 
     642                } 
    612643                if (!feof(f)) 
    613644                { 
    614                         chunkID =       readChunk(f); 
    615                          
    616                         while   (!feof(f) && (chunkID == M_SUBMESH_NAME_TABLE_ELEMENT )) 
    617                         { 
    618                                 //      Debug. 
    619                                 cout    <<      "               M_SUBMESH_NAME_TABLE_ELEMENT" 
    620                                                         <<      endl; 
    621                                  
    622                                 // Read in the index of the submesh. 
    623                                 fread(&subMeshIndex,sizeof(unsigned short),1,f); 
    624                                  
    625                                 // Read in the String and map it to its index. 
    626                                 fgets(string,255,f); 
    627  
    628                                 // If we're not end of file get the next chunk ID. 
    629                                 if (!feof(f)) 
    630                                 { 
    631                                         chunkID = readChunk(f); 
    632                                 } 
    633                         } 
    634                         if (!feof(f)) 
    635                         { 
    636                                 // Backpedal back to start of chunk. 
    637                                 fseek(f,-(long)CHUNK_OVERHEAD_SIZE,1); 
    638                         } 
    639                 } 
     645                        // Backpedal back to start of chunk. 
     646                        fseek(f,-(long)CHUNK_OVERHEAD_SIZE,1); 
     647                } 
     648        } 
    640649} 
    641650 
     
    643652//      Read a mesh file. 
    644653//------------------------------------------------------------------------- 
    645  
    646 #include "GeoLodStripsLibrary.h" 
    647 #include "GeoLodStripsConstructor.h" 
    648  
    649654void GeoMeshLoader::readMesh(FILE       *f, Mesh        *geoMesh, int option) 
    650655{ 
     
    667672                chunkID =       readChunk(f); 
    668673 
    669                 while(!feof(f) && 
    670                                 (chunkID == M_GEOMETRY || 
    671                                  chunkID == M_SUBMESH || 
    672                                  chunkID == M_MESH_SKELETON_LINK || 
    673                                  chunkID == M_MESH_BONE_ASSIGNMENT || 
    674                                  chunkID == M_MESH_LOD || 
    675                                  chunkID == M_MESH_BOUNDS || 
    676                                  chunkID == M_SUBMESH_NAME_TABLE || 
    677                                  chunkID == M_EDGE_LISTS || 
    678                                  chunkID == 0xabcd ||  
    679                                  chunkID == 0xdcba)) 
     674                while   (!feof(f) && 
     675                                (chunkID == M_GEOMETRY                                                  || 
     676                                 chunkID == M_SUBMESH                                                           || 
     677                                 chunkID == M_MESH_SKELETON_LINK                || 
     678                                 chunkID == M_MESH_BONE_ASSIGNMENT      || 
     679                                 chunkID == M_MESH_LOD                                                  || 
     680                                 chunkID == M_MESH_BOUNDS                                               || 
     681                                 chunkID == M_SUBMESH_NAME_TABLE                || 
     682                                 chunkID == M_EDGE_LISTS                                                || 
     683                                 chunkID == M_LODSTRIPS                                                 || 
     684                                 chunkID == M_LODTREES                                                  || 
     685                                 chunkID == M_POSES                                                                     || 
     686                                 chunkID == M_ANIMATIONS)) 
    680687                { 
    681688                        switch(chunkID) 
    682689                        { 
    683                                 case 0xabcd: 
     690                                case M_LODSTRIPS: 
    684691                                         
    685692                                        //      Debug. 
     
    741748                                        break; 
    742749 
    743                                 case 0xdcba: 
     750                                case M_LODTREES: 
     751 
    744752                                        cout << "LODTREES_Chunk" << endl; 
    745753                                        treesimpseq = new Geometry::TreeSimplificationSequence; 
     
    761769                                        break; 
    762770 
    763  
    764771                                case M_GEOMETRY: 
    765772 
     
    792799                                        cout    <<      "               M_MESH_SKELETON_LINK  " 
    793800                                                                <<      endl; 
    794                                                                  
    795801 
    796802                                        readSkeletonLink(f, geoMesh, option); 
     
    799805 
    800806                                case M_MESH_BONE_ASSIGNMENT: 
    801  
    802                                         //      Debug. 
    803                                         //cout  <<      "               M_MESH_BONE_ASSIGNMENT  " 
    804                                         //                      <<      endl; 
    805807 
    806808                                        readMeshBoneAssignment(f, geoMesh, option); 
     
    823825                                                                <<      endl; 
    824826 
    825                                         //jumpChunk(f); 
    826827                                        readMeshBounds(f, geoMesh, option); 
    827828                                        break; 
     
    844845                                        jumpChunk(f); 
    845846                                        break; 
     847 
     848                                case M_POSES: 
     849 
     850                                        //      Debug. 
     851                                        cout    <<      "               M_POSES " 
     852                                                                <<      endl; 
     853 
     854                                        jumpChunk(f); 
     855                                        break; 
     856 
     857                                case M_ANIMATIONS: 
     858 
     859                                        //      Debug. 
     860                                        cout    <<      "               M_ANIMATIONS " 
     861                                                                <<      endl; 
     862 
     863                                        jumpChunk(f); 
     864                                        break; 
    846865                        } 
    847866 
     
    866885                } 
    867886        } 
    868  
    869 } 
    870  
     887} 
    871888 
    872889//------------------------------------------------------------------------- 
     
    879896        size_t  strip_count; 
    880897        size_t  tailIndex; 
    881         //size_t        tail; 
    882898 
    883899        head_found                                                      =       false; 
     
    14761492        { 
    14771493                fgets(geoMesh->mSkeletonName,255,f); 
     1494 
     1495                geoMesh->mSkeletonName[strlen(geoMesh->mSkeletonName) - 1]      =       '\0'; 
    14781496                 
    14791497                geoMesh->hasSkeleton    =       true; 
  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSaver.cpp

    r2127 r2341  
    181181        if (geoMesh->hasSkeleton) 
    182182        { 
     183                strcat(geoMesh->mSkeletonName,"\n"); 
     184 
    183185                // Write skeleton link 
    184186                writeSkeletonLink(geoMesh->mSkeletonName); 
     
    199201        writeMeshBounds(geoMesh); 
    200202 
     203        // Write submesh name table. 
     204        writeSubMeshNameTable(geoMesh); 
     205 
    201206        /* 
    202207        // Write LOD data if any 
     
    212217        writeBoundsInfo(pMesh); 
    213218        LogManager::getSingleton().logMessage("Bounds information exported."); 
    214  
    215         // Write submesh name table 
    216         LogManager::getSingleton().logMessage("Exporting submesh name table..."); 
    217         writeSubMeshNameTable(pMesh); 
    218         LogManager::getSingleton().logMessage("Submesh name table exported."); 
    219219 
    220220        // Write edge lists 
     
    414414 
    415415        //      Write the vertex declaration header. 
    416         writeChunkHeader(       M_GEOMETRY_VERTEX_DECLARATION,size); 
     416        writeChunkHeader(M_GEOMETRY_VERTEX_DECLARATION,size); 
    417417 
    418418        //      Debug. 
     
    425425        //      Positions. 
    426426        //      Write the vertex element header for position. 
    427         writeChunkHeader(       M_GEOMETRY_VERTEX_ELEMENT,size); 
     427        writeChunkHeader(M_GEOMETRY_VERTEX_ELEMENT,size); 
    428428 
    429429        //      Debug. 
     
    448448        //      Normals. 
    449449        //      Write the vertex element header for position. 
    450         writeChunkHeader(       M_GEOMETRY_VERTEX_ELEMENT,size); 
     450        writeChunkHeader(M_GEOMETRY_VERTEX_ELEMENT,size); 
    451451         
    452452        //      Debug. 
     
    528528 
    529529        //      Write the vertex buffer header. 
    530         writeChunkHeader(       M_GEOMETRY_VERTEX_BUFFER,       size); 
     530        writeChunkHeader(M_GEOMETRY_VERTEX_BUFFER,      size); 
    531531 
    532532        //      Debug. 
     
    613613        writeFloats(geoMesh->mMeshBounds.maxZ,1); 
    614614        writeFloats(geoMesh->mMeshBounds.radius,1); 
     615} 
     616 
     617//------------------------------------------------------------------------- 
     618// Write submesh name table. 
     619//------------------------------------------------------------------------- 
     620void    GeoMeshSaver::writeSubMeshNameTable(Mesh        *geoMesh) 
     621{ 
     622        size_t  size; 
     623        size_t  names_size; 
     624 
     625        //      Size of the names of the submeshes. 
     626        names_size      =       0; 
     627 
     628        //      For each submesh. 
     629        for (size_t     i = 0; i < geoMesh->mSubMeshCount;      i++) 
     630        { 
     631                names_size      =       strlen(geoMesh->mSubMesh[i].mName); 
     632        } 
     633 
     634        size    =       CHUNK_OVERHEAD_SIZE 
     635                                        + 
     636                                        names_size 
     637                                        + 
     638                                        (CHUNK_OVERHEAD_SIZE + sizeof(short)) * geoMesh->mSubMeshCount; 
     639 
     640        writeChunkHeader(M_SUBMESH_NAME_TABLE, (unsigned long)size); 
     641 
     642        //      For each submesh. 
     643        for (size_t     i = 0;  i < geoMesh->mSubMeshCount;     i++) 
     644        { 
     645                size    =       CHUNK_OVERHEAD_SIZE 
     646                                                + 
     647                                                sizeof(short) 
     648                                                + 
     649                                                strlen(geoMesh->mSubMesh[i].mName); 
     650 
     651                writeChunkHeader(M_SUBMESH_NAME_TABLE_ELEMENT, (unsigned long)size); 
     652 
     653                writeShorts(i, 1); 
     654 
     655                strcat(geoMesh->mSubMesh[i].mName,"\n"); 
     656                mSerializer->WriteData(geoMesh->mSubMesh[i].mName); 
     657        } 
    615658} 
    616659 
     
    751794 
    752795        writeString(mesh_version); 
    753  
    754796} 
    755797 
  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshStripifier.cpp

    r1559 r2341  
    1 /*      ========================================================================== 
     1/*      ===================================================================== 
    22 *      (C) 2005 Universitat Jaume I 
    3  *      ========================================================================== 
     3 *      ===================================================================== 
    44 *      PROYECT:        GAME TOOLS 
    5  *      ==========================================================================*/ 
    6 /**     CONTENT:        Make triangle strip meshes from triangle list meshes. 
    7         * 
    8         * 
    9         *       @file   GeoMeshStripifier.cpp 
    10 /*===========================================================================*/ 
     5 *      ===================================================================== 
     6 *      CONTENT:        Make triangle strip meshes from triangle list meshes. 
     7 * 
     8 * 
     9 *      @file   GeoMeshStripifier.cpp 
     10 *      =====================================================================*/ 
    1111 
    1212#include "GeoMeshStripifier.h" 
     
    1515using   namespace       std; 
    1616 
    17 //----------------------------------------------------------------------------- 
     17//------------------------------------------------------------------------- 
    1818//      Private. 
    19 //----------------------------------------------------------------------------- 
    20  
    21 //----------------------------------------------------------------------------- 
    22 ///     InitList. 
    23 //----------------------------------------------------------------------------- 
     19//------------------------------------------------------------------------- 
     20 
     21//------------------------------------------------------------------------- 
     22//      InitList. 
     23//------------------------------------------------------------------------- 
    2424BOOL CustomStripifier::InitList(PLISTHEAD LHead) 
    2525{ 
     
    3535} 
    3636 
    37 //----------------------------------------------------------------------------- 
     37//------------------------------------------------------------------------- 
    3838//      AddHead. 
    39 //----------------------------------------------------------------------------- 
     39//------------------------------------------------------------------------- 
    4040BOOL CustomStripifier::AddHead(PLISTHEAD LHead, PLISTINFO LInfo) 
    4141{ 
     
    80628062void CustomStripifier::Save_Walks(int numfaces) 
    80638063{ 
    8064   int x,y,numverts; 
    8065   int front_walk, back_walk; 
    8066   ListHead *pListHead; 
    8067   PF_FACES temp = NULL; 
    8068    
    8069   for (x=0; x<numfaces; x++) 
    8070     {  
    8071       /* for each face, get the face */ 
    8072       pListHead = PolFaces[x]; 
    8073       temp = (PF_FACES) PeekList(pListHead,LISTHEAD,0); 
    8074       numverts = temp->nPolSize; 
    8075       front_walk = 0;  
    8076       back_walk = 0; 
    8077        
    8078       /* we are finding patches only for quads */ 
    8079       if (numverts == 4) 
    8080         { 
    8081           /*    for each face not seen yet, do North and South together 
    8082                 and East and West together 
    8083           */ 
    8084           for (y=0;y<2;y++) 
    8085             { 
    8086               /*   Check if the opposite sides were seen already from another 
    8087                    starting face, if they were then there is no need to do  
    8088                    the walk again 
    8089               */ 
    8090                
    8091               if        ( ((*(temp->walked+y) == -1) && 
    8092                            (*(temp->walked+y+2) == -1) )) 
     8064        int x,y,numverts; 
     8065        int front_walk, back_walk; 
     8066        ListHead *pListHead; 
     8067        PF_FACES temp = NULL; 
     8068 
     8069        for (x=0; x<numfaces; x++) 
     8070        {  
     8071                /* for each face, get the face */ 
     8072                pListHead = PolFaces[x]; 
     8073                temp = (PF_FACES) PeekList(pListHead,LISTHEAD,0); 
     8074                numverts = temp->nPolSize; 
     8075                front_walk = 0;  
     8076                back_walk = 0; 
     8077 
     8078                /* we are finding patches only for quads */ 
     8079                if (numverts == 4) 
    80938080                { 
    8094                   /* Find walk for the first edge */ 
    8095                   front_walk = Calculate_Walks(x,y,temp); 
    8096                   /* Find walk in the opposite direction */ 
    8097                   back_walk = Calculate_Walks(x,y+2,temp); 
    8098                   /*    Now put into the data structure the numbers that 
    8099                         we have found 
    8100                   */ 
    8101                   Assign_Walk(x,temp,front_walk,y,back_walk); 
    8102                   Assign_Walk(x,temp,back_walk,y+2,front_walk); 
     8081                        /*      for each face not seen yet, do North and South together 
     8082                                        and East and West together 
     8083                                        */ 
     8084                        for (y=0;y<2;y++) 
     8085                        { 
     8086                                /*   Check if the opposite sides were seen already from another 
     8087                                                 starting face, if they were then there is no need to do  
     8088                                                 the walk again 
     8089                                                 */ 
     8090 
     8091                                if      ( ((*(temp->walked+y) == -1) && 
     8092                                                        (*(temp->walked+y+2) == -1) )) 
     8093                                { 
     8094                                        /* Find walk for the first edge */ 
     8095                                        front_walk = Calculate_Walks(x,y,temp); 
     8096                                        /* Find walk in the opposite direction */ 
     8097                                        back_walk = Calculate_Walks(x,y+2,temp); 
     8098                                        /*      Now put into the data structure the numbers that 
     8099                                                        we have found 
     8100                                                        */ 
     8101                                        Assign_Walk(x,temp,front_walk,y,back_walk); 
     8102                                        Assign_Walk(x,temp,back_walk,y+2,front_walk); 
     8103                                } 
     8104                        } 
    81038105                } 
    8104             } 
    8105         } 
    8106     } 
     8106        } 
    81078107} 
    81088108 
     
    85578557} 
    85588558 
    8559 //----------------------------------------------------------------------------- 
     8559//------------------------------------------------------------------------- 
    85608560//      Constructors. 
    8561 //----------------------------------------------------------------------------- 
     8561//------------------------------------------------------------------------- 
    85628562 
    85638563MeshStripifier::MeshStripifier() 
     
    85848584} 
    85858585 
    8586 //----------------------------------------------------------------------------- 
     8586//------------------------------------------------------------------------- 
    85878587//      Destroyers. 
    8588 //----------------------------------------------------------------------------- 
     8588//------------------------------------------------------------------------- 
    85898589CustomStripifier::~CustomStripifier() 
    85908590{        
     
    85968596} 
    85978597 
    8598 //----------------------------------------------------------------------------- 
     8598//------------------------------------------------------------------------- 
    85998599//      Public. 
    8600 //----------------------------------------------------------------------------- 
    8601  
    8602 //----------------------------------------------------------------------------- 
     8600//------------------------------------------------------------------------- 
     8601 
     8602//------------------------------------------------------------------------- 
    86038603//      Stripify. 
    8604 //----------------------------------------------------------------------------- 
     8604//------------------------------------------------------------------------- 
    86058605int CustomStripifier::Stripify() 
    86068606{ 
     
    86208620} 
    86218621 
    8622 //----------------------------------------------------------------------------- 
     8622//------------------------------------------------------------------------- 
    86238623//      GetMesh: Return de current Mesh. 
    8624 //----------------------------------------------------------------------------- 
     8624//------------------------------------------------------------------------- 
    86258625Mesh*   CustomStripifier::GetMesh() 
    86268626{ 
     
    86338633} 
    86348634 
    8635 //----------------------------------------------------------------------------- 
     8635//------------------------------------------------------------------------- 
    86368636//      Set the progress bar function. 
    8637 //----------------------------------------------------------------------------- 
     8637//------------------------------------------------------------------------- 
    86388638void    CustomStripifier::SetProgressFunc(TIPOFUNC upb) 
    86398639{ 
     
    86428642} 
    86438643 
    8644 //----------------------------------------------------------------------------- 
     8644//------------------------------------------------------------------------- 
    86458645// Sets what is the submesh that stores the leaves. 
    8646 //----------------------------------------------------------------------------- 
     8646//------------------------------------------------------------------------- 
    86478647void CustomStripifier::SetSubMeshLeaves(size_t  submesh) 
    86488648{ 
  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSubMesh.cpp

    r1009 r2341  
    1515        mType(GEO_TRIANGLE_LIST) 
    1616{ 
     17        strcpy(mName,""); 
    1718        strcpy(mMaterialName,""); 
    1819} 
Note: See TracChangeset for help on using the changeset viewer.