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
 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 << "Error while reading header of file " << file << "(.gz)" << 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 << "Error while reading object:" << i << " in file " << file << "(.gz)" << endl;
 616             return false;
 617         }
 618     }
 619
 620     // close the file
 621     gzclose(fp);
 622
 623     if ( sgReadError() ) {
 624         cout << "Error while reading file " << file << "(.gz)" << 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     int_list emptyList;
 671
 672     while (start < materials.size()) {
 673         m = materials[start];
 674     // find range of objects with identical material, write out as a single object
 675         for (end = start+1; (end < materials.size()) && (m == materials[end]); ++end) {}
 676
 677         const int count = end - start;
 678         write_header(fp, type, 2, count);
 679
 680     // properties
 681         sgWriteChar( fp, (char)SG_MATERIAL );        // property
 682         sgWriteUInt( fp, m.length() );        // nbytes
 683         sgWriteBytes( fp, m.length(), m.c_str() );
 684
 685         unsigned char idx_mask = 0;
 686         if ( !verts.empty() && !verts.front().empty()) idx_mask |= SG_IDX_VERTICES;
 687         if ( !normals.empty() && !normals.front().empty()) idx_mask |= SG_IDX_NORMALS;
 688         if ( !colors.empty() && !colors.front().empty()) idx_mask |= SG_IDX_COLORS;
 689         if ( !texCoords.empty() && !texCoords.front().empty()) idx_mask |= SG_IDX_TEXCOORDS;
 690         sgWriteChar( fp, (char)SG_INDEX_TYPES );     // property
 691         sgWriteUInt( fp, 1 );                        // nbytes
 692         sgWriteChar( fp, idx_mask );
 693
 694 //        cout << "material:" << m << ", count =" << count << endl;
 695     // elements
 696         for (unsigned int i=start; i < end; ++i) {
 697             const int_list& va(verts[i]);
 698             const int_list& na((idx_mask & SG_IDX_NORMALS) ? normals[i] : emptyList);
 699             const int_list& ca((idx_mask & SG_IDX_COLORS) ? colors[i] : emptyList);
 700             const int_list& tca((idx_mask & SG_IDX_TEXCOORDS) ? texCoords[i] : emptyList);
 701
 702             if (version == 7) {
 703                 write_indices<uint16_t>(fp, idx_mask, va, na, ca, tca);
 704             } else {
 705                 write_indices<uint32_t>(fp, idx_mask, va, na, ca, tca);
 706             }
 707         }
 708
 709         start = end;
 710     } // of materials iteration
 711 }
 712
 713 // write out the structures to a binary file.  We assume that the
 714 // groups come to us sorted by material property.  If not, things
 715 // don't break, but the result won't be as optimal.
 716 bool SGBinObject::write_bin( const string& base, const string& name,
 717                              const SGBucket& b )
 718 {
 719
 720     SGPath file = base + "/" + b.gen_base_path() + "/" + name + ".gz";
 721     return write_bin_file(file);
 722 }
 723
 724 bool SGBinObject::write_bin_file(const SGPath& file)
 725 {
 726     int i;
 727
 728     SGPath file2(file);
 729     file2.create_dir( 0755 );
 730     cout << "Output file = " << file.str() << endl;
 731
 732     gzFile fp;
 733     if ( (fp = gzopen( file.c_str(), "wb9" )) == NULL ) {
 734         cout << "ERROR: opening " << file.str() << " for writing!" << endl;
 735         return false;
 736     }
 737
 738     sgClearWriteError();
 739
 740     cout << "points size = " << pts_v.size() << "  pt_materials = "
 741          << pt_materials.size() << endl;
 742     cout << "triangles size = " << tris_v.size() << "  tri_materials = "
 743          << tri_materials.size() << endl;
 744     cout << "strips size = " << strips_v.size() << "  strip_materials = "
 745          << strip_materials.size() << endl;
 746     cout << "fans size = " << fans_v.size() << "  fan_materials = "
 747          << fan_materials.size() << endl;
 748
 749     cout << "nodes = " << wgs84_nodes.size() << endl;
 750     cout << "colors = " << colors.size() << endl;
 751     cout << "normals = " << normals.size() << endl;
 752     cout << "tex coords = " << texcoords.size() << endl;
 753
 754     version = 10;
 755     if ((wgs84_nodes.size() < 0xffff) &&
 756         (normals.size() < 0xffff) &&
 757         (texcoords.size() < 0xffff)) {
 758         version = 7; // use smaller indices if possible
 759     }
 760
 761     // write header magic
 762
 763     /** Magic Number for our file format */
 764     #define SG_FILE_MAGIC_NUMBER  ( ('S'<<24) + ('G'<<16) + version )
 765
 766     sgWriteUInt( fp, SG_FILE_MAGIC_NUMBER );
 767     time_t calendar_time = time(NULL);
 768     sgWriteLong( fp, (int32_t)calendar_time );
 769
 770     // calculate and write number of top level objects
 771     int nobjects = 5; // gbs, vertices, colors, normals, texcoords
 772     nobjects += count_objects(pt_materials);
 773     nobjects += count_objects(tri_materials);
 774     nobjects += count_objects(strip_materials);
 775     nobjects += count_objects(fan_materials);
 776
 777     cout << "total top level objects = " << nobjects << endl;
 778     if (version == 7) {
 779         sgWriteUShort( fp, (uint16_t) nobjects );
 780     } else {
 781         sgWriteInt( fp, nobjects );
 782     }
 783
 784     // write bounding sphere
 785     write_header( fp, SG_BOUNDING_SPHERE, 0, 1);
 786     sgWriteUInt( fp, sizeof(double) * 3 + sizeof(float) ); // nbytes
 787     sgWritedVec3( fp, gbs_center );
 788     sgWriteFloat( fp, gbs_radius );
 789
 790     // dump vertex list
 791     write_header( fp, SG_VERTEX_LIST, 0, 1);
 792     sgWriteUInt( fp, wgs84_nodes.size() * sizeof(float) * 3 ); // nbytes
 793     for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
 794         sgWriteVec3( fp, toVec3f(wgs84_nodes[i] - gbs_center));
 795     }
 796
 797     // dump vertex color list
 798     write_header( fp, SG_COLOR_LIST, 0, 1);
 799     sgWriteUInt( fp, colors.size() * sizeof(float) * 4 ); // nbytes
 800     for ( i = 0; i < (int)colors.size(); ++i ) {
 801       sgWriteVec4( fp, colors[i]);
 802     }
 803
 804     // dump vertex normal list
 805     write_header( fp, SG_NORMAL_LIST, 0, 1);
 806     sgWriteUInt( fp, normals.size() * 3 );              // nbytes
 807     char normal[3];
 808     for ( i = 0; i < (int)normals.size(); ++i ) {
 809         SGVec3f p = normals[i];
 810         normal[0] = (unsigned char)((p.x() + 1.0) * 127.5);
 811         normal[1] = (unsigned char)((p.y() + 1.0) * 127.5);
 812         normal[2] = (unsigned char)((p.z() + 1.0) * 127.5);
 813         sgWriteBytes( fp, 3, normal );
 814     }
 815
 816     // dump texture coordinates
 817     write_header( fp, SG_TEXCOORD_LIST, 0, 1);
 818     sgWriteUInt( fp, texcoords.size() * sizeof(float) * 2 ); // nbytes
 819     for ( i = 0; i < (int)texcoords.size(); ++i ) {
 820       sgWriteVec2( fp, texcoords[i]);
 821     }
 822
 823     write_objects(fp, SG_POINTS, pts_v, pts_n, pts_c, pts_tc, pt_materials);
 824     write_objects(fp, SG_TRIANGLE_FACES, tris_v, tris_n, tris_c, tris_tc, tri_materials);
 825     write_objects(fp, SG_TRIANGLE_STRIPS, strips_v, strips_n, strips_c, strips_tc, strip_materials);
 826     write_objects(fp, SG_TRIANGLE_FANS, fans_v, fans_n, fans_c, fans_tc, fan_materials);
 827
 828     // close the file
 829     gzclose(fp);
 830
 831     if ( sgWriteError() ) {
 832         cout << "Error while writing file " << file.str() << endl;
 833         return false;
 834     }
 835
 836     return true;
 837 }
 838
 839
 840 // write out the structures to an ASCII file.  We assume that the
 841 // groups come to us sorted by material property.  If not, things
 842 // don't break, but the result won't be as optimal.
 843 bool SGBinObject::write_ascii( const string& base, const string& name,
 844                                const SGBucket& b )
 845 {
 846     int i, j;
 847
 848     SGPath file = base + "/" + b.gen_base_path() + "/" + name;
 849     file.create_dir( 0755 );
 850     cout << "Output file = " << file.str() << endl;
 851
 852     FILE *fp;
 853     if ( (fp = fopen( file.c_str(), "w" )) == NULL ) {
 854         cout << "ERROR: opening " << file.str() << " for writing!" << endl;
 855         return false;
 856     }
 857
 858     cout << "triangles size = " << tris_v.size() << "  tri_materials = "
 859          << tri_materials.size() << endl;
 860     cout << "strips size = " << strips_v.size() << "  strip_materials = "
 861          << strip_materials.size() << endl;
 862     cout << "fans size = " << fans_v.size() << "  fan_materials = "
 863          << fan_materials.size() << endl;
 864
 865     cout << "points = " << wgs84_nodes.size() << endl;
 866     cout << "tex coords = " << texcoords.size() << endl;
 867     // write headers
 868     fprintf(fp, "# FGFS Scenery\n");
 869     fprintf(fp, "# Version %s\n", SG_SCENERY_FILE_FORMAT);
 870
 871     time_t calendar_time = time(NULL);
 872     struct tm *local_tm;
 873     local_tm = localtime( &calendar_time );
 874     char time_str[256];
 875     strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
 876     fprintf(fp, "# Created %s\n", time_str );
 877     fprintf(fp, "\n");
 878
 879     // write bounding sphere
 880     fprintf(fp, "# gbs %.5f %.5f %.5f %.2f\n",
 881             gbs_center.x(), gbs_center.y(), gbs_center.z(), gbs_radius);
 882     fprintf(fp, "\n");
 883
 884     // dump vertex list
 885     fprintf(fp, "# vertex list\n");
 886     for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
 887         SGVec3d p = wgs84_nodes[i] - gbs_center;
 888
 889         fprintf(fp,  "v %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
 890     }
 891     fprintf(fp, "\n");
 892
 893     fprintf(fp, "# vertex normal list\n");
 894     for ( i = 0; i < (int)normals.size(); ++i ) {
 895         SGVec3f p = normals[i];
 896         fprintf(fp,  "vn %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
 897     }
 898     fprintf(fp, "\n");
 899
 900     // dump texture coordinates
 901     fprintf(fp, "# texture coordinate list\n");
 902     for ( i = 0; i < (int)texcoords.size(); ++i ) {
 903         SGVec2f p = texcoords[i];
 904         fprintf(fp,  "vt %.5f %.5f\n", p.x(), p.y() );
 905     }
 906     fprintf(fp, "\n");
 907
 908     // dump individual triangles if they exist
 909     if ( tris_v.size() > 0 ) {
 910         fprintf(fp, "# triangle groups\n");
 911
 912         int start = 0;
 913         int end = 1;
 914         string material;
 915         while ( start < (int)tri_materials.size() ) {
 916             // find next group
 917             material = tri_materials[start];
 918             while ( (end < (int)tri_materials.size()) &&
 919                     (material == tri_materials[end]) )
 920             {
 921                 // cout << "end = " << end << endl;
 922                 end++;
 923             }
 924             // cout << "group = " << start << " to " << end - 1 << endl;
 925
 926       SGSphered d;
 927       for ( i = start; i < end; ++i ) {
 928         for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 929           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
 930         }
 931       }
 932
 933       SGVec3d bs_center = d.getCenter();
 934       double bs_radius = d.getRadius();
 935
 936             // write group headers
 937             fprintf(fp, "\n");
 938             fprintf(fp, "# usemtl %s\n", material.c_str());
 939             fprintf(fp, "# bs %.4f %.4f %.4f %.2f\n",
 940                     bs_center.x(), bs_center.y(), bs_center.z(), bs_radius);
 941
 942             // write groups
 943             for ( i = start; i < end; ++i ) {
 944                 fprintf(fp, "f");
 945                 for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 946                     fprintf(fp, " %d/%d", tris_v[i][j], tris_tc[i][j] );
 947                 }
 948                 fprintf(fp, "\n");
 949             }
 950
 951             start = end;
 952             end = start + 1;
 953         }
 954     }
 955
 956     // dump triangle groups
 957     if ( strips_v.size() > 0 ) {
 958         fprintf(fp, "# triangle strips\n");
 959
 960         int start = 0;
 961         int end = 1;
 962         string material;
 963         while ( start < (int)strip_materials.size() ) {
 964             // find next group
 965             material = strip_materials[start];
 966             while ( (end < (int)strip_materials.size()) &&
 967                     (material == strip_materials[end]) )
 968                 {
 969                     // cout << "end = " << end << endl;
 970                     end++;
 971                 }
 972             // cout << "group = " << start << " to " << end - 1 << endl;
 973
 974
 975       SGSphered d;
 976       for ( i = start; i < end; ++i ) {
 977         for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
 978           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
 979         }
 980       }
 981
 982       SGVec3d bs_center = d.getCenter();
 983       double bs_radius = d.getRadius();
 984
 985             // write group headers
 986             fprintf(fp, "\n");
 987             fprintf(fp, "# usemtl %s\n", material.c_str());
 988             fprintf(fp, "# bs %.4f %.4f %.4f %.2f\n",
 989                     bs_center.x(), bs_center.y(), bs_center.z(), bs_radius);
 990
 991             // write groups
 992             for ( i = start; i < end; ++i ) {
 993                 fprintf(fp, "ts");
 994                 for ( j = 0; j < (int)strips_v[i].size(); ++j ) {
 995                     fprintf(fp, " %d/%d", strips_v[i][j], strips_tc[i][j] );
 996                 }
 997                 fprintf(fp, "\n");
 998             }
 999
1000             start = end;
1001             end = start + 1;
1002         }
1003     }
1004
1005     // close the file
1006     fclose(fp);
1007
1008     string command = "gzip --force --best " + file.str();
1009     int err = system(command.c_str());
1010     if (err)
1011     {
1012         cout << "ERROR: gzip " << file.str() << " failed!" << endl;
1013     }
1014
1015     return (err == 0);
1016 }
1017
1018 void SGBinObject::read_properties(gzFile fp, int nproperties)
1019 {
1020     sgSimpleBuffer buf;
1021     uint32_t nbytes;
1022
1023     // read properties
1024     for ( int j = 0; j < nproperties; ++j ) {
1025         char prop_type;
1026         sgReadChar( fp, &prop_type );
1027         sgReadUInt( fp, &nbytes );
1028         // cout << "property size = " << nbytes << endl;
1029         if ( nbytes > buf.get_size() ) { buf.resize( nbytes ); }
1030         char *ptr = buf.get_ptr();
1031         sgReadBytes( fp, nbytes, ptr );
1032     }
1033 }
1034