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 (!normals.empty()) {
 265             write_indice(fp, static_cast<T>(normals[i]));
 266         }
 267         if (!colors.empty()) {
 268             write_indice(fp, static_cast<T>(colors[i]));
 269         }
 270         if (!texCoords.empty()) {
 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
 427         return false;
 428     }
 429
 430     // read creation time
 431     unsigned int foo_calendar_time;
 432     sgReadUInt( fp, &foo_calendar_time );
 433
 434 #if 0
 435     time_t calendar_time = foo_calendar_time;
 436     // The following code has a global effect on the host application
 437     // and can screws up the time elsewhere.  It should be avoided
 438     // unless you need this for debugging in which case you should
 439     // disable it again once the debugging task is finished.
 440     struct tm *local_tm;
 441     local_tm = localtime( &calendar_time );
 442     char time_str[256];
 443     strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
 444     SG_LOG( SG_EVENT, SG_DEBUG, "File created on " << time_str);
 445 #endif
 446
 447     // read number of top level objects
 448     int nobjects;
 449     if ( version >= 10) { // version 10 extends everything to be 32-bit
 450         sgReadInt( fp, &nobjects );
 451     } else if ( version >= 7 ) {
 452         uint16_t v;
 453         sgReadUShort( fp, &v );
 454         nobjects = v;
 455     } else {
 456         int16_t v;
 457         sgReadShort( fp, &v );
 458         nobjects = v;
 459     }
 460
 461      //cout << "Total objects to read = " << nobjects << endl;
 462
 463     if ( sgReadError() ) {
 464         cout << "We detected an error while reading the file header" << endl;
 465         return false;
 466     }
 467
 468     // read in objects
 469     for ( i = 0; i < nobjects; ++i ) {
 470         // read object header
 471         char obj_type;
 472         uint32_t nproperties, nelements;
 473         sgReadChar( fp, &obj_type );
 474         if ( version >= 10 ) {
 475             sgReadUInt( fp, &nproperties );
 476             sgReadUInt( fp, &nelements );
 477         } else if ( version >= 7 ) {
 478             uint16_t v;
 479             sgReadUShort( fp, &v );
 480             nproperties = v;
 481             sgReadUShort( fp, &v );
 482             nelements = v;
 483         } else {
 484             int16_t v;
 485             sgReadShort( fp, &v );
 486             nproperties = v;
 487             sgReadShort( fp, &v );
 488             nelements = v;
 489         }
 490
 491          //cout << "object " << i << " = " << (int)obj_type << " props = "
 492          //     << nproperties << " elements = " << nelements << endl;
 493
 494         if ( obj_type == SG_BOUNDING_SPHERE ) {
 495             // read bounding sphere properties
 496             read_properties( fp, nproperties );
 497
 498             // read bounding sphere elements
 499             for ( j = 0; j < nelements; ++j ) {
 500                 sgReadUInt( fp, &nbytes );
 501                 buf.resize( nbytes );
 502                 buf.reset();
 503                 char *ptr = buf.get_ptr();
 504                 sgReadBytes( fp, nbytes, ptr );
 505                 gbs_center = buf.readVec3d();
 506                 gbs_radius = buf.readFloat();
 507             }
 508         } else if ( obj_type == SG_VERTEX_LIST ) {
 509             // read vertex list properties
 510             read_properties( fp, nproperties );
 511
 512             // read vertex list elements
 513             for ( j = 0; j < nelements; ++j ) {
 514                 sgReadUInt( fp, &nbytes );
 515                 buf.resize( nbytes );
 516                 buf.reset();
 517                 char *ptr = buf.get_ptr();
 518                 sgReadBytes( fp, nbytes, ptr );
 519                 int count = nbytes / (sizeof(float) * 3);
 520                 wgs84_nodes.reserve( count );
 521                 for ( k = 0; k < count; ++k ) {
 522                     SGVec3f v = buf.readVec3f();
 523                 // extend from float to double, hmmm
 524                     wgs84_nodes.push_back( SGVec3d(v[0], v[1], v[2]) );
 525                 }
 526             }
 527         } else if ( obj_type == SG_COLOR_LIST ) {
 528             // read color list properties
 529             read_properties( fp, nproperties );
 530
 531             // read color list elements
 532             for ( j = 0; j < nelements; ++j ) {
 533                 sgReadUInt( fp, &nbytes );
 534                 buf.resize( nbytes );
 535                 buf.reset();
 536                 char *ptr = buf.get_ptr();
 537                 sgReadBytes( fp, nbytes, ptr );
 538                 int count = nbytes / (sizeof(float) * 4);
 539                 colors.reserve(count);
 540                 for ( k = 0; k < count; ++k ) {
 541                     colors.push_back( buf.readVec4f() );
 542                 }
 543             }
 544         } else if ( obj_type == SG_NORMAL_LIST ) {
 545             // read normal list properties
 546             read_properties( fp, nproperties );
 547
 548             // read normal list elements
 549             for ( j = 0; j < nelements; ++j ) {
 550                 sgReadUInt( fp, &nbytes );
 551                 buf.resize( nbytes );
 552                 buf.reset();
 553                 unsigned char *ptr = (unsigned char *)(buf.get_ptr());
 554                 sgReadBytes( fp, nbytes, ptr );
 555                 int count = nbytes / 3;
 556                 normals.reserve( count );
 557
 558                 for ( k = 0; k < count; ++k ) {
 559                     SGVec3f normal( (ptr[0]) / 127.5 - 1.0,
 560                                     (ptr[1]) / 127.5 - 1.0,
 561                                     (ptr[2]) / 127.5 - 1.0);
 562                     normals.push_back(normalize(normal));
 563                     ptr += 3;
 564                 }
 565             }
 566         } else if ( obj_type == SG_TEXCOORD_LIST ) {
 567             // read texcoord list properties
 568             read_properties( fp, nproperties );
 569
 570             // read texcoord list elements
 571             for ( j = 0; j < nelements; ++j ) {
 572                 sgReadUInt( fp, &nbytes );
 573                 buf.resize( nbytes );
 574                 buf.reset();
 575                 char *ptr = buf.get_ptr();
 576                 sgReadBytes( fp, nbytes, ptr );
 577                 int count = nbytes / (sizeof(float) * 2);
 578                 texcoords.reserve(count);
 579                 for ( k = 0; k < count; ++k ) {
 580                     texcoords.push_back( buf.readVec2f() );
 581                 }
 582             }
 583         } else if ( obj_type == SG_POINTS ) {
 584             // read point elements
 585             read_object( fp, SG_POINTS, nproperties, nelements,
 586                          pts_v, pts_n, pts_c, pts_tc, pt_materials );
 587         } else if ( obj_type == SG_TRIANGLE_FACES ) {
 588             // read triangle face properties
 589             read_object( fp, SG_TRIANGLE_FACES, nproperties, nelements,
 590                          tris_v, tris_n, tris_c, tris_tc, tri_materials );
 591         } else if ( obj_type == SG_TRIANGLE_STRIPS ) {
 592             // read triangle strip properties
 593             read_object( fp, SG_TRIANGLE_STRIPS, nproperties, nelements,
 594                          strips_v, strips_n, strips_c, strips_tc,
 595                          strip_materials );
 596         } else if ( obj_type == SG_TRIANGLE_FANS ) {
 597             // read triangle fan properties
 598             read_object( fp, SG_TRIANGLE_FANS, nproperties, nelements,
 599                          fans_v, fans_n, fans_c, fans_tc, fan_materials );
 600         } else {
 601             // unknown object type, just skip
 602             read_properties( fp, nproperties );
 603
 604             // read elements
 605             for ( j = 0; j < nelements; ++j ) {
 606                 sgReadUInt( fp, &nbytes );
 607                 // cout << "element size = " << nbytes << endl;
 608                 if ( nbytes > buf.get_size() ) { buf.resize( nbytes ); }
 609                 char *ptr = buf.get_ptr();
 610                 sgReadBytes( fp, nbytes, ptr );
 611             }
 612         }
 613
 614         if ( sgReadError() ) {
 615             cout << "We detected an error while reading object:" << i << endl;
 616             return false;
 617         }
 618     }
 619
 620     // close the file
 621     gzclose(fp);
 622
 623     if ( sgReadError() ) {
 624         cout << "We detected an error while reading the file." << endl;
 625         return false;
 626     }
 627
 628     return true;
 629 }
 630
 631 void SGBinObject::write_header(gzFile fp, int type, int nProps, int nElements)
 632 {
 633     sgWriteChar(fp, (unsigned char) type);
 634     if (version == 7) {
 635         sgWriteUShort(fp, nProps);
 636         sgWriteUShort(fp, nElements);
 637     } else {
 638         sgWriteUInt(fp, nProps);
 639         sgWriteUInt(fp, nElements);
 640     }
 641 }
 642
 643 unsigned int SGBinObject::count_objects(const string_list& materials)
 644 {
 645     unsigned int result = 0;
 646     unsigned int start = 0, end = 1;
 647     unsigned int count = materials.size();
 648     string m;
 649
 650     while ( start < count ) {
 651         m = materials[start];
 652         for (end = start+1; (end < count) && (m == materials[end]); ++end) { }
 653         ++result;
 654         start = end;
 655     }
 656
 657     return result;
 658 }
 659
 660 void SGBinObject::write_objects(gzFile fp, int type, const group_list& verts,
 661     const group_list& normals, const group_list& colors,
 662     const group_list& texCoords, const string_list& materials)
 663 {
 664     if (verts.empty()) {
 665         return;
 666     }
 667
 668     unsigned int start = 0, end = 1;
 669     string m;
 670     while (start < materials.size()) {
 671         m = materials[start];
 672     // find range of objects with identical material, write out as a single object
 673         for (end = start+1; (end < materials.size()) && (m == materials[end]); ++end) {}
 674
 675         const int count = end - start;
 676         write_header(fp, type, 2, count);
 677
 678     // properties
 679         sgWriteChar( fp, (char)SG_MATERIAL );        // property
 680         sgWriteUInt( fp, m.length() );        // nbytes
 681         sgWriteBytes( fp, m.length(), m.c_str() );
 682
 683         unsigned char idx_mask = 0;
 684         if ( !verts.empty() && !verts.front().empty()) idx_mask |= SG_IDX_VERTICES;
 685         if ( !normals.empty() && !normals.front().empty()) idx_mask |= SG_IDX_NORMALS;
 686         if ( !colors.empty() && !colors.front().empty()) idx_mask |= SG_IDX_COLORS;
 687         if ( !texCoords.empty() && !texCoords.front().empty()) idx_mask |= SG_IDX_TEXCOORDS;
 688         sgWriteChar( fp, (char)SG_INDEX_TYPES );     // property
 689         sgWriteUInt( fp, 1 );                        // nbytes
 690         sgWriteChar( fp, idx_mask );
 691
 692 //        cout << "material:" << m << ", count =" << count << endl;
 693     // elements
 694         for (unsigned int i=start; i < end; ++i) {
 695             if (version == 7) {
 696                 write_indices<uint16_t>(fp, idx_mask, verts[i], normals[i], colors[i], texCoords[i]);
 697             } else {
 698                 write_indices<uint32_t>(fp, idx_mask, verts[i], normals[i], colors[i], texCoords[i]);
 699             }
 700         }
 701
 702         start = end;
 703     } // of materials iteration
 704 }
 705
 706 // write out the structures to a binary file.  We assume that the
 707 // groups come to us sorted by material property.  If not, things
 708 // don't break, but the result won't be as optimal.
 709 bool SGBinObject::write_bin( const string& base, const string& name,
 710                              const SGBucket& b )
 711 {
 712
 713     SGPath file = base + "/" + b.gen_base_path() + "/" + name + ".gz";
 714     return write_bin_file(file);
 715 }
 716
 717 bool SGBinObject::write_bin_file(const SGPath& file)
 718 {
 719     int i;
 720
 721     SGPath file2(file);
 722     file2.create_dir( 0755 );
 723     cout << "Output file = " << file.str() << endl;
 724
 725     gzFile fp;
 726     if ( (fp = gzopen( file.c_str(), "wb9" )) == NULL ) {
 727         cout << "ERROR: opening " << file.str() << " for writing!" << endl;
 728         return false;
 729     }
 730
 731     sgClearWriteError();
 732
 733     cout << "points size = " << pts_v.size() << "  pt_materials = "
 734          << pt_materials.size() << endl;
 735     cout << "triangles size = " << tris_v.size() << "  tri_materials = "
 736          << tri_materials.size() << endl;
 737     cout << "strips size = " << strips_v.size() << "  strip_materials = "
 738          << strip_materials.size() << endl;
 739     cout << "fans size = " << fans_v.size() << "  fan_materials = "
 740          << fan_materials.size() << endl;
 741
 742     cout << "nodes = " << wgs84_nodes.size() << endl;
 743     cout << "colors = " << colors.size() << endl;
 744     cout << "normals = " << normals.size() << endl;
 745     cout << "tex coords = " << texcoords.size() << endl;
 746
 747     version = 10;
 748     if (wgs84_nodes.size() < 0xffff) {
 749         version = 7; // use smaller indices if possible
 750     }
 751
 752     // write header magic
 753
 754     /** Magic Number for our file format */
 755     #define SG_FILE_MAGIC_NUMBER  ( ('S'<<24) + ('G'<<16) + version )
 756
 757     sgWriteUInt( fp, SG_FILE_MAGIC_NUMBER );
 758     time_t calendar_time = time(NULL);
 759     sgWriteLong( fp, (int32_t)calendar_time );
 760
 761     // calculate and write number of top level objects
 762     int nobjects = 5; // gbs, vertices, colors, normals, texcoords
 763     nobjects += count_objects(pt_materials);
 764     nobjects += count_objects(tri_materials);
 765     nobjects += count_objects(strip_materials);
 766     nobjects += count_objects(fan_materials);
 767
 768     cout << "total top level objects = " << nobjects << endl;
 769     if (version == 7) {
 770         sgWriteUShort( fp, (uint16_t) nobjects );
 771     } else {
 772         sgWriteInt( fp, nobjects );
 773     }
 774
 775     // write bounding sphere
 776     write_header( fp, SG_BOUNDING_SPHERE, 0, 1);
 777     sgWriteUInt( fp, sizeof(double) * 3 + sizeof(float) ); // nbytes
 778     sgWritedVec3( fp, gbs_center );
 779     sgWriteFloat( fp, gbs_radius );
 780
 781     // dump vertex list
 782     write_header( fp, SG_VERTEX_LIST, 0, 1);
 783     sgWriteUInt( fp, wgs84_nodes.size() * sizeof(float) * 3 ); // nbytes
 784     for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
 785         sgWriteVec3( fp, toVec3f(wgs84_nodes[i] - gbs_center));
 786     }
 787
 788     // dump vertex color list
 789     write_header( fp, SG_COLOR_LIST, 0, 1);
 790     sgWriteUInt( fp, colors.size() * sizeof(float) * 4 ); // nbytes
 791     for ( i = 0; i < (int)colors.size(); ++i ) {
 792       sgWriteVec4( fp, colors[i]);
 793     }
 794
 795     // dump vertex normal list
 796     write_header( fp, SG_NORMAL_LIST, 0, 1);
 797     sgWriteUInt( fp, normals.size() * 3 );              // nbytes
 798     char normal[3];
 799     for ( i = 0; i < (int)normals.size(); ++i ) {
 800         SGVec3f p = normals[i];
 801         normal[0] = (unsigned char)((p.x() + 1.0) * 127.5);
 802         normal[1] = (unsigned char)((p.y() + 1.0) * 127.5);
 803         normal[2] = (unsigned char)((p.z() + 1.0) * 127.5);
 804         sgWriteBytes( fp, 3, normal );
 805     }
 806
 807     // dump texture coordinates
 808     write_header( fp, SG_TEXCOORD_LIST, 0, 1);
 809     sgWriteUInt( fp, texcoords.size() * sizeof(float) * 2 ); // nbytes
 810     for ( i = 0; i < (int)texcoords.size(); ++i ) {
 811       sgWriteVec2( fp, texcoords[i]);
 812     }
 813
 814     write_objects(fp, SG_POINTS, pts_v, pts_n, pts_c, pts_tc, pt_materials);
 815     write_objects(fp, SG_TRIANGLE_FACES, tris_v, tris_n, tris_c, tris_tc, tri_materials);
 816     write_objects(fp, SG_TRIANGLE_STRIPS, strips_v, strips_n, strips_c, strips_tc, strip_materials);
 817     write_objects(fp, SG_TRIANGLE_FANS, fans_v, fans_n, fans_c, fans_tc, fan_materials);
 818
 819     // close the file
 820     gzclose(fp);
 821
 822     if ( sgWriteError() ) {
 823         cout << "We detected an error while writing the file." << endl;
 824         return false;
 825     }
 826
 827     return true;
 828 }
 829
 830
 831 // write out the structures to an ASCII file.  We assume that the
 832 // groups come to us sorted by material property.  If not, things
 833 // don't break, but the result won't be as optimal.
 834 bool SGBinObject::write_ascii( const string& base, const string& name,
 835                                const SGBucket& b )
 836 {
 837     int i, j;
 838
 839     SGPath file = base + "/" + b.gen_base_path() + "/" + name;
 840     file.create_dir( 0755 );
 841     cout << "Output file = " << file.str() << endl;
 842
 843     FILE *fp;
 844     if ( (fp = fopen( file.c_str(), "w" )) == NULL ) {
 845         cout << "ERROR: opening " << file.str() << " for writing!" << endl;
 846         return false;
 847     }
 848
 849     cout << "triangles size = " << tris_v.size() << "  tri_materials = "
 850          << tri_materials.size() << endl;
 851     cout << "strips size = " << strips_v.size() << "  strip_materials = "
 852          << strip_materials.size() << endl;
 853     cout << "fans size = " << fans_v.size() << "  fan_materials = "
 854          << fan_materials.size() << endl;
 855
 856     cout << "points = " << wgs84_nodes.size() << endl;
 857     cout << "tex coords = " << texcoords.size() << endl;
 858     // write headers
 859     fprintf(fp, "# FGFS Scenery\n");
 860     fprintf(fp, "# Version %s\n", SG_SCENERY_FILE_FORMAT);
 861
 862     time_t calendar_time = time(NULL);
 863     struct tm *local_tm;
 864     local_tm = localtime( &calendar_time );
 865     char time_str[256];
 866     strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
 867     fprintf(fp, "# Created %s\n", time_str );
 868     fprintf(fp, "\n");
 869
 870     // write bounding sphere
 871     fprintf(fp, "# gbs %.5f %.5f %.5f %.2f\n",
 872             gbs_center.x(), gbs_center.y(), gbs_center.z(), gbs_radius);
 873     fprintf(fp, "\n");
 874
 875     // dump vertex list
 876     fprintf(fp, "# vertex list\n");
 877     for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
 878         SGVec3d p = wgs84_nodes[i] - gbs_center;
 879
 880         fprintf(fp,  "v %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
 881     }
 882     fprintf(fp, "\n");
 883
 884     fprintf(fp, "# vertex normal list\n");
 885     for ( i = 0; i < (int)normals.size(); ++i ) {
 886         SGVec3f p = normals[i];
 887         fprintf(fp,  "vn %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
 888     }
 889     fprintf(fp, "\n");
 890
 891     // dump texture coordinates
 892     fprintf(fp, "# texture coordinate list\n");
 893     for ( i = 0; i < (int)texcoords.size(); ++i ) {
 894         SGVec2f p = texcoords[i];
 895         fprintf(fp,  "vt %.5f %.5f\n", p.x(), p.y() );
 896     }
 897     fprintf(fp, "\n");
 898
 899     // dump individual triangles if they exist
 900     if ( tris_v.size() > 0 ) {
 901         fprintf(fp, "# triangle groups\n");
 902
 903         int start = 0;
 904         int end = 1;
 905         string material;
 906         while ( start < (int)tri_materials.size() ) {
 907             // find next group
 908             material = tri_materials[start];
 909             while ( (end < (int)tri_materials.size()) &&
 910                     (material == tri_materials[end]) )
 911             {
 912                 // cout << "end = " << end << endl;
 913                 end++;
 914             }
 915             // cout << "group = " << start << " to " << end - 1 << endl;
 916
 917       SGSphered d;
 918       for ( i = start; i < end; ++i ) {
 919         for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 920           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
 921         }
 922       }
 923
 924       SGVec3d bs_center = d.getCenter();
 925       double bs_radius = d.getRadius();
 926
 927             // write group headers
 928             fprintf(fp, "\n");
 929             fprintf(fp, "# usemtl %s\n", material.c_str());
 930             fprintf(fp, "# bs %.4f %.4f %.4f %.2f\n",
 931                     bs_center.x(), bs_center.y(), bs_center.z(), bs_radius);
 932
 933             // write groups
 934             for ( i = start; i < end; ++i ) {
 935                 fprintf(fp, "f");
 936                 for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 937                     fprintf(fp, " %d/%d", tris_v[i][j], tris_tc[i][j] );
 938                 }
 939                 fprintf(fp, "\n");
 940             }
 941
 942             start = end;
 943             end = start + 1;
 944         }
 945     }
 946
 947     // dump triangle groups
 948     if ( strips_v.size() > 0 ) {
 949         fprintf(fp, "# triangle strips\n");
 950
 951         int start = 0;
 952         int end = 1;
 953         string material;
 954         while ( start < (int)strip_materials.size() ) {
 955             // find next group
 956             material = strip_materials[start];
 957             while ( (end < (int)strip_materials.size()) &&
 958                     (material == strip_materials[end]) )
 959                 {
 960                     // cout << "end = " << end << endl;
 961                     end++;
 962                 }
 963             // cout << "group = " << start << " to " << end - 1 << endl;
 964
 965
 966       SGSphered d;
 967       for ( i = start; i < end; ++i ) {
 968         for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 969           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
 970         }
 971       }
 972
 973       SGVec3d bs_center = d.getCenter();
 974       double bs_radius = d.getRadius();
 975
 976             // write group headers
 977             fprintf(fp, "\n");
 978             fprintf(fp, "# usemtl %s\n", material.c_str());
 979             fprintf(fp, "# bs %.4f %.4f %.4f %.2f\n",
 980                     bs_center.x(), bs_center.y(), bs_center.z(), bs_radius);
 981
 982             // write groups
 983             for ( i = start; i < end; ++i ) {
 984                 fprintf(fp, "ts");
 985                 for ( j = 0; j < (int)strips_v[i].size(); ++j ) {
 986                     fprintf(fp, " %d/%d", strips_v[i][j], strips_tc[i][j] );
 987                 }
 988                 fprintf(fp, "\n");
 989             }
 990
 991             start = end;
 992             end = start + 1;
 993         }
 994     }
 995
 996     // close the file
 997     fclose(fp);
 998
 999     string command = "gzip --force --best " + file.str();
1000     system(command.c_str());
1001
1002     return true;
1003 }
1004
1005 void SGBinObject::read_properties(gzFile fp, int nproperties)
1006 {
1007     sgSimpleBuffer buf;
1008     uint32_t nbytes;
1009
1010     // read properties
1011     for ( int j = 0; j < nproperties; ++j ) {
1012         char prop_type;
1013         sgReadChar( fp, &prop_type );
1014         sgReadUInt( fp, &nbytes );
1015         // cout << "property size = " << nbytes << endl;
1016         if ( nbytes > buf.get_size() ) { buf.resize( nbytes ); }
1017         char *ptr = buf.get_ptr();
1018         sgReadBytes( fp, nbytes, ptr );
1019     }
1020 }
1021