simgear/io/sg_binobj.cxx

   1 // sg_binobj.cxx -- routines to read and write low level flightgear 3d objects
   2 //
   3 // Written by Curtis Olson, started January 2000.
   4 //
   5 // Copyright (C) 2000  Curtis L. Olson  - http://www.flightgear.org/~curt
   6 //
   7 // This program is free software; you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by
   9 // the Free Software Foundation; either version 2 of the License, or
  10 // (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 //
  21 // $Id$
  22 //
  23
  24
  25 #ifdef HAVE_CONFIG_H
  26 #  include <simgear_config.h>
  27 #endif
  28
  29 #include <simgear/compiler.h>
  30 #include <simgear/debug/logstream.hxx>
  31
  32 #include <stdio.h>
  33 #include <time.h>
  34 #include <cstring>
  35 #include <cstdlib> // for system()
  36 #include <cassert>
  37
  38 #include <vector>
  39 #include <string>
  40 #include <iostream>
  41 #include <bitset>
  42
  43 #include <simgear/bucket/newbucket.hxx>
  44 #include <simgear/misc/sg_path.hxx>
  45 #include <simgear/math/SGGeometry.hxx>
  46
  47 #include "lowlevel.hxx"
  48 #include "sg_binobj.hxx"
  49
  50
  51 using std::string;
  52 using std::vector;
  53 using std::cout;
  54 using std::endl;
  55
  56 enum sgObjectTypes {
  57     SG_BOUNDING_SPHERE = 0,
  58
  59     SG_VERTEX_LIST = 1,
  60     SG_COLOR_LIST = 4,
  61     SG_NORMAL_LIST = 2,
  62     SG_TEXCOORD_LIST = 3,
  63
  64     SG_POINTS = 9,
  65
  66     SG_TRIANGLE_FACES = 10,
  67     SG_TRIANGLE_STRIPS = 11,
  68     SG_TRIANGLE_FANS = 12
  69 };
  70
  71 enum sgIndexTypes {
  72     SG_IDX_VERTICES =  0x01,
  73     SG_IDX_NORMALS =   0x02,
  74     SG_IDX_COLORS =    0x04,
  75     SG_IDX_TEXCOORDS = 0x08
  76 };
  77
  78 enum sgPropertyTypes {
  79     SG_MATERIAL = 0,
  80     SG_INDEX_TYPES = 1
  81 };
  82
  83
  84 class sgSimpleBuffer {
  85
  86 private:
  87
  88     char *ptr;
  89     unsigned int size;
  90     size_t offset;
  91 public:
  92
  93     sgSimpleBuffer( unsigned int s = 0) :
  94         ptr(NULL),
  95         size(0),
  96         offset(0)
  97     {
  98         resize(s);
  99     }
 100
 101     ~sgSimpleBuffer()
 102     {
 103         delete [] ptr;
 104     }
 105
 106     unsigned int get_size() const { return size; }
 107     char *get_ptr() const { return ptr; }
 108
 109     void reset()
 110     {
 111         offset = 0;
 112     }
 113
 114     void resize( unsigned int s )
 115     {
 116         if ( s > size ) {
 117             if ( ptr != NULL ) {
 118                 delete [] ptr;
 119             }
 120
 121             if ( size == 0) {
 122                 size = 16;
 123             }
 124
 125             while ( size < s ) {
 126               size = size << 1;
 127             }
 128             ptr = new char[size];
 129         }
 130     }
 131
 132     SGVec3d readVec3d()
 133     {
 134         double* p = reinterpret_cast<double*>(ptr + offset);
 135
 136         if ( sgIsBigEndian() ) {
 137             sgEndianSwap((uint64_t *) p + 0);
 138             sgEndianSwap((uint64_t *) p + 1);
 139             sgEndianSwap((uint64_t *) p + 2);
 140         }
 141
 142         offset += 3 * sizeof(double);
 143         return SGVec3d(p);
 144     }
 145
 146     float readFloat()
 147     {
 148         float* p = reinterpret_cast<float*>(ptr + offset);
 149         if ( sgIsBigEndian() ) {
 150             sgEndianSwap((uint32_t *) p);
 151         }
 152
 153         offset += sizeof(float);
 154         return *p;
 155     }
 156
 157     SGVec2f readVec2f()
 158     {
 159         float* p = reinterpret_cast<float*>(ptr + offset);
 160
 161         if ( sgIsBigEndian() ) {
 162             sgEndianSwap((uint32_t *) p + 0);
 163             sgEndianSwap((uint32_t *) p + 1);
 164         }
 165
 166         offset += 2 * sizeof(float);
 167         return SGVec2f(p);
 168     }
 169
 170     SGVec3f readVec3f()
 171     {
 172         float* p = reinterpret_cast<float*>(ptr + offset);
 173
 174         if ( sgIsBigEndian() ) {
 175             sgEndianSwap((uint32_t *) p + 0);
 176             sgEndianSwap((uint32_t *) p + 1);
 177             sgEndianSwap((uint32_t *) p + 2);
 178         }
 179
 180         offset += 3 * sizeof(float);
 181         return SGVec3f(p);
 182     }
 183
 184     SGVec4f readVec4f()
 185     {
 186         float* p = reinterpret_cast<float*>(ptr + offset);
 187
 188         if ( sgIsBigEndian() ) {
 189             sgEndianSwap((uint32_t *) p + 0);
 190             sgEndianSwap((uint32_t *) p + 1);
 191             sgEndianSwap((uint32_t *) p + 2);
 192             sgEndianSwap((uint32_t *) p + 3);
 193         }
 194
 195         offset += 4 * sizeof(float);
 196         return SGVec4f(p);
 197     }
 198 };
 199
 200 template <class T>
 201 static void read_indices(char* buffer,
 202                          size_t bytes,
 203                          int indexMask,
 204                          int_list& vertices,
 205                          int_list& normals,
 206                          int_list& colors,
 207                          int_list& texCoords)
 208 {
 209     const int indexSize = sizeof(T) * std::bitset<32>(indexMask).count();
 210     const int count = bytes / indexSize;
 211
 212 // fix endian-ness of the whole lot, if required
 213     if (sgIsBigEndian()) {
 214         int indices = bytes / sizeof(T);
 215         T* src = reinterpret_cast<T*>(buffer);
 216         for (int i=0; i<indices; ++i) {
 217             sgEndianSwap(src++);
 218         }
 219     }
 220
 221     T* src = reinterpret_cast<T*>(buffer);
 222     for (int i=0; i<count; ++i) {
 223         if (indexMask & SG_IDX_VERTICES) vertices.push_back(*src++);
 224         if (indexMask & SG_IDX_NORMALS) normals.push_back(*src++);
 225         if (indexMask & SG_IDX_COLORS) colors.push_back(*src++);
 226         if (indexMask & SG_IDX_TEXCOORDS) texCoords.push_back(*src++);
 227     } // of elements in the index
 228 }
 229
 230 template <class T>
 231 void write_indice(gzFile fp, T value)
 232 {
 233     sgWriteBytes(fp, sizeof(T), &value);
 234 }
 235
 236 // specialize template to call endian-aware conversion methods
 237 template <>
 238 void write_indice(gzFile fp, uint16_t value)
 239 {
 240     sgWriteUShort(fp, value);
 241 }
 242
 243 template <>
 244 void write_indice(gzFile fp, uint32_t value)
 245 {
 246     sgWriteUInt(fp, value);
 247 }
 248
 249
 250 template <class T>
 251 void write_indices(gzFile fp, unsigned char indexMask,
 252     const int_list& vertices,
 253     const int_list& normals,
 254     const int_list& colors,
 255     const int_list& texCoords)
 256 {
 257     unsigned int count = vertices.size();
 258     const int indexSize = sizeof(T) * std::bitset<32>(indexMask).count();
 259     sgWriteUInt(fp, indexSize * count);
 260
 261     for (unsigned int i=0; i < count; ++i) {
 262         write_indice(fp, static_cast<T>(vertices[i]));
 263
 264         if (indexMask & SG_IDX_NORMALS) {
 265             write_indice(fp, static_cast<T>(normals[i]));
 266         }
 267         if (indexMask & SG_IDX_COLORS) {
 268             write_indice(fp, static_cast<T>(colors[i]));
 269         }
 270         if (indexMask & SG_IDX_TEXCOORDS) {
 271             write_indice(fp, static_cast<T>(texCoords[i]));
 272         }
 273     }
 274 }
 275
 276
 277 // read object properties
 278 void SGBinObject::read_object( gzFile fp,
 279                          int obj_type,
 280                          int nproperties,
 281                          int nelements,
 282                          group_list& vertices,
 283                           group_list& normals,
 284                           group_list& colors,
 285                           group_list& texCoords,
 286                           string_list& materials)
 287 {
 288     unsigned int nbytes;
 289     unsigned char idx_mask;
 290     int j;
 291     sgSimpleBuffer buf( 32768 );  // 32 Kb
 292     char material[256];
 293
 294     // default values
 295     if ( obj_type == SG_POINTS ) {
 296         idx_mask = SG_IDX_VERTICES;
 297     } else {
 298         idx_mask = (char)(SG_IDX_VERTICES | SG_IDX_TEXCOORDS);
 299     }
 300
 301     for ( j = 0; j < nproperties; ++j ) {
 302         char prop_type;
 303         sgReadChar( fp, &prop_type );
 304         sgReadUInt( fp, &nbytes );
 305         buf.resize(nbytes);
 306         char *ptr = buf.get_ptr();
 307         sgReadBytes( fp, nbytes, ptr );
 308         if ( prop_type == SG_MATERIAL ) {
 309             if (nbytes > 255) {
 310                 nbytes = 255;
 311             }
 312             strncpy( material, ptr, nbytes );
 313             material[nbytes] = '\0';
 314             // cout << "material type = " << material << endl;
 315         } else if ( prop_type == SG_INDEX_TYPES ) {
 316             idx_mask = ptr[0];
 317             //cout << std::hex << "index mask:" << idx_mask << std::dec << endl;
 318         }
 319     }
 320
 321     if ( sgReadError() ) {
 322         cout << "We detected an error reading object properties"  << endl;
 323         return;
 324     }
 325
 326     for ( j = 0; j < nelements; ++j ) {
 327         sgReadUInt( fp, &nbytes );
 328         if ( sgReadError() ) {
 329             cout << "We detected an error reading element size for :" << j << endl;
 330             return;
 331         }
 332
 333         buf.resize( nbytes );
 334         char *ptr = buf.get_ptr();
 335         sgReadBytes( fp, nbytes, ptr );
 336
 337         if ( sgReadError() ) {
 338             cout << "We detected an error reading object element:" << j << "bytes="<< nbytes  << endl;
 339             return;
 340         }
 341
 342         int_list vs;
 343         int_list ns;
 344         int_list cs;
 345         int_list tcs;
 346         if (version >= 10) {
 347             read_indices<uint32_t>(ptr, nbytes, idx_mask, vs, ns, cs, tcs);
 348         } else {
 349             read_indices<uint16_t>(ptr, nbytes, idx_mask, vs, ns, cs, tcs);
 350         }
 351
 352         vertices.push_back( vs );
 353         normals.push_back( ns );
 354         colors.push_back( cs );
 355         texCoords.push_back( tcs );
 356         materials.push_back( material );
 357     } // of element iteration
 358 }
 359
 360
 361 // read a binary file and populate the provided structures.
 362 bool SGBinObject::read_bin( const string& file ) {
 363     SGVec3d p;
 364     int i, k;
 365     size_t j;
 366     unsigned int nbytes;
 367     sgSimpleBuffer buf( 32768 );  // 32 Kb
 368
 369     // zero out structures
 370     gbs_center = SGVec3d(0, 0, 0);
 371     gbs_radius = 0.0;
 372
 373     wgs84_nodes.clear();
 374     normals.clear();
 375     texcoords.clear();
 376
 377     pts_v.clear();
 378     pts_n.clear();
 379     pts_c.clear();
 380     pts_tc.clear();
 381     pt_materials.clear();
 382
 383     tris_v.clear();
 384     tris_n.clear();
 385     tris_c.clear();
 386     tris_tc.clear();
 387     tri_materials.clear();
 388
 389     strips_v.clear();
 390     strips_n.clear();
 391     strips_c.clear();
 392     strips_tc.clear();
 393     strip_materials.clear();
 394
 395     fans_v.clear();
 396     fans_n.clear();
 397     fans_c.clear();
 398     fans_tc.clear();
 399     fan_materials.clear();
 400
 401     gzFile fp;
 402     if ( (fp = gzopen( file.c_str(), "rb" )) == NULL ) {
 403         string filegz = file + ".gz";
 404         if ( (fp = gzopen( filegz.c_str(), "rb" )) == NULL ) {
 405             SG_LOG( SG_EVENT, SG_ALERT,
 406                "ERROR: opening " << file << " or " << filegz << " for reading!");
 407
 408             return false;
 409         }
 410     }
 411
 412     sgClearReadError();
 413
 414     // read headers
 415     unsigned int header;
 416     sgReadUInt( fp, &header );
 417     if ( ((header & 0xFF000000) >> 24) == 'S' &&
 418          ((header & 0x00FF0000) >> 16) == 'G' ) {
 419         // cout << "Good header" << endl;
 420         // read file version
 421         version = (header & 0x0000FFFF);
 422         // cout << "File version = " << version << endl;
 423     } else {
 424         // close the file before we return
 425         gzclose(fp);
 426         SG_LOG( SG_EVENT, SG_ALERT,
 427            "ERROR: " << file << "has bad header");
 428         return false;
 429     }
 430
 431     // read creation time
 432     unsigned int foo_calendar_time;
 433     sgReadUInt( fp, &foo_calendar_time );
 434
 435 #if 0
 436     time_t calendar_time = foo_calendar_time;
 437     // The following code has a global effect on the host application
 438     // and can screws up the time elsewhere.  It should be avoided
 439     // unless you need this for debugging in which case you should
 440     // disable it again once the debugging task is finished.
 441     struct tm *local_tm;
 442     local_tm = localtime( &calendar_time );
 443     char time_str[256];
 444     strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
 445     SG_LOG( SG_EVENT, SG_DEBUG, "File created on " << time_str);
 446 #endif
 447
 448     // read number of top level objects
 449     int nobjects;
 450     if ( version >= 10) { // version 10 extends everything to be 32-bit
 451         sgReadInt( fp, &nobjects );
 452     } else if ( version >= 7 ) {
 453         uint16_t v;
 454         sgReadUShort( fp, &v );
 455         nobjects = v;
 456     } else {
 457         int16_t v;
 458         sgReadShort( fp, &v );
 459         nobjects = v;
 460     }
 461
 462      //cout << "Total objects to read = " << nobjects << endl;
 463
 464     if ( sgReadError() ) {
 465         cout << "Error while reading header of file " << file << "(.gz)" << endl;
 466         return false;
 467     }
 468
 469     // read in objects
 470     for ( i = 0; i < nobjects; ++i ) {
 471         // read object header
 472         char obj_type;
 473         uint32_t nproperties, nelements;
 474         sgReadChar( fp, &obj_type );
 475         if ( version >= 10 ) {
 476             sgReadUInt( fp, &nproperties );
 477             sgReadUInt( fp, &nelements );
 478         } else if ( version >= 7 ) {
 479             uint16_t v;
 480             sgReadUShort( fp, &v );
 481             nproperties = v;
 482             sgReadUShort( fp, &v );
 483             nelements = v;
 484         } else {
 485             int16_t v;
 486             sgReadShort( fp, &v );
 487             nproperties = v;
 488             sgReadShort( fp, &v );
 489             nelements = v;
 490         }
 491
 492          //cout << "object " << i << " = " << (int)obj_type << " props = "
 493          //     << nproperties << " elements = " << nelements << endl;
 494
 495         if ( obj_type == SG_BOUNDING_SPHERE ) {
 496             // read bounding sphere properties
 497             read_properties( fp, nproperties );
 498
 499             // read bounding sphere elements
 500             for ( j = 0; j < nelements; ++j ) {
 501                 sgReadUInt( fp, &nbytes );
 502                 buf.resize( nbytes );
 503                 buf.reset();
 504                 char *ptr = buf.get_ptr();
 505                 sgReadBytes( fp, nbytes, ptr );
 506                 gbs_center = buf.readVec3d();
 507                 gbs_radius = buf.readFloat();
 508             }
 509         } else if ( obj_type == SG_VERTEX_LIST ) {
 510             // read vertex list properties
 511             read_properties( fp, nproperties );
 512
 513             // read vertex list elements
 514             for ( j = 0; j < nelements; ++j ) {
 515                 sgReadUInt( fp, &nbytes );
 516                 buf.resize( nbytes );
 517                 buf.reset();
 518                 char *ptr = buf.get_ptr();
 519                 sgReadBytes( fp, nbytes, ptr );
 520                 int count = nbytes / (sizeof(float) * 3);
 521                 wgs84_nodes.reserve( count );
 522                 for ( k = 0; k < count; ++k ) {
 523                     SGVec3f v = buf.readVec3f();
 524                 // extend from float to double, hmmm
 525                     wgs84_nodes.push_back( SGVec3d(v[0], v[1], v[2]) );
 526                 }
 527             }
 528         } else if ( obj_type == SG_COLOR_LIST ) {
 529             // read color list properties
 530             read_properties( fp, nproperties );
 531
 532             // read color list elements
 533             for ( j = 0; j < nelements; ++j ) {
 534                 sgReadUInt( fp, &nbytes );
 535                 buf.resize( nbytes );
 536                 buf.reset();
 537                 char *ptr = buf.get_ptr();
 538                 sgReadBytes( fp, nbytes, ptr );
 539                 int count = nbytes / (sizeof(float) * 4);
 540                 colors.reserve(count);
 541                 for ( k = 0; k < count; ++k ) {
 542                     colors.push_back( buf.readVec4f() );
 543                 }
 544             }
 545         } else if ( obj_type == SG_NORMAL_LIST ) {
 546             // read normal list properties
 547             read_properties( fp, nproperties );
 548
 549             // read normal list elements
 550             for ( j = 0; j < nelements; ++j ) {
 551                 sgReadUInt( fp, &nbytes );
 552                 buf.resize( nbytes );
 553                 buf.reset();
 554                 unsigned char *ptr = (unsigned char *)(buf.get_ptr());
 555                 sgReadBytes( fp, nbytes, ptr );
 556                 int count = nbytes / 3;
 557                 normals.reserve( count );
 558
 559                 for ( k = 0; k < count; ++k ) {
 560                     SGVec3f normal( (ptr[0]) / 127.5 - 1.0,
 561                                     (ptr[1]) / 127.5 - 1.0,
 562                                     (ptr[2]) / 127.5 - 1.0);
 563                     normals.push_back(normalize(normal));
 564                     ptr += 3;
 565                 }
 566             }
 567         } else if ( obj_type == SG_TEXCOORD_LIST ) {
 568             // read texcoord list properties
 569             read_properties( fp, nproperties );
 570
 571             // read texcoord list elements
 572             for ( j = 0; j < nelements; ++j ) {
 573                 sgReadUInt( fp, &nbytes );
 574                 buf.resize( nbytes );
 575                 buf.reset();
 576                 char *ptr = buf.get_ptr();
 577                 sgReadBytes( fp, nbytes, ptr );
 578                 int count = nbytes / (sizeof(float) * 2);
 579                 texcoords.reserve(count);
 580                 for ( k = 0; k < count; ++k ) {
 581                     texcoords.push_back( buf.readVec2f() );
 582                 }
 583             }
 584         } else if ( obj_type == SG_POINTS ) {
 585             // read point elements
 586             read_object( fp, SG_POINTS, nproperties, nelements,
 587                          pts_v, pts_n, pts_c, pts_tc, pt_materials );
 588         } else if ( obj_type == SG_TRIANGLE_FACES ) {
 589             // read triangle face properties
 590             read_object( fp, SG_TRIANGLE_FACES, nproperties, nelements,
 591                          tris_v, tris_n, tris_c, tris_tc, tri_materials );
 592         } else if ( obj_type == SG_TRIANGLE_STRIPS ) {
 593             // read triangle strip properties
 594             read_object( fp, SG_TRIANGLE_STRIPS, nproperties, nelements,
 595                          strips_v, strips_n, strips_c, strips_tc,
 596                          strip_materials );
 597         } else if ( obj_type == SG_TRIANGLE_FANS ) {
 598             // read triangle fan properties
 599             read_object( fp, SG_TRIANGLE_FANS, nproperties, nelements,
 600                          fans_v, fans_n, fans_c, fans_tc, fan_materials );
 601         } else {
 602             // unknown object type, just skip
 603             read_properties( fp, nproperties );
 604
 605             // read elements
 606             for ( j = 0; j < nelements; ++j ) {
 607                 sgReadUInt( fp, &nbytes );
 608                 // cout << "element size = " << nbytes << endl;
 609                 if ( nbytes > buf.get_size() ) { buf.resize( nbytes ); }
 610                 char *ptr = buf.get_ptr();
 611                 sgReadBytes( fp, nbytes, ptr );
 612             }
 613         }
 614
 615         if ( sgReadError() ) {
 616             cout << "Error while reading object:" << i << " in file " << file << "(.gz)" << endl;
 617             return false;
 618         }
 619     }
 620
 621     // close the file
 622     gzclose(fp);
 623
 624     if ( sgReadError() ) {
 625         cout << "Error while reading file " << file << "(.gz)" << endl;
 626         return false;
 627     }
 628
 629     return true;
 630 }
 631
 632 void SGBinObject::write_header(gzFile fp, int type, int nProps, int nElements)
 633 {
 634     sgWriteChar(fp, (unsigned char) type);
 635     if (version == 7) {
 636         sgWriteUShort(fp, nProps);
 637         sgWriteUShort(fp, nElements);
 638     } else {
 639         sgWriteUInt(fp, nProps);
 640         sgWriteUInt(fp, nElements);
 641     }
 642 }
 643
 644 unsigned int SGBinObject::count_objects(const string_list& materials)
 645 {
 646     unsigned int result = 0;
 647     unsigned int start = 0, end = 1;
 648     unsigned int count = materials.size();
 649     string m;
 650
 651     while ( start < count ) {
 652         m = materials[start];
 653         for (end = start+1; (end < count) && (m == materials[end]); ++end) { }
 654         ++result;
 655         start = end;
 656     }
 657
 658     return result;
 659 }
 660
 661 void SGBinObject::write_objects(gzFile fp, int type, const group_list& verts,
 662     const group_list& normals, const group_list& colors,
 663     const group_list& texCoords, const string_list& materials)
 664 {
 665     if (verts.empty()) {
 666         return;
 667     }
 668
 669     unsigned int start = 0, end = 1;
 670     string m;
 671     int_list emptyList;
 672
 673     while (start < materials.size()) {
 674         m = materials[start];
 675     // find range of objects with identical material, write out as a single object
 676         for (end = start+1; (end < materials.size()) && (m == materials[end]); ++end) {}
 677
 678         const int count = end - start;
 679         write_header(fp, type, 2, count);
 680
 681     // properties
 682         sgWriteChar( fp, (char)SG_MATERIAL );        // property
 683         sgWriteUInt( fp, m.length() );        // nbytes
 684         sgWriteBytes( fp, m.length(), m.c_str() );
 685
 686         unsigned char idx_mask = 0;
 687         if ( !verts.empty() && !verts.front().empty()) idx_mask |= SG_IDX_VERTICES;
 688         if ( !normals.empty() && !normals.front().empty()) idx_mask |= SG_IDX_NORMALS;
 689         if ( !colors.empty() && !colors.front().empty()) idx_mask |= SG_IDX_COLORS;
 690         if ( !texCoords.empty() && !texCoords.front().empty()) idx_mask |= SG_IDX_TEXCOORDS;
 691         sgWriteChar( fp, (char)SG_INDEX_TYPES );     // property
 692         sgWriteUInt( fp, 1 );                        // nbytes
 693         sgWriteChar( fp, idx_mask );
 694
 695 //        cout << "material:" << m << ", count =" << count << endl;
 696     // elements
 697         for (unsigned int i=start; i < end; ++i) {
 698             const int_list& va(verts[i]);
 699             const int_list& na((idx_mask & SG_IDX_NORMALS) ? normals[i] : emptyList);
 700             const int_list& ca((idx_mask & SG_IDX_COLORS) ? colors[i] : emptyList);
 701             const int_list& tca((idx_mask & SG_IDX_TEXCOORDS) ? texCoords[i] : emptyList);
 702
 703             if (version == 7) {
 704                 write_indices<uint16_t>(fp, idx_mask, va, na, ca, tca);
 705             } else {
 706                 write_indices<uint32_t>(fp, idx_mask, va, na, ca, tca);
 707             }
 708         }
 709
 710         start = end;
 711     } // of materials iteration
 712 }
 713
 714 // write out the structures to a binary file.  We assume that the
 715 // groups come to us sorted by material property.  If not, things
 716 // don't break, but the result won't be as optimal.
 717 bool SGBinObject::write_bin( const string& base, const string& name,
 718                              const SGBucket& b )
 719 {
 720
 721     SGPath file = base + "/" + b.gen_base_path() + "/" + name + ".gz";
 722     return write_bin_file(file);
 723 }
 724
 725 bool SGBinObject::write_bin_file(const SGPath& file)
 726 {
 727     int i;
 728
 729     SGPath file2(file);
 730     file2.create_dir( 0755 );
 731     cout << "Output file = " << file.str() << endl;
 732
 733     gzFile fp;
 734     if ( (fp = gzopen( file.c_str(), "wb9" )) == NULL ) {
 735         cout << "ERROR: opening " << file.str() << " for writing!" << endl;
 736         return false;
 737     }
 738
 739     sgClearWriteError();
 740
 741     cout << "points size = " << pts_v.size() << "  pt_materials = "
 742          << pt_materials.size() << endl;
 743     cout << "triangles size = " << tris_v.size() << "  tri_materials = "
 744          << tri_materials.size() << endl;
 745     cout << "strips size = " << strips_v.size() << "  strip_materials = "
 746          << strip_materials.size() << endl;
 747     cout << "fans size = " << fans_v.size() << "  fan_materials = "
 748          << fan_materials.size() << endl;
 749
 750     cout << "nodes = " << wgs84_nodes.size() << endl;
 751     cout << "colors = " << colors.size() << endl;
 752     cout << "normals = " << normals.size() << endl;
 753     cout << "tex coords = " << texcoords.size() << endl;
 754
 755     version = 10;
 756     if ((wgs84_nodes.size() < 0xffff) &&
 757         (normals.size() < 0xffff) &&
 758         (texcoords.size() < 0xffff)) {
 759         version = 7; // use smaller indices if possible
 760     }
 761
 762     // write header magic
 763
 764     /** Magic Number for our file format */
 765     #define SG_FILE_MAGIC_NUMBER  ( ('S'<<24) + ('G'<<16) + version )
 766
 767     sgWriteUInt( fp, SG_FILE_MAGIC_NUMBER );
 768     time_t calendar_time = time(NULL);
 769     sgWriteLong( fp, (int32_t)calendar_time );
 770
 771     // calculate and write number of top level objects
 772     int nobjects = 5; // gbs, vertices, colors, normals, texcoords
 773     nobjects += count_objects(pt_materials);
 774     nobjects += count_objects(tri_materials);
 775     nobjects += count_objects(strip_materials);
 776     nobjects += count_objects(fan_materials);
 777
 778     cout << "total top level objects = " << nobjects << endl;
 779     if (version == 7) {
 780         sgWriteUShort( fp, (uint16_t) nobjects );
 781     } else {
 782         sgWriteInt( fp, nobjects );
 783     }
 784
 785     // write bounding sphere
 786     write_header( fp, SG_BOUNDING_SPHERE, 0, 1);
 787     sgWriteUInt( fp, sizeof(double) * 3 + sizeof(float) ); // nbytes
 788     sgWritedVec3( fp, gbs_center );
 789     sgWriteFloat( fp, gbs_radius );
 790
 791     // dump vertex list
 792     write_header( fp, SG_VERTEX_LIST, 0, 1);
 793     sgWriteUInt( fp, wgs84_nodes.size() * sizeof(float) * 3 ); // nbytes
 794     for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
 795         sgWriteVec3( fp, toVec3f(wgs84_nodes[i] - gbs_center));
 796     }
 797
 798     // dump vertex color list
 799     write_header( fp, SG_COLOR_LIST, 0, 1);
 800     sgWriteUInt( fp, colors.size() * sizeof(float) * 4 ); // nbytes
 801     for ( i = 0; i < (int)colors.size(); ++i ) {
 802       sgWriteVec4( fp, colors[i]);
 803     }
 804
 805     // dump vertex normal list
 806     write_header( fp, SG_NORMAL_LIST, 0, 1);
 807     sgWriteUInt( fp, normals.size() * 3 );              // nbytes
 808     char normal[3];
 809     for ( i = 0; i < (int)normals.size(); ++i ) {
 810         SGVec3f p = normals[i];
 811         normal[0] = (unsigned char)((p.x() + 1.0) * 127.5);
 812         normal[1] = (unsigned char)((p.y() + 1.0) * 127.5);
 813         normal[2] = (unsigned char)((p.z() + 1.0) * 127.5);
 814         sgWriteBytes( fp, 3, normal );
 815     }
 816
 817     // dump texture coordinates
 818     write_header( fp, SG_TEXCOORD_LIST, 0, 1);
 819     sgWriteUInt( fp, texcoords.size() * sizeof(float) * 2 ); // nbytes
 820     for ( i = 0; i < (int)texcoords.size(); ++i ) {
 821       sgWriteVec2( fp, texcoords[i]);
 822     }
 823
 824     write_objects(fp, SG_POINTS, pts_v, pts_n, pts_c, pts_tc, pt_materials);
 825     write_objects(fp, SG_TRIANGLE_FACES, tris_v, tris_n, tris_c, tris_tc, tri_materials);
 826     write_objects(fp, SG_TRIANGLE_STRIPS, strips_v, strips_n, strips_c, strips_tc, strip_materials);
 827     write_objects(fp, SG_TRIANGLE_FANS, fans_v, fans_n, fans_c, fans_tc, fan_materials);
 828
 829     // close the file
 830     gzclose(fp);
 831
 832     if ( sgWriteError() ) {
 833         cout << "Error while writing file " << file.str() << endl;
 834         return false;
 835     }
 836
 837     return true;
 838 }
 839
 840
 841 // write out the structures to an ASCII file.  We assume that the
 842 // groups come to us sorted by material property.  If not, things
 843 // don't break, but the result won't be as optimal.
 844 bool SGBinObject::write_ascii( const string& base, const string& name,
 845                                const SGBucket& b )
 846 {
 847     int i, j;
 848
 849     SGPath file = base + "/" + b.gen_base_path() + "/" + name;
 850     file.create_dir( 0755 );
 851     cout << "Output file = " << file.str() << endl;
 852
 853     FILE *fp;
 854     if ( (fp = fopen( file.c_str(), "w" )) == NULL ) {
 855         cout << "ERROR: opening " << file.str() << " for writing!" << endl;
 856         return false;
 857     }
 858
 859     cout << "triangles size = " << tris_v.size() << "  tri_materials = "
 860          << tri_materials.size() << endl;
 861     cout << "strips size = " << strips_v.size() << "  strip_materials = "
 862          << strip_materials.size() << endl;
 863     cout << "fans size = " << fans_v.size() << "  fan_materials = "
 864          << fan_materials.size() << endl;
 865
 866     cout << "points = " << wgs84_nodes.size() << endl;
 867     cout << "tex coords = " << texcoords.size() << endl;
 868     // write headers
 869     fprintf(fp, "# FGFS Scenery\n");
 870     fprintf(fp, "# Version %s\n", SG_SCENERY_FILE_FORMAT);
 871
 872     time_t calendar_time = time(NULL);
 873     struct tm *local_tm;
 874     local_tm = localtime( &calendar_time );
 875     char time_str[256];
 876     strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
 877     fprintf(fp, "# Created %s\n", time_str );
 878     fprintf(fp, "\n");
 879
 880     // write bounding sphere
 881     fprintf(fp, "# gbs %.5f %.5f %.5f %.2f\n",
 882             gbs_center.x(), gbs_center.y(), gbs_center.z(), gbs_radius);
 883     fprintf(fp, "\n");
 884
 885     // dump vertex list
 886     fprintf(fp, "# vertex list\n");
 887     for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
 888         SGVec3d p = wgs84_nodes[i] - gbs_center;
 889
 890         fprintf(fp,  "v %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
 891     }
 892     fprintf(fp, "\n");
 893
 894     fprintf(fp, "# vertex normal list\n");
 895     for ( i = 0; i < (int)normals.size(); ++i ) {
 896         SGVec3f p = normals[i];
 897         fprintf(fp,  "vn %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
 898     }
 899     fprintf(fp, "\n");
 900
 901     // dump texture coordinates
 902     fprintf(fp, "# texture coordinate list\n");
 903     for ( i = 0; i < (int)texcoords.size(); ++i ) {
 904         SGVec2f p = texcoords[i];
 905         fprintf(fp,  "vt %.5f %.5f\n", p.x(), p.y() );
 906     }
 907     fprintf(fp, "\n");
 908
 909     // dump individual triangles if they exist
 910     if ( tris_v.size() > 0 ) {
 911         fprintf(fp, "# triangle groups\n");
 912
 913         int start = 0;
 914         int end = 1;
 915         string material;
 916         while ( start < (int)tri_materials.size() ) {
 917             // find next group
 918             material = tri_materials[start];
 919             while ( (end < (int)tri_materials.size()) &&
 920                     (material == tri_materials[end]) )
 921             {
 922                 // cout << "end = " << end << endl;
 923                 end++;
 924             }
 925             // cout << "group = " << start << " to " << end - 1 << endl;
 926
 927       SGSphered d;
 928       for ( i = start; i < end; ++i ) {
 929         for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 930           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
 931         }
 932       }
 933
 934       SGVec3d bs_center = d.getCenter();
 935       double bs_radius = d.getRadius();
 936
 937             // write group headers
 938             fprintf(fp, "\n");
 939             fprintf(fp, "# usemtl %s\n", material.c_str());
 940             fprintf(fp, "# bs %.4f %.4f %.4f %.2f\n",
 941                     bs_center.x(), bs_center.y(), bs_center.z(), bs_radius);
 942
 943             // write groups
 944             for ( i = start; i < end; ++i ) {
 945                 fprintf(fp, "f");
 946                 for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 947                     fprintf(fp, " %d/%d", tris_v[i][j], tris_tc[i][j] );
 948                 }
 949                 fprintf(fp, "\n");
 950             }
 951
 952             start = end;
 953             end = start + 1;
 954         }
 955     }
 956
 957     // dump triangle groups
 958     if ( strips_v.size() > 0 ) {
 959         fprintf(fp, "# triangle strips\n");
 960
 961         int start = 0;
 962         int end = 1;
 963         string material;
 964         while ( start < (int)strip_materials.size() ) {
 965             // find next group
 966             material = strip_materials[start];
 967             while ( (end < (int)strip_materials.size()) &&
 968                     (material == strip_materials[end]) )
 969                 {
 970                     // cout << "end = " << end << endl;
 971                     end++;
 972                 }
 973             // cout << "group = " << start << " to " << end - 1 << endl;
 974
 975
 976       SGSphered d;
 977       for ( i = start; i < end; ++i ) {
 978         for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 979           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
 980         }
 981       }
 982
 983       SGVec3d bs_center = d.getCenter();
 984       double bs_radius = d.getRadius();
 985
 986             // write group headers
 987             fprintf(fp, "\n");
 988             fprintf(fp, "# usemtl %s\n", material.c_str());
 989             fprintf(fp, "# bs %.4f %.4f %.4f %.2f\n",
 990                     bs_center.x(), bs_center.y(), bs_center.z(), bs_radius);
 991
 992             // write groups
 993             for ( i = start; i < end; ++i ) {
 994                 fprintf(fp, "ts");
 995                 for ( j = 0; j < (int)strips_v[i].size(); ++j ) {
 996                     fprintf(fp, " %d/%d", strips_v[i][j], strips_tc[i][j] );
 997                 }
 998                 fprintf(fp, "\n");
 999             }
1000
1001             start = end;
1002             end = start + 1;
1003         }
1004     }
1005
1006     // close the file
1007     fclose(fp);
1008
1009     string command = "gzip --force --best " + file.str();
1010     int err = system(command.c_str());
1011     if (err)
1012     {
1013         cout << "ERROR: gzip " << file.str() << " failed!" << endl;
1014     }
1015
1016     return (err == 0);
1017 }
1018
1019 void SGBinObject::read_properties(gzFile fp, int nproperties)
1020 {
1021     sgSimpleBuffer buf;
1022     uint32_t nbytes;
1023
1024     // read properties
1025     for ( int j = 0; j < nproperties; ++j ) {
1026         char prop_type;
1027         sgReadChar( fp, &prop_type );
1028         sgReadUInt( fp, &nbytes );
1029         // cout << "property size = " << nbytes << endl;
1030         if ( nbytes > buf.get_size() ) { buf.resize( nbytes ); }
1031         char *ptr = buf.get_ptr();
1032         sgReadBytes( fp, nbytes, ptr );
1033     }
1034 }
1035