Ignore:
Timestamp:
05/29/06 11:59:07 (19 years ago)
Author:
gumbau
Message:
 
Location:
GTP/trunk/Lib/Geom/shared/GeoTool
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • GTP/trunk/Lib/Geom/shared/GeoTool/include/GeoMeshLoader.h

    r980 r989  
    114114                        unsigned        long    long_actual; 
    115115                        size_t                                  currentSubMesh; 
     116                        bool                                            mError; 
    116117 
    117118                        struct GeometryElement 
  • GTP/trunk/Lib/Geom/shared/GeoTool/include/GeoMeshSaver.h

    r980 r989  
    110110                        //      Gets the material of the mesh. 
    111111                        String  getMaterialName(); 
    112  
     112                         
    113113                        //      Saves a Mesh into a file. 
    114114                        int     save(Mesh       *geoMesh,       const   char    *fileNameMesh); 
  • GTP/trunk/Lib/Geom/shared/GeoTool/include/GeoMeshViewUI.h

    r988 r989  
    7171enum    SimplificationType 
    7272{ 
     73        NO_SIMPLIFICATION, 
    7374        MESHSIMP, 
    7475        HOJAS, 
     
    121122        inline void cb_menuFileSave_i(fltk::Item*, void*); 
    122123        static void cb_menuFileSave(fltk::Item*, void*); 
    123         inline void cb_menuOpenSaveAs_i(fltk::Item*, void*); 
    124         static void cb_menuOpenSaveAs(fltk::Item*, void*); 
     124        inline void cb_menuFileSaveAs_i(fltk::Item*, void*); 
     125        static void cb_menuFileSaveAs(fltk::Item*, void*); 
    125126 
    126127        inline void cb_menuMeshInfo_i(fltk::Item*, void*); 
     
    131132        static void     cb_menuFileTransformSharedVertex(fltk::Item* o, void* v); 
    132133 
    133         inline void cb_menuOpenQuit_i(fltk::Item*, void*); 
    134         static void cb_menuOpenQuit(fltk::Item*, void*); 
     134        inline void cb_menuFileQuit_i(fltk::Item*, void*); 
     135        static void cb_menuFileQuit(fltk::Item*, void*); 
    135136        inline void cb_menuEditUndo_i(fltk::Item*, void*); 
    136137        static void cb_menuEditUndo(fltk::Item*, void*); 
     
    201202        static void cb_mLogo(fltk::InvisibleBox*, void*); 
    202203 
     204        //      Shows build process. 
     205        void    activeBuildProcess(); 
     206 
    203207        //      Shows the stripify panel. 
    204208        void    showStripify(); 
     
    271275        void    openMeshFile(); 
    272276 
     277        //      Check if file exists. 
     278        bool    fileExists(const char   *fileNameMesh); 
     279 
    273280        public: 
    274281 
     
    281288        fltk::Item                                      *menuFileOpen; 
    282289        fltk::Item                                      *menuFileSave; 
    283         fltk::Item                                      *menuOpenSaveAs; 
     290        fltk::Item                                      *menuFileSaveAs; 
    284291        fltk::Item                                      *menuMeshInfo; 
    285292        fltk::Item                                      *menuMeshExportOBJ; 
    286293        fltk::Item                                      *menuFileTransformSharedVertex; 
    287294 
    288         fltk::Item                                      *menuOpenQuit; 
     295        fltk::Item                                      *menuFileQuit; 
    289296        fltk::ItemGroup                 *menuEdit; 
    290297        fltk::Item                                      *menuEditUndo; 
  • GTP/trunk/Lib/Geom/shared/GeoTool/out.objf

    r988 r989  
    33#by Francine Evans 
    44 
    5 t 1413 1414 1412 
    6 q 1415 
    7 q 1399 
    8 q 1400 
    9 q 1398 
    10 q 1401 
    11 q 1402 
    12 q 1403 
    13 q 1404 
    14 q 1405 
    15 q 1406 
    16 q 1407 
    17 q 1408 
    18 q 1409 
    19 q 1410 1411 
    20 t 1395 1396 1394 
    21 q 1397 
    22 q 1381 
    23 q 1382 
    24 q 1380 
    25 q 1383 
    26 q 1384 
    27 q 1385 
    28 q 1386 
    29 q 1387 
    30 q 1388 
    31 q 1389 
    32 q 1390 
    33 q 1391 
    34 q 1392 1393 
    35 t 1377 1378 1376 
    36 q 1379 
    37 q 1363 
    38 q 1364 
    39 q 1362 
    40 q 1365 
    41 q 1366 
    42 q 1367 
    43 q 1368 
    44 q 1369 
    45 q 1370 
    46 q 1371 
    47 q 1372 
    48 q 1373 
    49 q 1374 1375 
    50 t 1359 1360 1358 
    51 q 1361 
    52 q 1345 
    53 q 1346 
    54 q 1344 
    55 q 1347 
    56 q 1348 
    57 q 1349 
    58 q 1350 
    59 q 1351 
    60 q 1352 
    61 q 1353 
    62 q 1354 
    63 q 1355 
    64 q 1356 1357 
    65 t 1340 1341 1339 
    66 q 1342 
    67 q 1312 
    68 q 1313 
    69 q 1311 
    70 q 1314 
    71 q 1319 
    72 q 1320 
    73 q 1323 
    74 q 1324 
    75 q 1327 
    76 q 1328 
    77 q 1331 
    78 q 1332 
    79 q 1335 1336 
    80 t 1294 1295 1293 
    81 q 1305 
    82 q 1304 
    83 q 1301 
    84 q 1300 
    85 q 1297 
    86 q 1296 
    87 q 1298 
    88 q 1299 
    89 q 1302 
    90 q 1303 
    91 q 1306 
    92 q 1307 
    93 q 1291 
    94 q 1290 1292 
    95 t 1284 1285 1283 
    96 q 1286 
    97 q 1287 
    98 q 1289 
    99 q 1275 
    100 q 1276 1275 
    101 q 1252 1275 
    102 q 1255 1275 
    103 q 1277 
    104 q 1287 
    105 q 1278 
    106 q 1279 1278 
    107 q 1259 1278 
    108 q 1257 
    109 q 1277 1257 
    110 q 1255 
    111 q 1256 1255 
    112 q 1254 
    113 q 1252 1254 
    114 q 1253 1254 
    115 q 1274 1254 
    116 q 1273 
    117 q 1256 
    118 q 1258 
    119 q 1257 1258 
    120 q 1259 1258 
    121 q 1260 
    122 q 1273 
    123 q 1262 1273 
    124 q 1272 1273 
    125 q 1270 1273 
    126 q 1271 1274 
    127 t 1271 1268 1270 1269 
    128 t 1288 1283 1288 1287 
    129 q 1280 
    130 q 1279 
    131 q 1261 
    132 q 1259 1261 
    133 q 1260 1261 
    134 q 1262 1261 
    135 q 1263 
    136 q 1280 
    137 q 1281 
    138 q 1288 1281 
    139 q 1282 1281 
    140 q 1265 
    141 q 1263 
    142 q 1264 
    143 q 1262 1264 
    144 q 1272 1264 
    145 q 1266 
    146 q 1265 
    147 q 1267 1282 
    148 t 1453 1452 1453 1479 
    149 q 1478 
    150 q 1475 
    151 q 1474 
    152 q 1471 
    153 q 1470 
    154 q 1467 
    155 q 1466 
    156 q 1463 
    157 q 1462 
    158 q 1459 
    159 q 1458 
    160 q 1455 
    161 q 1454 
    162 q 1452 1453 
    163 t 1477 1476 1477 1451 
    164 q 1450 
    165 q 1448 
    166 q 1449 
    167 q 1456 
    168 q 1457 
    169 q 1460 
    170 q 1461 
    171 q 1464 
    172 q 1465 
    173 q 1468 
    174 q 1469 
    175 q 1472 
    176 q 1473 
    177 q 1476 1477 
    178 t 1421 1420 1421 1447 
    179 q 1446 
    180 q 1443 
    181 q 1442 
    182 q 1439 
    183 q 1438 
    184 q 1435 
    185 q 1434 
    186 q 1431 
    187 q 1430 
    188 q 1427 
    189 q 1426 
    190 q 1423 
    191 q 1422 
    192 q 1420 1421 
    193 t 1445 1444 1445 1419 
    194 q 1418 
    195 q 1416 
    196 q 1417 
    197 q 1424 
    198 q 1425 
    199 q 1428 
    200 q 1429 
    201 q 1432 
    202 q 1433 
    203 q 1436 
    204 q 1437 
    205 q 1440 
    206 q 1441 
    207 q 1444 1445 
    208 t 1343 1317 1316 
    209 q 1315 1316 
    210 q 1321 1316 
    211 q 1325 1316 
    212 q 1329 1316 
    213 q 1333 1316 
    214 q 1337 1343 
    215 t 1309 1338 1310 
    216 q 1334 1310 
    217 q 1330 1310 
    218 q 1326 1310 
    219 q 1322 1310 
    220 q 1318 1310 
    221 q 1308 1309 
     5t 77 128 77 57 
     6q 76 57 
     7q 56 
     8q 49 
     9q 51 49 
     10q 50 49 
     11q 52 49 
     12q 59 49 
     13q 46 49 
     14q 47 49 
     15q 58 
     16q 57 58 
     17q 53 58 
     18q 55 58 
     19q 60 58 
     20q 48 
     21q 47 
     22q 43 
     23q 46 
     24q 42 
     25q 41 42 
     26q 39 
     27q 43 
     28q 44 
     29q 48 60 
     30t 39 44 39 40 
     31q 41 40 
     32q 45 
     33q 44 
     34q 52 
     35q 55 52 
     36q 53 52 
     37q 54 
     38q 50 54 
     39q 68 
     40q 53 
     41q 67 
     42q 128 67 
     43q 138 
     44q 139 138 
     45q 144 138 
     46q 124 138 
     47q 127 
     48q 128 127 
     49q 126 
     50q 124 
     51q 125 124 
     52q 123 
     53q 144 123 
     54q 130 
     55q 125 
     56q 132 
     57q 131 132 
     58q 128 132 
     59q 77 132 
     60q 76 
     61q 130 76 
     62q 144 
     63q 145 
     64q 139 
     65q 97 139 
     66q 140 
     67q 67 
     68q 141 
     69q 143 141 
     70q 142 
     71q 140 142 
     72q 97 
     73q 96 97 
     74q 95 97 
     75q 103 97 
     76q 105 97 
     77q 102 
     78q 145 
     79q 78 
     80q 76 
     81q 75 76 
     82q 74 
     83q 56 74 
     84q 50 74 
     85q 68 
     86q 69 
     87q 67 69 
     88q 70 
     89q 17 
     90q 73 
     91q 18 
     92q 62 18 
     93q 20 18 
     94q 19 
     95q 17 
     96q 25 17 
     97q 28 
     98q 24 
     99q 29 
     100q 23 29 
     101q 27 29 
     102q 32 29 
     103q 34 
     104q 28 
     105q 33 
     106q 25 33 
     107q 11 33 
     108q 15 
     109q 34 
     110q 13 
     111q 32 
     112q 16 32 
     113q 31 
     114q 27 31 
     115q 26 
     116q 30 26 
     117q 25 26 
     118q 19 
     119q 21 
     120q 20 
     121q 22 20 
     122q 66 
     123q 62 
     124q 65 62 
     125q 61 62 
     126q 63 62 
     127q 72 
     128q 73 
     129q 71 
     130q 70 71 
     131q 67 
     132q 72 67 
     133q 63 
     134q 143 
     135q 135 
     136q 142 135 
     137q 96 
     138q 98 
     139q 95 98 
     140q 99 98 
     141q 100 98 
     142q 137 
     143q 135 137 
     144q 64 137 
     145q 38 
     146q 66 
     147q 64 
     148q 65 64 
     149q 61 
     150q 136 
     151q 63 136 
     152q 135 64 
     153t 27 26 27 21 
     154q 23 
     155q 22 
     156q 24 22 
     157q 78 
     158q 66 78 
     159q 137 78 
     160q 100 
     161q 102 100 
     162q 101 
     163q 99 101 
     164q 106 
     165q 102 106 
     166q 105 
     167q 111 105 
     168q 110 
     169q 103 110 
     170q 90 110 
     171q 93 
     172q 111 
     173q 91 111 
     174q 92 111 
     175q 109 
     176q 106 109 
     177q 99 
     178q 108 99 
     179q 104 
     180q 95 104 
     181q 103 104 
     182q 107 
     183q 108 107 
     184q 87 107 
     185q 88 107 
     186q 89 
     187q 103 89 
     188q 90 
     189q 83 90 
     190q 84 
     191q 93 
     192q 85 
     193q 91 
     194q 81 
     195q 92 
     196q 86 92 
     197q 94 
     198q 109 94 
     199q 108 94 
     200q 87 94 
     201q 79 
     202q 86 79 
     203q 81 79 
     204q 80 
     205q 87 80 
     206q 88 
     207q 82 
     208q 89 82 
     209q 83 82 
     210q 81 80 
     211t 81 83 81 84 85 
     212t 24 78 24 75 
     213q 17 75 
     214q 69 74 
     215t 45 52 45 46 41 
     216t 14 1 13 
     217q 8 
     218q 16 
     219q 3 16 
     220q 10 
     221q 31 10 
     222q 30 10 
     223q 9 10 
     224q 2 
     225q 3 2 
     226q 1 2 
     227q 5 
     228q 9 
     229q 12 
     230q 30 12 
     231q 25 12 
     232q 11 12 
     233q 4 
     234q 5 4 
     235q 1 4 
     236q 7 
     237q 11 7 
     238q 15 
     239q 6 
     240q 14 6 
     241q 1 7 
     242t 1 3 1 8 
     243t 128 131 128 129 
     244q 126 
     245q 134 126 
     246q 133 
     247q 125 
     248q 120 125 
     249q 121 
     250q 131 
     251q 122 
     252q 129 122 
     253q 117 122 
     254q 118 
     255q 121 118 
     256q 120 118 
     257q 116 118 
     258q 115 
     259q 117 
     260q 114 117 
     261q 119 117 
     262q 133 134 
     263t 120 133 120 119 
     264q 113 
     265q 114 113 
     266q 115 113 
     267q 116 120 
     268t 38 112 35 
     269q 36 35 
     270q 37 38 
  • GTP/trunk/Lib/Geom/shared/GeoTool/src/GeoMeshLoader.cpp

    r985 r989  
    1515using   namespace       std; 
    1616 
     17//--------------------------------------------------------------------------- 
    1718//      Jump a chunk. 
     19//--------------------------------------------------------------------------- 
    1820void GeoMeshLoader::jumpChunk(FILE      *f) 
    1921{ 
     
    2426} 
    2527 
     28//--------------------------------------------------------------------------- 
    2629//      Read a chunk. 
     30//--------------------------------------------------------------------------- 
    2731unsigned short GeoMeshLoader::readChunk(FILE    *f) 
    2832{ 
     
    3539} 
    3640 
     41//--------------------------------------------------------------------------- 
    3742//      Read geometry vertex element. 
     43//--------------------------------------------------------------------------- 
    3844void GeoMeshLoader::readGeometryVertexElement(FILE      *f, Mesh        *geoMesh) 
    3945{ 
     
    103109} 
    104110 
     111//--------------------------------------------------------------------------- 
    105112//      Read geometry vertex declaration. 
     113//--------------------------------------------------------------------------- 
    106114void GeoMeshLoader::readGeometryVertexDeclaration(FILE  *f, Mesh        *geoMesh) 
    107115{ 
     
    143151}//     End readGeometryVertexDeclaration. 
    144152 
     153//--------------------------------------------------------------------------- 
    145154//      Read geometry vertex buffer. 
     155//--------------------------------------------------------------------------- 
    146156void GeoMeshLoader::readGeometryVertexBuffer(FILE       *f, Mesh        *geoMesh, int option) 
    147157{ 
     
    270280                cout    <<      "Error: Source not found." 
    271281                                        <<      endl; 
    272         } 
    273  
    274 } 
    275  
     282 
     283                //      Error. 
     284                mError  =       true; 
     285        } 
     286 
     287} 
     288 
     289//--------------------------------------------------------------------------- 
    276290//      Read Geometry. 
     291//--------------------------------------------------------------------------- 
    277292void GeoMeshLoader::readGeometry(FILE   *f, Mesh        *geoMesh, int option) 
    278293{ 
     
    361376} 
    362377 
     378//--------------------------------------------------------------------------- 
    363379//      Read a submesh operation. 
     380//--------------------------------------------------------------------------- 
    364381void GeoMeshLoader::readSubMeshOperation(       FILE    *f, 
    365382                                                                                                                                                                        Mesh    *geoMesh, 
     
    383400} 
    384401 
     402//--------------------------------------------------------------------------- 
    385403//      Read a submesh. 
     404//--------------------------------------------------------------------------- 
    386405void GeoMeshLoader::readSubMesh(FILE    *f, Mesh        *geoMesh, int option) 
    387406{ 
     
    479498                        cout    <<      "Error: Missing mesh geometry." 
    480499                                                <<      endl; 
     500 
     501                        //      Error. 
     502                        mError  =       true; 
    481503                } 
    482504                 
     
    537559} 
    538560 
     561//--------------------------------------------------------------------------- 
    539562//      Read a mesh lod information. 
     563//--------------------------------------------------------------------------- 
    540564void GeoMeshLoader::readMeshLodInfo(FILE        *f, Mesh        *geoMesh) 
    541565{ 
     
    572596} 
    573597 
     598//--------------------------------------------------------------------------- 
    574599//      Read a submesh name table. 
     600//--------------------------------------------------------------------------- 
    575601void GeoMeshLoader::readSubMeshNameTable(FILE   *f, Mesh        *geoMesh) 
    576602{ 
     
    609635} 
    610636 
     637//--------------------------------------------------------------------------- 
    611638//      Read a mesh file. 
     639//--------------------------------------------------------------------------- 
    612640void GeoMeshLoader::readMesh(FILE       *f, Mesh        *geoMesh, int option) 
    613641{ 
     
    741769                        cout    <<      "Error: Reading failure." 
    742770                                                <<      endl; 
    743                 } 
    744         } 
    745  
    746 } 
    747  
    748 /* 
    749                 Allocate memory to the array of strips 
    750 */ 
     771 
     772                        //      Error. 
     773                        mError  =       true; 
     774                } 
     775        } 
     776 
     777} 
     778 
     779 
     780//--------------------------------------------------------------------------- 
     781//      Allocate memory to the array of strips 
     782//--------------------------------------------------------------------------- 
    751783SubMesh* GeoMeshLoader::BuildStripsGeoSubMesh(SubMesh* geoSubMesh) 
    752784{ 
     
    848880} 
    849881 
     882//--------------------------------------------------------------------------- 
    850883//      Remove degenerate triangles of a submesh given. 
     884//--------------------------------------------------------------------------- 
    851885SubMesh *       GeoMeshLoader::removeDegenerateTriangles(SubMesh        *geoSubMesh) 
    852886{ 
     
    951985} 
    952986 
     987//--------------------------------------------------------------------------- 
    953988//      Loads a mesh. 
     989//--------------------------------------------------------------------------- 
    954990Mesh* GeoMeshLoader::load(char  *nameFileMesh)  
    955991{ 
     
    961997        SubMesh                                 *geosubmesh; 
    962998 
    963         //      Initialize the current submesh; 
    964         currentSubMesh  =       -1; 
    965          
    966999        //      Debug. 
    9671000        cout    <<      "---------------------------------" 
     
    9721005                                <<      endl; 
    9731006 
    974         //      Initialize the return value. 
    975         geoMesh =       new     Mesh(); 
     1007        geoMesh =       NULL; 
    9761008 
    9771009        //      Open the mesh file. 
    978         pFile   =       fopen( nameFileMesh, "rb" ); 
    979  
    980   if (!pFile) 
    981   { 
     1010        pFile   =       fopen(nameFileMesh, "rb"); 
     1011 
     1012  if (pFile) 
     1013        { 
     1014                //      Initialize the current submesh; 
     1015                currentSubMesh  =       -1; 
     1016 
     1017                //      Initialize the return value. 
     1018                geoMesh =       new     Mesh(); 
     1019 
     1020                //      Count the submeshes 
     1021                //      and next build the geomesh. 
     1022                for (int option = 0; option < 2;option++) 
     1023                { 
     1024                        //      Initialize Error. 
     1025                        mError  =       false; 
     1026         
     1027                        fread(&uno,sizeof(unsigned short),1,pFile); 
     1028 
     1029                        if (uno != M_HEADER) 
     1030                        { 
     1031                                //      Debug. 
     1032                                cout    <<      "Error: Header not found." 
     1033                                        <<      endl; 
     1034 
     1035                                //      Error. 
     1036                                mError  =       true; 
     1037                        } 
     1038 
     1039                        // Read version. 
     1040                        fgets(version,255,pFile); 
     1041 
     1042                        cout    <<      version <<      endl; 
     1043 
     1044                        if (strcmp(version,"[MeshSerializer_v1.30]\n")) 
     1045                        { 
     1046                                //      Debug. 
     1047                                cout    <<      "Error: Wrong mesh version." 
     1048                                        <<      endl 
     1049                                        <<      "Only version 1.3 or older allowed." 
     1050                                        <<      endl; 
     1051 
     1052                                //      Error. 
     1053                                mError  =       true; 
     1054                        } 
     1055 
     1056                        while(!feof(pFile)) 
     1057                        { 
     1058                                chunkID = readChunk(pFile); 
     1059 
     1060                                switch (chunkID) 
     1061                                { 
     1062                                        case M_MESH: 
     1063                                                readMesh(pFile, geoMesh, option); 
     1064                                                break; 
     1065                                } 
     1066                        } 
     1067 
     1068                        //      Create the submesh array. 
     1069                        if (option == SUBMESH_COUNT) 
     1070                        { 
     1071                                geoMesh->mSubMesh       = new SubMesh[geoMesh->mSubMeshCount]; 
     1072                        } 
     1073 
     1074                        //      Move the curso to the begining of the file. 
     1075                        fseek(pFile,0,SEEK_SET); 
     1076                } 
     1077 
     1078                //      Goes to the end of the file. 
     1079                fseek(pFile,0,SEEK_END); 
     1080 
     1081                //      Gets the size of the file. 
     1082                mFileSize       =       ftell(pFile); 
     1083 
     1084                // Close the mesh file. 
     1085                fclose(pFile); 
     1086 
     1087                //      If no error. 
     1088                if (!mError) 
     1089                { 
     1090                        for (int submesh = 0;   submesh < geoMesh->mSubMeshCount; submesh++) 
     1091                        { 
     1092                                //      Gets the actual submesh. 
     1093                                geosubmesh      =       &geoMesh->mSubMesh[submesh]; 
     1094 
     1095                                if (geosubmesh->mType == Geometry::GEO_TRIANGLE_STRIPS) 
     1096                                { 
     1097                                        //      Fill the strips list. 
     1098                                        geosubmesh      =       BuildStripsGeoSubMesh(geosubmesh); 
     1099                                } 
     1100                        } 
     1101 
     1102                        //      Sets coods between -1 and 1. 
     1103                        normalizeModel(geoMesh); 
     1104                } 
     1105        } 
     1106        else 
     1107        { 
    9821108                //      Debug. 
    983                 cout    <<      "Error: File " 
    984                                         <<      nameFileMesh 
    985                                         <<      " not found." 
     1109                cout    <<      "Error: File not found." 
    9861110                                        <<      endl; 
     1111 
     1112                //      File not found. 
     1113                mError  =       true; 
     1114        } 
     1115 
     1116        //      If an error happens. 
     1117        if (mError) 
     1118        { 
     1119                delete  geoMesh; 
    9871120                 
    988                 exit(0); 
    989   } 
    990  
    991         //      Count the submeshes 
    992         //      and next build the geomesh. 
    993         for (int option = 0; option < 2;option++) 
    994         { 
    995                 fread(&uno,sizeof(unsigned short),1,pFile); 
    996  
    997                 if (uno != M_HEADER) 
    998                 { 
    999                         //      Debug. 
    1000                         cout    <<      "Error: Header not found." 
    1001                                                 <<      endl; 
    1002                 } 
    1003  
    1004                 // Read version. 
    1005                 fgets(version,255,pFile); 
    1006  
    1007                 cout    <<      version <<      endl; 
    1008  
    1009                 if (strcmp(version,"[MeshSerializer_v1.30]\n")) 
    1010                 { 
    1011                         //      Debug. 
    1012                         cout    <<      "Error: Wrong mesh version." 
    1013                                                 <<      endl 
    1014                                                 <<      "Only version 1.3 or older allowed." 
    1015                                                 <<      endl; 
    1016                 } 
    1017  
    1018                 while(!feof(pFile)) 
    1019                 { 
    1020                         chunkID = readChunk(pFile); 
    1021  
    1022                         switch (chunkID) 
    1023                         { 
    1024                                 case M_MESH: 
    1025                                         readMesh(pFile, geoMesh, option); 
    1026                                         break; 
    1027                         } 
    1028                 } 
    1029  
    1030                 //      Create the submesh array 
    1031                 if (option == SUBMESH_COUNT) 
    1032                 {                
    1033                         geoMesh->mSubMesh       = new SubMesh[geoMesh->mSubMeshCount]; 
    1034                 } 
    1035                                                          
    1036                 //      Move the curso to the begining of the file. 
    1037                 fseek(pFile,0,SEEK_SET); 
    1038         } 
    1039  
    1040         //      Goes to the end of the file. 
    1041         fseek(pFile,0,SEEK_END); 
    1042  
    1043         //      Gets the size of the file. 
    1044         mFileSize       =       ftell(pFile); 
    1045          
    1046         // Close the mesh file. 
    1047         fclose(pFile); 
    1048          
    1049         for (int submesh = 0;   submesh < geoMesh->mSubMeshCount; submesh++) 
    1050         { 
    1051                 //      Gets the actual submesh. 
    1052                 geosubmesh      =       &geoMesh->mSubMesh[submesh]; 
    1053                  
    1054                 if (geosubmesh->mType == Geometry::GEO_TRIANGLE_STRIPS) 
    1055                 { 
    1056                         //      Fill the strips list. 
    1057                         geosubmesh      =       BuildStripsGeoSubMesh(geosubmesh); 
    1058                 } 
    1059         } 
    1060          
    1061         //      Sets coods between -1 and 1. 
    1062         normalizeModel(geoMesh); 
    1063  
     1121                geoMesh =       NULL; 
     1122        } 
     1123         
    10641124        return  geoMesh; 
    10651125} 
    10661126 
     1127//--------------------------------------------------------------------------- 
    10671128//      Sets coords between -1 and 1. 
     1129//--------------------------------------------------------------------------- 
    10681130void    GeoMeshLoader::normalizeModel(Mesh      *geoMesh) 
    10691131{ 
     
    11871249} 
    11881250 
     1251//--------------------------------------------------------------------------- 
    11891252//      Get the size in bytes of the file. 
     1253//--------------------------------------------------------------------------- 
    11901254size_t  GeoMeshLoader::getFileSize() 
    11911255{ 
     
    11931257} 
    11941258 
     1259//--------------------------------------------------------------------------- 
    11951260//      Constructor 
     1261//--------------------------------------------------------------------------- 
    11961262GeoMeshLoader::GeoMeshLoader() 
    11971263{ 
     
    12001266} 
    12011267 
     1268//--------------------------------------------------------------------------- 
    12021269//      Destroyer. 
     1270//--------------------------------------------------------------------------- 
    12031271GeoMeshLoader::~GeoMeshLoader() 
    12041272{ 
     
    12061274} 
    12071275 
    1208 //OSCAR 
     1276//--------------------------------------------------------------------------- 
     1277//      Read bones of the submesh. 
     1278//--------------------------------------------------------------------------- 
    12091279void GeoMeshLoader::readSubMeshBoneAssignment(FILE* f, SubMesh* geoSubMesh,int option) 
    12101280{ 
     
    12241294} 
    12251295 
    1226 //OSCAR 
     1296//--------------------------------------------------------------------------- 
     1297//      Read bones of the main mesh. 
     1298//--------------------------------------------------------------------------- 
    12271299void GeoMeshLoader::readMeshBoneAssignment(FILE* f, Mesh* geoMesh,int option) 
    12281300{ 
     
    12431315} 
    12441316 
    1245 //OSCAR 
     1317//--------------------------------------------------------------------------- 
     1318//      Read skeleton link. 
     1319//--------------------------------------------------------------------------- 
    12461320void GeoMeshLoader::readSkeletonLink(FILE* f, Mesh* geoMesh,int option) 
    12471321{ 
     
    12591333} 
    12601334 
     1335//--------------------------------------------------------------------------- 
    12611336//      Read bounding box settings. 
     1337//--------------------------------------------------------------------------- 
    12621338void    GeoMeshLoader::readMeshBounds(FILE      *f, Mesh        *geoMesh,       int     option) 
    12631339{ 
  • GTP/trunk/Lib/Geom/shared/GeoTool/src/GeoMeshSaver.cpp

    r985 r989  
    1 /*      ========================================================================== 
     1/*========================================================================== 
    22 *      (C) 2005 Universitat Jaume I 
    3  *      ========================================================================== 
     3 *========================================================================== 
    44 *      PROYECT:        GAME TOOLS 
    5  *      ==========================================================================*/ 
    6 /**     CONTENT:         
    7         * 
    8         * 
    9         *       @file   GeoMeshSaver.cpp 
    10 /*===========================================================================*/ 
     5 *==========================================================================*/ 
     6/*      CONTENT:         
     7 * 
     8 * 
     9 *      @file   GeoMeshSaver.cpp 
     10 *==========================================================================*/ 
    1111#include        <GeoMeshSaver.h> 
    1212 
     
    1414using   namespace       std; 
    1515 
    16 //------------------------------------------ 
     16//--------------------------------------------------------------------------- 
    1717//              Public: 
    18 //------------------------------------------ 
    19  
    20 //////////////////// 
    21 //      Constructors.   // 
    22 //////////////////// 
     18//--------------------------------------------------------------------------- 
     19 
     20//--------------------------------------------------------------------------- 
     21//      Constructors. 
     22//--------------------------------------------------------------------------- 
    2323GeoMeshSaver::GeoMeshSaver() 
    2424{ 
    2525} 
    2626 
    27 ////////////////// 
    28 //      Destroyer.      // 
    29 ////////////////// 
     27//--------------------------------------------------------------------------- 
     28//      Destroyer. 
     29//--------------------------------------------------------------------------- 
    3030GeoMeshSaver::~GeoMeshSaver() 
    3131{ 
     
    3333} 
    3434 
     35//--------------------------------------------------------------------------- 
    3536//      Saves a Mesh into a file. 
     37//--------------------------------------------------------------------------- 
    3638int     GeoMeshSaver::save(Mesh *geoMesh,       const   char    *fileNameMesh) 
    3739{ 
  • GTP/trunk/Lib/Geom/shared/GeoTool/src/GeoMeshViewUI.cpp

    r988 r989  
    8383//      Save As Callback 
    8484//--------------------------------------------------------------------------- 
    85 inline void GeoMeshViewUI::cb_menuOpenSaveAs_i(fltk::Item*, void*) 
     85inline void GeoMeshViewUI::cb_menuFileSaveAs_i(fltk::Item*, void*) 
    8686{ 
    8787        fltk::FileChooser *fcho; 
    8888        GeoMeshSaver                    *mesh_saver; 
     89        char                                                    file_name[255]; 
     90        char                                                    message[255]; 
     91        char                                                    *ptr; 
     92        int                                                             answer_yes; 
     93         
     94        //      Initialize answer to yes. 
     95        answer_yes      =       1; 
    8996         
    9097        if (mGeoMesh != NULL) 
     
    99106                if (fcho->value()) 
    100107                { 
    101                         mesh_saver      =       new     GeoMeshSaver(); 
    102                         mesh_saver->save(mGeoMesh,filename_name(fcho->value())); 
    103                         delete  mesh_saver; 
     108                        //      Gets file name. 
     109                        strcpy(file_name,fcho->value()); 
     110 
     111                        //      Cut extension. 
     112                        ptr                             =       strtok(file_name,"."); 
     113 
     114                        //      If has extension. 
     115                        if (ptr) 
     116                        { 
     117                                strcpy(file_name,ptr); 
     118                        } 
     119 
     120                        //      Adds mesh extension. 
     121                        strcat(file_name,".mesh"); 
     122 
     123                        //      If File Exists. 
     124                        if (fileExists(file_name)) 
     125                        { 
     126                                //      Compose message. 
     127                                strcpy(message,"Do you want to replace "); 
     128                                strcat(message,file_name); 
     129                                strcat(message,"?"); 
     130 
     131                                //      Question. 
     132                                answer_yes      =       fltk::ask(message); 
     133                        } 
     134 
     135                        //      If answer yes to replace question. 
     136                        //      or if file not exists. 
     137                        if (answer_yes) 
     138                        { 
     139                                mesh_saver      =       new     GeoMeshSaver(); 
     140 
     141 
     142                                mesh_saver->save(mGeoMesh,filename_name(file_name)); 
     143 
     144                                delete  mesh_saver; 
     145                        } 
    104146                } 
    105  
    106147                //      Repaint the window. 
    107148                mMainWindow->redraw(); 
     
    111152} 
    112153 
    113 void GeoMeshViewUI::cb_menuOpenSaveAs(fltk::Item* o, void* v) 
    114 { 
    115   ((GeoMeshViewUI*)     (o->parent()->parent()->parent()->user_data())) 
    116                                                                                 -> 
    117                                                                                 cb_menuOpenSaveAs_i(o,v); 
     154void GeoMeshViewUI::cb_menuFileSaveAs(fltk::Item* o, void* v) 
     155{ 
     156  ((GeoMeshViewUI*)     (o->parent()->parent()->parent()->user_data())) 
     157                                                                                -> 
     158                                                                                cb_menuFileSaveAs_i(o,v); 
    118159} 
    119160 
     
    210251//      Quit Callback 
    211252//--------------------------------------------------------------------------- 
    212 inline void GeoMeshViewUI::cb_menuOpenQuit_i(fltk::Item*, void*) 
     253inline void GeoMeshViewUI::cb_menuFileQuit_i(fltk::Item*, void*) 
    213254{ 
    214255        delete  this; 
    215256} 
    216257 
    217 void GeoMeshViewUI::cb_menuOpenQuit(fltk::Item* o, void* v) 
    218 { 
    219   ((GeoMeshViewUI*)     (o->parent()->parent()->parent()->user_data())) 
    220                                                                                 -> 
    221                                                                                 cb_menuOpenQuit_i(o,v); 
     258void GeoMeshViewUI::cb_menuFileQuit(fltk::Item* o, void* v) 
     259{ 
     260  ((GeoMeshViewUI*)     (o->parent()->parent()->parent()->user_data())) 
     261                                                                                -> 
     262                                                                                cb_menuFileQuit_i(o,v); 
    222263} 
    223264 
     
    710751        openMeshFile(); 
    711752         
    712         //      Show title. 
    713         mProcessTitle->label("Visualize LodStrips"); 
    714753 
    715754        //      If an object is loaded. 
     
    735774                //      Free memory. 
    736775                delete  fcho; 
    737         } 
    738776 
    739777        //      Hide the right panel. 
    740778        hideRightPanel(); 
    741779 
     780        //      Show title. 
     781        mProcessTitle->label("Visualize LodStrips"); 
     782 
    742783        //      Show the Visulize LodStrips panel. 
    743784        showLodStripSlider(); 
     
    745786        //      Repaint the window. 
    746787        mMainWindow->redraw(); 
    747 } 
    748  
     788 
     789        } 
     790} 
    749791 
    750792inline void GeoMeshViewUI::cb_menuLodTreesVisualize_i(fltk::Item*, void*) 
     
    752794        fltk::FileChooser *fcho; 
    753795        const   char                            *lod_file; 
    754          
     796 
    755797        //      Sets menus application state to NONE. 
    756798        mApplicationState       =       NONE; 
     
    762804        //      Loads a mesh file. 
    763805        openMeshFile(); 
    764          
    765         //      Show title. 
    766         mProcessTitle->label("Visualize LodTrees"); 
    767806 
    768807        /*if (geoMeshView->getLeavesSubmesh()==-1) 
    769         { 
     808                { 
    770809                fltk::alert("No se ha seleccionado el submesh de hojas!"); 
    771810                return; 
    772         }*/ 
    773  
    774         // POR AHORA SE SELECCIONA EL PRIMER SUBMESH QUE NO ES STRIPS COMO HOJAS 
    775         int leafsSubMeshID = -1; 
    776         for (int i=0; i<mGeoMesh->mSubMeshCount; i++) 
    777                 if (mGeoMesh->mSubMesh[i].mType==GEO_TRIANGLE_LIST) 
    778                 { 
    779                         leafsSubMeshID=i; 
    780                         break; 
    781                 } 
    782  
    783  
     811                }*/ 
    784812 
    785813        //      If an object is loaded. 
    786814        if (mGeoMesh != NULL) 
    787815        { 
    788                 fcho    =       new fltk::FileChooser("", 
    789                                 "*.lod", 
    790                                 fltk::FileChooser::CREATE, 
    791                                 "Open Lod file"); 
    792  
    793                 fcho->exec(); 
    794  
    795                 //      If a file was selected. 
    796                 if (fcho->value()) 
     816                // POR AHORA SE SELECCIONA EL PRIMER SUBMESH QUE NO ES STRIPS COMO HOJAS 
     817                int leafsSubMeshID = -1; 
     818 
     819                for (int i=0; i<mGeoMesh->mSubMeshCount; i++) 
    797820                { 
    798                         //      Build lod strips library. 
    799  
    800                         std::string lodstripFile(fcho->value()); 
    801                         delete fcho; 
     821                        if (mGeoMesh->mSubMesh[i].mType==GEO_TRIANGLE_LIST) 
     822                        { 
     823                                leafsSubMeshID=i; 
     824                                break; 
     825                        } 
     826                } 
     827 
     828                //      If an object is loaded. 
     829                if (mGeoMesh != NULL) 
     830                { 
    802831                        fcho    =       new fltk::FileChooser("", 
    803                                         "*.leafseq", 
     832                                        "*.lod", 
    804833                                        fltk::FileChooser::CREATE, 
    805                                         "Open LeafSeq file"); 
     834                                        "Open Lod file"); 
    806835 
    807836                        fcho->exec(); 
    808837 
     838                        //      If a file was selected. 
    809839                        if (fcho->value()) 
    810840                        { 
    811                                 std::string leafseqFile(fcho->value()); 
    812  
    813                                 setLodTreesLibrary(lodstripFile, leafseqFile, mGeoMesh, leafsSubMeshID); 
    814  
    815                                 //      Sets the aplication mode. 
    816                                 mApplicationState       =       VISUALIZE_LODTREES; 
     841                                //      Build lod strips library. 
     842 
     843                                std::string lodstripFile(fcho->value()); 
     844                                delete fcho; 
     845                                fcho    =       new fltk::FileChooser("", 
     846                                                "*.leafseq", 
     847                                                fltk::FileChooser::CREATE, 
     848                                                "Open LeafSeq file"); 
     849 
     850                                fcho->exec(); 
     851 
     852                                if (fcho->value()) 
     853                                { 
     854                                        std::string leafseqFile(fcho->value()); 
     855 
     856                                        setLodTreesLibrary(lodstripFile, leafseqFile, mGeoMesh, leafsSubMeshID); 
     857 
     858                                        //      Sets the aplication mode. 
     859                                        mApplicationState       =       VISUALIZE_LODTREES; 
     860                                } 
    817861                        } 
     862 
     863                        //      Free memory. 
     864                        delete  fcho; 
     865 
     866                        //      Hide the right panel. 
     867                        hideRightPanel(); 
     868 
     869                        //      Show title. 
     870                        mProcessTitle->label("Visualize LodTrees"); 
     871 
     872                        //      Show the Visulize LodTree panel. 
     873                        showLodStripSlider(); 
     874                        showLodTreeSlider(); 
     875 
     876                        //      Repaint the window. 
     877                        mMainWindow->redraw(); 
    818878                } 
    819  
    820                 //      Free memory. 
    821                 delete  fcho; 
    822         } 
    823  
    824         //      Hide the right panel. 
    825         hideRightPanel(); 
    826  
    827         //      Show the Visulize LodTree panel. 
    828         showLodStripSlider(); 
    829         showLodTreeSlider(); 
    830          
    831         //      Repaint the window. 
    832         mMainWindow->redraw(); 
    833 } 
     879        } 
     880} 
     881 
    834882void GeoMeshViewUI::cb_menuLodTreesVisualize(fltk::Item *o, void *v) 
    835883{ 
     
    10091057                                                //      Create the simplification sequence. 
    10101058                                                createSimplificationSequence(); 
     1059 
     1060                                                //      Show build process. 
     1061                                                activeBuildProcess(); 
    10111062                                        } 
    10121063 
     
    10541105                                                delete  mMeshSimplifier; 
    10551106                                                geoMeshView->restoreContext(); 
     1107 
     1108                                                //      Show build process. 
     1109                                                activeBuildProcess(); 
    10561110                                        } 
    10571111                                } 
     
    11071161inline void GeoMeshViewUI::cb_mButtonBuild_i(fltk::Button*, void*) 
    11081162{ 
    1109         char                    *file_name=NULL; 
     1163        char                                    *file_name      =       NULL; 
    11101164        GeoMeshSaver    *mesh_saver; 
    11111165        Serializer              *oSerializer; 
    1112          
     1166 
    11131167        //      Sets the progress bar to process bar. 
    11141168        progressBarType =       BUILD; 
     
    11251179                        //      Build the LOD file. 
    11261180                        case    LODTREES_AUTO:                   
    1127                                  
     1181 
    11281182                                //      Open file chooser dialog. 
    11291183                                file_name       =       fltk::file_chooser("Build LOD","*",""); 
     
    11351189                                std::cout << "OK!" << std::endl; 
    11361190 
    1137 /*                              TreeSimplificationSequence * auxTreeSimpSequence = new TreeSimplificationSequence(); 
    1138                                 auxTreeSimpSequence->Load(Serializer("leavesSimplification.txt",Serializer::READ)); 
    1139  
    1140                                 if (auxTreeSimpSequence && mGeoMesh) 
    1141                                 { 
    1142                                         LodTreeConstructor * auxLodTreeConstructor = new LodTreeConstructor(mGeoMesh,auxTreeSimpSequence); 
    1143                                         delete auxLodTreeConstructor; 
    1144                                 } 
    1145                                 else 
    1146                                 { 
    1147                                         fltk::alert("There is no leaf simplification sequence."); 
    1148                                         break; 
    1149                                 } 
    1150  
    1151  
    1152                                 delete auxTreeSimpSequence;*/ 
    1153                                  
     1191                                /*                              TreeSimplificationSequence * auxTreeSimpSequence = new TreeSimplificationSequence(); 
     1192                                                                        auxTreeSimpSequence->Load(Serializer("leavesSimplification.txt",Serializer::READ)); 
     1193 
     1194                                                                        if (auxTreeSimpSequence && mGeoMesh) 
     1195                                                                        { 
     1196                                                                        LodTreeConstructor * auxLodTreeConstructor = new LodTreeConstructor(mGeoMesh,auxTreeSimpSequence); 
     1197                                                                        delete auxLodTreeConstructor; 
     1198                                                                        } 
     1199                                                                        else 
     1200                                                                        { 
     1201                                                                        fltk::alert("There is no leaf simplification sequence."); 
     1202                                                                        break; 
     1203                                                                        } 
     1204 
     1205 
     1206                                                                        delete auxTreeSimpSequence;*/ 
     1207 
    11541208 
    11551209                        case    LODSTRIPS_AUTO: 
     
    13091363 
    13101364//--------------------------------------------------------------------------- 
     1365//      Active Build process. 
     1366//--------------------------------------------------------------------------- 
     1367void    GeoMeshViewUI::activeBuildProcess() 
     1368{ 
     1369        //mButtonBuild->set_visible(); 
     1370        mButtonBuild->activate(); 
     1371 
     1372        //mBuildBar->set_visible(); 
     1373        mBuildBar->activate(); 
     1374} 
     1375 
     1376//--------------------------------------------------------------------------- 
    13111377//      Show the stripify panel 
    13121378//--------------------------------------------------------------------------- 
     
    15721638 
    15731639        mButtonBuild->set_visible(); 
    1574         mButtonBuild->activate(); 
     1640        //mButtonBuild->activate(); 
    15751641 
    15761642        mBuildBar->set_visible(); 
    1577         mBuildBar->activate(); 
     1643        //mBuildBar->activate(); 
    15781644} 
    15791645//--------------------------------------------------------------------------- 
     
    15861652 
    15871653        mButtonBuild->set_visible(); 
    1588         mButtonBuild->activate(); 
     1654        //mButtonBuild->activate(); 
    15891655 
    15901656        mBuildBar->set_visible(); 
    1591         mBuildBar->activate(); 
     1657        //mBuildBar->activate(); 
    15921658} 
    15931659 
     
    23102376void    GeoMeshViewUI::openMeshFile() 
    23112377{ 
     2378        Mesh                                                    *mesh_loaded; 
    23122379        fltk::FileChooser       *fcho; 
    23132380        static  char                    char_value[10]; 
    23142381        static  char                    title[256]; 
    2315  
     2382         
    23162383        fcho    =       new fltk::FileChooser("", 
    23172384                                                                                                                                "*.mesh", 
     
    23262393        if (mFileName) 
    23272394        { 
    2328                 //      Set Window Title. 
    2329                 strcpy(title,mFileName); 
    2330                 mMainWindow->label(strcat(title," - GeoTool")); 
    2331  
    2332                 //      Identify the mesh that stores the leaves 
    2333                 idMeshLeaves    =       -1; 
    2334  
    2335                 //      Stores the name of the mesh. 
    2336                 nombremesh      =       new char[255]; 
    2337                 strcpy(nombremesh,mFileName); 
    2338  
    2339                 //      Delete  the current mesh. 
    2340                 delete  mGeoMesh; 
    2341                 delete  mUndoMesh; 
    2342  
    23432395                //      Loads a new mesh. 
    2344                 mGeoMesh                =       geoMeshLoader->load(mFileName); 
    2345  
    2346                 //      Reset the undo mesh. 
    2347                 mUndoMesh               =       new Mesh(); 
    2348                 *mUndoMesh      =       *mGeoMesh; 
    2349  
    2350                 //      Translate the MB count to a char value. 
    2351                 sprintf(char_value, 
    2352                                 "MB %.3f", 
    2353                                 (float)geoMeshLoader->getFileSize()/1024/1024); 
    2354  
    2355                 mMB->label(char_value); 
    2356  
    2357                 //      Visualize mesh. 
    2358                 geoMeshView->setMesh(mGeoMesh); 
    2359  
    2360                 //      Hide right panel. 
    2361                 hideRightPanel(); 
    2362  
    2363                 //      Quit culling. 
    2364                 menuRenderCW->clear_value(); 
    2365                 menuRenderCCW->clear_value(); 
    2366                 geoMeshView->deactiveCW(); 
    2367                 geoMeshView->deactiveCCW(); 
    2368  
    2369                 //      Deactive solid mode and wire. 
    2370                 menuRenderSolid->clear_value(); 
    2371                 menuRenderWire->clear_value(); 
    2372                 geoMeshView->deactiveSolid(); 
    2373                 geoMeshView->deactiveWire(); 
    2374  
    2375                 //      Fit model in midle. 
    2376                 geoMeshView->fit(); 
    2377  
    2378                 //      Lighting smooth. 
    2379                 menuRenderFlat->clear_value(); 
    2380                 menuRenderSmooth->set_value(); 
    2381                 geoMeshView->smooth(); 
    2382  
    2383                 //      Show title. 
    2384                 mProcessTitle->label("Mesh Info"); 
    2385  
    2386                 //      Shows the mesh info. 
    2387                 showMeshInfo(); 
    2388  
    2389                 //      if the mesh is stripified. 
    2390                 geoMeshView->setStripColors(); 
    2391  
    2392                 //      Refresh geometry attributes. 
    2393                 refreshApplicationBar(); 
    2394         } 
    2395          
     2396                mesh_loaded             =       geoMeshLoader->load(mFileName); 
     2397 
     2398                //      If no error happens. 
     2399                if (mesh_loaded) 
     2400                { 
     2401                        //      Identify the mesh that stores the leaves 
     2402                        idMeshLeaves    =       -1; 
     2403 
     2404                        //      Delete  the current mesh. 
     2405                        delete  mGeoMesh; 
     2406                        delete  mUndoMesh; 
     2407 
     2408                        //      Assigns mesh loaded. 
     2409                        mGeoMesh        =       mesh_loaded; 
     2410                         
     2411                        //      Set Window Title. 
     2412                        strcpy(title,mFileName); 
     2413                        mMainWindow->label(strcat(title," - GeoTool")); 
     2414 
     2415                        //      Stores the name of the mesh. 
     2416                        nombremesh      =       new char[255]; 
     2417                        strcpy(nombremesh,mFileName); 
     2418 
     2419                        //      Reset the undo mesh. 
     2420                        mUndoMesh               =       new Mesh(); 
     2421                        *mUndoMesh      =       *mGeoMesh; 
     2422 
     2423                        //      Translate the MB count to a char value. 
     2424                        sprintf(char_value, 
     2425                                        "MB %.3f", 
     2426                                        (float)geoMeshLoader->getFileSize()/1024/1024); 
     2427 
     2428                        mMB->label(char_value); 
     2429 
     2430                        //      Visualize mesh. 
     2431                        geoMeshView->setMesh(mGeoMesh); 
     2432 
     2433                        //      Hide right panel. 
     2434                        hideRightPanel(); 
     2435 
     2436                        //      Quit culling. 
     2437                        menuRenderCW->clear_value(); 
     2438                        menuRenderCCW->clear_value(); 
     2439                        geoMeshView->deactiveCW(); 
     2440                        geoMeshView->deactiveCCW(); 
     2441 
     2442                        //      Deactive solid mode and wire. 
     2443                        menuRenderSolid->clear_value(); 
     2444                        menuRenderWire->clear_value(); 
     2445                        geoMeshView->deactiveSolid(); 
     2446                        geoMeshView->deactiveWire(); 
     2447 
     2448                        //      Fit model in midle. 
     2449                        geoMeshView->fit(); 
     2450 
     2451                        //      Lighting smooth. 
     2452                        menuRenderFlat->clear_value(); 
     2453                        menuRenderSmooth->set_value(); 
     2454                        geoMeshView->smooth(); 
     2455 
     2456                        //      Show title. 
     2457                        mProcessTitle->label("Mesh Info"); 
     2458 
     2459                        //      Shows the mesh info. 
     2460                        showMeshInfo(); 
     2461 
     2462                        //      if the mesh is stripified. 
     2463                        geoMeshView->setStripColors(); 
     2464 
     2465                        //      Refresh geometry attributes. 
     2466                        refreshApplicationBar(); 
     2467 
     2468                        //      Restore simplification state. 
     2469                        simplificationState     =       NO_SIMPLIFICATION; 
     2470                } 
     2471        } 
    23962472        //      Free memory. 
    23972473        delete  fcho; 
     2474} 
     2475 
     2476//--------------------------------------------------------------------------- 
     2477//      If file exists. 
     2478//--------------------------------------------------------------------------- 
     2479bool    GeoMeshViewUI::fileExists(const char    *fileNameMesh) 
     2480{ 
     2481        FILE    *pFile; 
     2482         
     2483        //      Open the mesh file. 
     2484        pFile   =       fopen(fileNameMesh, "r"); 
     2485 
     2486  if (pFile) 
     2487        { 
     2488                return  true; 
     2489        } 
     2490        else 
     2491        { 
     2492                return  false; 
     2493        } 
    23982494} 
    23992495 
     
    24472543                        { 
    24482544                                fltk::Group* o; 
    2449                                 o = MainView = new fltk::Group(0, 0, 500, 530); 
     2545                                o = MainView = new fltk::Group(0, 0, 570, 530); 
    24502546                                o->begin(); 
    24512547 
    24522548                                { 
    24532549                                        fltk::InvisibleBox* o; 
    2454                                         o = cframe = new fltk::InvisibleBox(0, 0, 500, 530); 
     2550                                        o = cframe = new fltk::InvisibleBox(0, 0, 570, 530); 
    24552551                                        o->box(fltk::FLAT_BOX); 
    24562552                                        o->color((fltk::Color)0xffffff00); 
     
    24602556                                { 
    24612557                                        GeoMeshView* o; 
    2462                                         o = geoMeshView = new GeoMeshView(      0,0,500,530,0,this); 
     2558                                        o = geoMeshView = new GeoMeshView(      0,0,570,530,0,this); 
    24632559                                } 
    24642560 
     
    24712567                        { 
    24722568                                fltk::Group* o; 
    2473                                 o = MainView = new fltk::Group(500, 0, 300, 530); 
     2569                                o = MainView = new fltk::Group(570, 0, 230, 530); 
    24742570                                o->begin(); 
    24752571 
     
    24772573                                        fltk::Button* o; 
    24782574                                        //o = mButtonProcess = new fltk::Button(665, 410, 73, 25, "Process"); 
    2479                                         o = mButtonProcess = new fltk::Button(65, 410, 73, 25, "Process"); 
     2575                                        o = mButtonProcess = new fltk::Button(75, 410, 73, 25, "Process"); 
    24802576                                        o->callback((fltk::Callback*)cb_mButtonProcess); 
    24812577                                        o->hide(); 
     
    24862582                                        fltk::ProgressBar* o; 
    24872583                                        //o = mProcessBar = new fltk::ProgressBar(616, 435, 175, 18); 
    2488                                         o = mProcessBar = new fltk::ProgressBar(16, 435, 175, 18); 
     2584                                        o = mProcessBar = new fltk::ProgressBar(16, 435, 195, 18); 
    24892585                                        o->hide(); 
    24902586                                        o->deactivate(); 
     
    24932589                                { 
    24942590                                        fltk::Button* o; 
    2495                                         o = mButtonSort = new fltk::Button(65, 375, 73, 25, "Sort"); 
     2591                                        o = mButtonSort = new fltk::Button(75, 375, 73, 25, "Sort"); 
    24962592                                        o->callback((fltk::Callback*)cb_mButtonSort); 
    24972593                                        o->hide(); 
     
    25012597                                { 
    25022598                                        fltk::ProgressBar* o; 
    2503                                         o = mSortBar = new fltk::ProgressBar(16, 390, 175, 18); 
     2599                                        o = mSortBar = new fltk::ProgressBar(16, 390, 195, 18); 
    25042600                                        o->hide(); 
    25052601                                        o->deactivate(); 
     
    25082604                                { 
    25092605                                        fltk::Button* o; 
    2510                                         o = mButtonBuild = new fltk::Button(65, 455, 73, 25, "Build"); 
     2606                                        o = mButtonBuild = new fltk::Button(75, 455, 73, 25, "Build"); 
    25112607                                        o->callback((fltk::Callback*)cb_mButtonBuild); 
    25122608                                        o->hide(); 
     
    25162612                                { 
    25172613                                        fltk::ProgressBar* o; 
    2518                                         o = mBuildBar = new fltk::ProgressBar(16, 480, 175, 18); 
     2614                                        o = mBuildBar = new fltk::ProgressBar(16, 480, 195, 18); 
    25192615                                        o->hide(); 
    25202616                                        o->deactivate(); 
     
    25642660 
    25652661                                { 
    2566                                         mProcessTitle           = new fltk::Widget(0, 0, 300, 25, ""); 
     2662                                        mProcessTitle           = new fltk::Widget(0, 0, 230, 25, ""); 
    25672663                                        fltk::Widget* o =       mProcessTitle; 
    25682664                                        o->set_vertical(); 
     
    26292725 
    26302726                                { 
    2631                                         fltk::Browser* o = mMeshInfo = new fltk::Browser(0, 20, 300, 380); 
     2727                                        fltk::Browser* o = mMeshInfo = new fltk::Browser(0, 20, 230, 380); 
    26322728                                        o->set_vertical(); 
    26332729                                        o->callback((fltk::Callback*)cb_mMeshInfo); 
     
    26612757 
    26622758                                { 
    2663                                         fltk::Item* o = menuOpenSaveAs = new fltk::Item("Save As"); 
    2664                                         o->callback((fltk::Callback*)cb_menuOpenSaveAs); 
     2759                                        fltk::Item* o = menuFileSaveAs = new fltk::Item("Save As"); 
     2760                                        o->callback((fltk::Callback*)cb_menuFileSaveAs); 
    26652761                                } 
    26662762 
     
    26762772 
    26772773                                { 
    2678                                         fltk::Item* o = menuOpenQuit = new fltk::Item("Quit"); 
    2679                                         o->callback((fltk::Callback*)cb_menuOpenQuit); 
     2774                                        fltk::Item* o = menuFileQuit = new fltk::Item("Quit"); 
     2775                                        o->callback((fltk::Callback*)cb_menuFileQuit); 
    26802776                                } 
    26812777 
Note: See TracChangeset for help on using the changeset viewer.