Show
Ignore:
Timestamp:
04/22/09 17:46:24 (5 years ago)
Author:
robert
Message:

From Neil Hughes, converted across to use istream for reading data from file to enable reading .3ds files over http (use OSG's libcurl plugin).

From Robert Osfield, ammendments of the above to better support reading of files from local directories.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgPlugins/3ds/file.cpp

    r9124 r10076  
    3838#endif 
    3939 
    40 #include <osgDB/FileUtils> 
    41  
     40#include <istream> 
     41#include <stdio.h> 
     42//#include <strstream> 
     43#include <sstream> 
     44#include <fstream> 
    4245 
    4346/*! 
     
    6669 */ 
    6770Lib3dsFile* 
    68 lib3ds_file_load(const char *filename) 
    69 { 
    70   FILE *f; 
    71   Lib3dsFile *file; 
    72  
    73   f=osgDB::fopen(filename, "rb"); 
    74   if (!f) { 
    75     return(0); 
    76   } 
    77   file=lib3ds_file_new(); 
    78   if (!file) { 
    79     fclose(f); 
    80     return(0); 
    81   } 
    82    
    83   if (!lib3ds_file_read(file, f)) { 
    84     free(file); 
    85     fclose(f); 
    86     return(0); 
    87   } 
    88   fclose(f); 
     71lib3ds_file_load(const char *filename, const osgDB::ReaderWriter::Options* options) 
     72{ 
     73  Lib3dsFile *file = NULL; 
     74  std::stringstream bufferedStream; 
     75  ifstream inputStream(filename,ios::in|ios::binary); 
     76  if (!inputStream.fail()) 
     77  { 
     78        bufferedStream.operator<<(inputStream.rdbuf());                 
     79        bufferedStream.seekp(ios_base::beg);                     
     80        file = lib3ds_stream_load(&bufferedStream); 
     81        inputStream.close(); 
     82  } 
    8983  return(file); 
    9084} 
     85 
     86Lib3dsFile* 
     87lib3ds_stream_load(iostream * strm) 
     88{ 
     89  Lib3dsFile *file = NULL; 
     90  if (strm) 
     91  {     
     92    file=lib3ds_file_new(); 
     93    if (file)  
     94    { 
     95        if (!lib3ds_file_read(file,strm))  
     96        { 
     97            free(file); 
     98            file = NULL; 
     99        } 
     100    } 
     101    else  
     102        file = NULL; 
     103  } 
     104  return(file); 
     105} 
     106 
    91107 
    92108 
     
    107123lib3ds_file_save(Lib3dsFile *file, const char *filename) 
    108124{ 
    109   FILE *f; 
    110  
    111   f=osgDB::fopen(filename, "wb"); 
    112   if (!f) { 
     125  fstream strm; 
     126 
     127  strm.open(filename,ios_base::out | ios_base::binary); 
     128  if (strm.fail()) return (LIB3DS_FALSE); 
     129   
     130  if (!lib3ds_file_write(file, &strm)) { 
     131      strm.close(); 
    113132    return(LIB3DS_FALSE); 
    114133  } 
    115    
    116   if (!lib3ds_file_write(file, f)) { 
    117     fclose(f); 
    118     return(LIB3DS_FALSE); 
    119   } 
    120   fclose(f); 
     134  strm.close(); 
    121135  return(LIB3DS_TRUE); 
    122136} 
     
    214228 
    215229static Lib3dsBool 
    216 named_object_read(Lib3dsFile *file, FILE *f) 
     230named_object_read(Lib3dsFile *file, iostream *strm) 
    217231{ 
    218232  Lib3dsChunk c; 
     
    220234  Lib3dsWord chunk; 
    221235 
    222   if (!lib3ds_chunk_read_start(&c, LIB3DS_NAMED_OBJECT, f)) { 
     236  if (!lib3ds_chunk_read_start(&c, LIB3DS_NAMED_OBJECT, strm)) { 
    223237    return(LIB3DS_FALSE); 
    224238  } 
    225   if (!lib3ds_string_read(name, 64, f)) { 
     239  if (!lib3ds_string_read(name, 64, strm)) { 
    226240    return(LIB3DS_FALSE); 
    227241  } 
    228242  lib3ds_chunk_dump_info("  NAME=%s", name); 
    229   lib3ds_chunk_read_tell(&c, f); 
    230  
    231   while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) { 
     243  lib3ds_chunk_read_tell(&c, strm); 
     244 
     245  while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) { 
    232246    switch (chunk) { 
    233247      case LIB3DS_N_TRI_OBJECT: 
     
    239253            return(LIB3DS_FALSE); 
    240254          } 
    241           lib3ds_chunk_read_reset(&c, f); 
    242           if (!lib3ds_mesh_read(mesh, f)) { 
     255          lib3ds_chunk_read_reset(&c, strm); 
     256          if (!lib3ds_mesh_read(mesh, strm)) { 
    243257            return(LIB3DS_FALSE); 
    244258          } 
     
    254268            return(LIB3DS_FALSE); 
    255269          } 
    256           lib3ds_chunk_read_reset(&c, f); 
    257           if (!lib3ds_camera_read(camera, f)) { 
     270          lib3ds_chunk_read_reset(&c, strm); 
     271          if (!lib3ds_camera_read(camera, strm)) { 
    258272            return(LIB3DS_FALSE); 
    259273          } 
     
    269283            return(LIB3DS_FALSE); 
    270284          } 
    271           lib3ds_chunk_read_reset(&c, f); 
    272           if (!lib3ds_light_read(light, f)) { 
     285          lib3ds_chunk_read_reset(&c, strm); 
     286          if (!lib3ds_light_read(light, strm)) { 
    273287            return(LIB3DS_FALSE); 
    274288          } 
     
    281295  } 
    282296   
    283   lib3ds_chunk_read_end(&c, f); 
     297  lib3ds_chunk_read_end(&c, strm); 
    284298  return(LIB3DS_TRUE); 
    285299} 
     
    287301 
    288302static Lib3dsBool 
    289 ambient_read(Lib3dsFile *file, FILE *f) 
     303ambient_read(Lib3dsFile *file, iostream *strm) 
    290304{ 
    291305  Lib3dsChunk c; 
     
    293307  Lib3dsBool have_lin=LIB3DS_FALSE; 
    294308 
    295   if (!lib3ds_chunk_read_start(&c, LIB3DS_AMBIENT_LIGHT, f)) { 
     309  if (!lib3ds_chunk_read_start(&c, LIB3DS_AMBIENT_LIGHT, strm)) { 
    296310    return(LIB3DS_FALSE); 
    297311  } 
    298312 
    299   while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) { 
     313  while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) { 
    300314    switch (chunk) { 
    301315      case LIB3DS_LIN_COLOR_F: 
     
    303317          int i; 
    304318          for (i=0; i<3; ++i) { 
    305             file->ambient[i]=lib3ds_float_read(f); 
     319            file->ambient[i]=lib3ds_float_read(strm); 
    306320          } 
    307321        } 
     
    315329            int i; 
    316330            for (i=0; i<3; ++i) { 
    317               file->ambient[i]=lib3ds_float_read(f); 
     331              file->ambient[i]=lib3ds_float_read(strm); 
    318332            } 
    319333          } 
     
    325339  } 
    326340   
    327   lib3ds_chunk_read_end(&c, f); 
     341  lib3ds_chunk_read_end(&c, strm); 
    328342  return(LIB3DS_TRUE); 
    329343} 
     
    331345 
    332346static Lib3dsBool 
    333 mdata_read(Lib3dsFile *file, FILE *f) 
     347mdata_read(Lib3dsFile *file, iostream *strm) 
    334348{ 
    335349  Lib3dsChunk c; 
    336350  Lib3dsWord chunk; 
    337351 
    338   if (!lib3ds_chunk_read_start(&c, LIB3DS_MDATA, f)) { 
     352  if (!lib3ds_chunk_read_start(&c, LIB3DS_MDATA, strm)) { 
    339353    return(LIB3DS_FALSE); 
    340354  } 
    341355   
    342   while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) { 
     356  while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) { 
    343357    switch (chunk) { 
    344358      case LIB3DS_MESH_VERSION: 
    345359        { 
    346           file->mesh_version=lib3ds_intd_read(f); 
     360          file->mesh_version=lib3ds_intd_read(strm); 
    347361        } 
    348362        break; 
    349363      case LIB3DS_MASTER_SCALE: 
    350364        { 
    351           file->master_scale=lib3ds_float_read(f); 
     365          file->master_scale=lib3ds_float_read(strm); 
    352366        } 
    353367        break; 
     
    360374      case LIB3DS_RAY_BIAS: 
    361375        { 
    362           lib3ds_chunk_read_reset(&c, f); 
    363           if (!lib3ds_shadow_read(&file->shadow, f)) { 
     376          lib3ds_chunk_read_reset(&c, strm); 
     377          if (!lib3ds_shadow_read(&file->shadow, strm)) { 
    364378            return(LIB3DS_FALSE); 
    365379          } 
     
    369383      case LIB3DS_DEFAULT_VIEW: 
    370384        { 
    371           lib3ds_chunk_read_reset(&c, f); 
    372           if (!lib3ds_viewport_read(&file->viewport, f)) { 
     385          lib3ds_chunk_read_reset(&c, strm); 
     386          if (!lib3ds_viewport_read(&file->viewport, strm)) { 
    373387            return(LIB3DS_FALSE); 
    374388          } 
     
    379393          int i; 
    380394          for (i=0; i<3; ++i) { 
    381             file->construction_plane[i]=lib3ds_float_read(f); 
     395            file->construction_plane[i]=lib3ds_float_read(strm); 
    382396          } 
    383397        } 
     
    385399      case LIB3DS_AMBIENT_LIGHT: 
    386400        { 
    387           lib3ds_chunk_read_reset(&c, f); 
    388           if (!ambient_read(file, f)) { 
     401          lib3ds_chunk_read_reset(&c, strm); 
     402          if (!ambient_read(file, strm)) { 
    389403            return(LIB3DS_FALSE); 
    390404          } 
     
    398412      case LIB3DS_USE_V_GRADIENT: 
    399413        { 
    400           lib3ds_chunk_read_reset(&c, f); 
    401           if (!lib3ds_background_read(&file->background, f)) { 
     414          lib3ds_chunk_read_reset(&c, strm); 
     415          if (!lib3ds_background_read(&file->background, strm)) { 
    402416            return(LIB3DS_FALSE); 
    403417          } 
     
    411425      case LIB3DS_USE_DISTANCE_CUE: 
    412426        { 
    413           lib3ds_chunk_read_reset(&c, f); 
    414           if (!lib3ds_atmosphere_read(&file->atmosphere, f)) { 
     427          lib3ds_chunk_read_reset(&c, strm); 
     428          if (!lib3ds_atmosphere_read(&file->atmosphere, strm)) { 
    415429            return(LIB3DS_FALSE); 
    416430          } 
     
    425439            return(LIB3DS_FALSE); 
    426440          } 
    427           lib3ds_chunk_read_reset(&c, f); 
    428           if (!lib3ds_material_read(material, f)) { 
     441          lib3ds_chunk_read_reset(&c, strm); 
     442          if (!lib3ds_material_read(material, strm)) { 
    429443            return(LIB3DS_FALSE); 
    430444          } 
     
    434448      case LIB3DS_NAMED_OBJECT: 
    435449        { 
    436           lib3ds_chunk_read_reset(&c, f); 
    437           if (!named_object_read(file, f)) { 
     450          lib3ds_chunk_read_reset(&c, strm); 
     451          if (!named_object_read(file, strm)) { 
    438452            return(LIB3DS_FALSE); 
    439453          } 
     
    445459  } 
    446460 
    447   lib3ds_chunk_read_end(&c, f); 
     461  lib3ds_chunk_read_end(&c, strm); 
    448462  return(LIB3DS_TRUE); 
    449463} 
     
    451465 
    452466static Lib3dsBool 
    453 kfdata_read(Lib3dsFile *file, FILE *f) 
     467kfdata_read(Lib3dsFile *file, iostream *strm) 
    454468{ 
    455469  Lib3dsChunk c; 
    456470  Lib3dsWord chunk; 
    457471 
    458   if (!lib3ds_chunk_read_start(&c, LIB3DS_KFDATA, f)) { 
     472  if (!lib3ds_chunk_read_start(&c, LIB3DS_KFDATA, strm)) { 
    459473    return(LIB3DS_FALSE); 
    460474  } 
    461475   
    462   while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) { 
     476  while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) { 
    463477    switch (chunk) { 
    464478      case LIB3DS_KFHDR: 
    465479        { 
    466           file->keyf_revision=lib3ds_word_read(f); 
    467           if (!lib3ds_string_read(file->name, 12+1, f)) { 
    468             return(LIB3DS_FALSE); 
    469           } 
    470           file->frames=lib3ds_intd_read(f); 
     480          file->keyf_revision=lib3ds_word_read(strm); 
     481          if (!lib3ds_string_read(file->name, 12+1, strm)) { 
     482            return(LIB3DS_FALSE); 
     483          } 
     484          file->frames=lib3ds_intd_read(strm); 
    471485        } 
    472486        break; 
    473487      case LIB3DS_KFSEG: 
    474488        { 
    475           file->segment_from=lib3ds_intd_read(f); 
    476           file->segment_to=lib3ds_intd_read(f); 
     489          file->segment_from=lib3ds_intd_read(strm); 
     490          file->segment_to=lib3ds_intd_read(strm); 
    477491        } 
    478492        break; 
    479493      case LIB3DS_KFCURTIME: 
    480494        { 
    481           file->current_frame=lib3ds_intd_read(f); 
     495          file->current_frame=lib3ds_intd_read(strm); 
    482496        } 
    483497        break; 
     
    485499      case LIB3DS_DEFAULT_VIEW: 
    486500        { 
    487           lib3ds_chunk_read_reset(&c, f); 
    488           if (!lib3ds_viewport_read(&file->viewport_keyf, f)) { 
     501          lib3ds_chunk_read_reset(&c, strm); 
     502          if (!lib3ds_viewport_read(&file->viewport_keyf, strm)) { 
    489503            return(LIB3DS_FALSE); 
    490504          } 
     
    499513            return(LIB3DS_FALSE); 
    500514          } 
    501           lib3ds_chunk_read_reset(&c, f); 
    502           if (!lib3ds_node_read(node, file, f)) { 
     515          lib3ds_chunk_read_reset(&c, strm); 
     516          if (!lib3ds_node_read(node, file, strm)) { 
    503517            return(LIB3DS_FALSE); 
    504518          } 
     
    514528            return(LIB3DS_FALSE); 
    515529          } 
    516           lib3ds_chunk_read_reset(&c, f); 
    517           if (!lib3ds_node_read(node, file, f)) { 
     530          lib3ds_chunk_read_reset(&c, strm); 
     531          if (!lib3ds_node_read(node, file, strm)) { 
    518532            return(LIB3DS_FALSE); 
    519533          } 
     
    529543            return(LIB3DS_FALSE); 
    530544          } 
    531           lib3ds_chunk_read_reset(&c, f); 
    532           if (!lib3ds_node_read(node, file, f)) { 
     545          lib3ds_chunk_read_reset(&c, strm); 
     546          if (!lib3ds_node_read(node, file, strm)) { 
    533547            return(LIB3DS_FALSE); 
    534548          } 
     
    544558            return(LIB3DS_FALSE); 
    545559          } 
    546           lib3ds_chunk_read_reset(&c, f); 
    547           if (!lib3ds_node_read(node, file, f)) { 
     560          lib3ds_chunk_read_reset(&c, strm); 
     561          if (!lib3ds_node_read(node, file, strm)) { 
    548562            return(LIB3DS_FALSE); 
    549563          } 
     
    560574            return(LIB3DS_FALSE); 
    561575          } 
    562           lib3ds_chunk_read_reset(&c, f); 
    563           if (!lib3ds_node_read(node, file, f)) { 
     576          lib3ds_chunk_read_reset(&c, strm); 
     577          if (!lib3ds_node_read(node, file, strm)) { 
    564578            return(LIB3DS_FALSE); 
    565579          } 
     
    575589            return(LIB3DS_FALSE); 
    576590          } 
    577           lib3ds_chunk_read_reset(&c, f); 
    578           if (!lib3ds_node_read(node, file, f)) { 
     591          lib3ds_chunk_read_reset(&c, strm); 
     592          if (!lib3ds_node_read(node, file, strm)) { 
    579593            return(LIB3DS_FALSE); 
    580594          } 
     
    587601  } 
    588602 
    589   lib3ds_chunk_read_end(&c, f); 
     603  lib3ds_chunk_read_end(&c, strm); 
    590604  return(LIB3DS_TRUE); 
    591605} 
     
    596610 */ 
    597611Lib3dsBool 
    598 lib3ds_file_read(Lib3dsFile *file, FILE *f) 
     612lib3ds_file_read(Lib3dsFile *file, iostream *strm) 
    599613{ 
    600614  Lib3dsChunk c; 
    601615  Lib3dsWord chunk; 
    602616 
    603   if (!lib3ds_chunk_read_start(&c, 0, f)) { 
     617  if (!lib3ds_chunk_read_start(&c, 0, strm)) { 
    604618    return(LIB3DS_FALSE); 
    605619  } 
     
    607621    case LIB3DS_MDATA: 
    608622      { 
    609         lib3ds_chunk_read_reset(&c, f); 
    610         if (!mdata_read(file, f)) { 
     623        lib3ds_chunk_read_reset(&c, strm); 
     624        if (!mdata_read(file, strm)) { 
    611625          return(LIB3DS_FALSE); 
    612626        } 
     
    617631    case LIB3DS_CMAGIC: 
    618632      { 
    619         while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) { 
     633        while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) { 
    620634          switch (chunk) { 
    621635            case LIB3DS_M3D_VERSION: 
    622636              { 
    623                 file->mesh_version=lib3ds_dword_read(f); 
     637                file->mesh_version=lib3ds_dword_read(strm); 
    624638              } 
    625639              break; 
    626640            case LIB3DS_MDATA: 
    627641              { 
    628                 lib3ds_chunk_read_reset(&c, f); 
    629                 if (!mdata_read(file, f)) { 
     642                lib3ds_chunk_read_reset(&c, strm); 
     643                if (!mdata_read(file, strm)) { 
    630644                  return(LIB3DS_FALSE); 
    631645                } 
     
    634648            case LIB3DS_KFDATA: 
    635649              { 
    636                 lib3ds_chunk_read_reset(&c, f); 
    637                 if (!kfdata_read(file, f)) { 
     650                lib3ds_chunk_read_reset(&c, strm); 
     651                if (!kfdata_read(file, strm)) { 
    638652                  return(LIB3DS_FALSE); 
    639653                } 
     
    651665  } 
    652666 
    653   lib3ds_chunk_read_end(&c, f); 
     667  lib3ds_chunk_read_end(&c, strm); 
    654668  return(LIB3DS_TRUE); 
    655669} 
     
    657671 
    658672static Lib3dsBool 
    659 colorf_write(Lib3dsRgba rgb, FILE *f) 
     673colorf_write(Lib3dsRgba rgb, iostream *strm) 
    660674{ 
    661675  Lib3dsChunk c; 
     
    663677  c.chunk=LIB3DS_COLOR_F; 
    664678  c.size=18; 
    665   lib3ds_chunk_write(&c,f); 
    666   lib3ds_rgb_write(rgb,f); 
     679  lib3ds_chunk_write(&c,strm); 
     680  lib3ds_rgb_write(rgb,strm); 
    667681 
    668682  c.chunk=LIB3DS_LIN_COLOR_F; 
    669683  c.size=18; 
    670   lib3ds_chunk_write(&c,f); 
    671   lib3ds_rgb_write(rgb,f); 
     684  lib3ds_chunk_write(&c,strm); 
     685  lib3ds_rgb_write(rgb,strm); 
    672686  return(LIB3DS_TRUE); 
    673687} 
     
    675689 
    676690static Lib3dsBool 
    677 mdata_write(Lib3dsFile *file, FILE *f) 
     691mdata_write(Lib3dsFile *file, iostream *strm) 
    678692{ 
    679693  Lib3dsChunk c; 
    680694 
    681695  c.chunk=LIB3DS_MDATA; 
    682   if (!lib3ds_chunk_write_start(&c,f)) { 
     696  if (!lib3ds_chunk_write_start(&c,strm)) { 
    683697    return(LIB3DS_FALSE); 
    684698  } 
     
    688702    c.chunk=LIB3DS_MESH_VERSION; 
    689703    c.size=10; 
    690     lib3ds_chunk_write(&c,f); 
    691     lib3ds_intd_write(file->mesh_version,f); 
     704    lib3ds_chunk_write(&c,strm); 
     705    lib3ds_intd_write(file->mesh_version,strm); 
    692706  } 
    693707  { /*---- LIB3DS_MASTER_SCALE ----*/ 
     
    695709    c.chunk=LIB3DS_MASTER_SCALE; 
    696710    c.size=10; 
    697     lib3ds_chunk_write(&c,f); 
    698     lib3ds_float_write(file->master_scale,f); 
     711    lib3ds_chunk_write(&c,strm); 
     712    lib3ds_float_write(file->master_scale,strm); 
    699713  } 
    700714  { /*---- LIB3DS_O_CONSTS ----*/ 
     
    709723      c.chunk=LIB3DS_O_CONSTS; 
    710724      c.size=18; 
    711       lib3ds_chunk_write(&c,f); 
    712       lib3ds_vector_write(file->construction_plane,f); 
     725      lib3ds_chunk_write(&c,strm); 
     726      lib3ds_vector_write(file->construction_plane,strm); 
    713727    } 
    714728  } 
     
    725739      c.chunk=LIB3DS_AMBIENT_LIGHT; 
    726740      c.size=42; 
    727       lib3ds_chunk_write(&c,f); 
    728       colorf_write(file->ambient,f); 
    729     } 
    730   } 
    731   lib3ds_background_write(&file->background, f); 
    732   lib3ds_atmosphere_write(&file->atmosphere, f); 
    733   lib3ds_shadow_write(&file->shadow, f); 
    734   lib3ds_viewport_write(&file->viewport, f); 
     741      lib3ds_chunk_write(&c,strm); 
     742      colorf_write(file->ambient,strm); 
     743    } 
     744  } 
     745  lib3ds_background_write(&file->background, strm); 
     746  lib3ds_atmosphere_write(&file->atmosphere, strm); 
     747  lib3ds_shadow_write(&file->shadow, strm); 
     748  lib3ds_viewport_write(&file->viewport, strm); 
    735749  { 
    736750    Lib3dsMaterial *p; 
    737751    for (p=file->materials; p!=0; p=p->next) { 
    738       if (!lib3ds_material_write(p,f)) { 
     752      if (!lib3ds_material_write(p,strm)) { 
    739753        return(LIB3DS_FALSE); 
    740754      } 
     
    747761    for (p=file->cameras; p!=0; p=p->next) { 
    748762      c.chunk=LIB3DS_NAMED_OBJECT; 
    749       if (!lib3ds_chunk_write_start(&c,f)) { 
     763      if (!lib3ds_chunk_write_start(&c,strm)) { 
    750764        return(LIB3DS_FALSE); 
    751765      } 
    752       lib3ds_string_write(p->name,f); 
    753       lib3ds_camera_write(p,f); 
    754       if (!lib3ds_chunk_write_end(&c,f)) { 
     766      lib3ds_string_write(p->name,strm); 
     767      lib3ds_camera_write(p,strm); 
     768      if (!lib3ds_chunk_write_end(&c,strm)) { 
    755769        return(LIB3DS_FALSE); 
    756770      } 
     
    763777    for (p=file->lights; p!=0; p=p->next) { 
    764778      c.chunk=LIB3DS_NAMED_OBJECT; 
    765       if (!lib3ds_chunk_write_start(&c,f)) { 
     779      if (!lib3ds_chunk_write_start(&c,strm)) { 
    766780        return(LIB3DS_FALSE); 
    767781      } 
    768       lib3ds_string_write(p->name,f); 
    769       lib3ds_light_write(p,f); 
    770       if (!lib3ds_chunk_write_end(&c,f)) { 
     782      lib3ds_string_write(p->name,strm); 
     783      lib3ds_light_write(p,strm); 
     784      if (!lib3ds_chunk_write_end(&c,strm)) { 
    771785        return(LIB3DS_FALSE); 
    772786      } 
     
    779793    for (p=file->meshes; p!=0; p=p->next) { 
    780794      c.chunk=LIB3DS_NAMED_OBJECT; 
    781       if (!lib3ds_chunk_write_start(&c,f)) { 
     795      if (!lib3ds_chunk_write_start(&c,strm)) { 
    782796        return(LIB3DS_FALSE); 
    783797      } 
    784       lib3ds_string_write(p->name,f); 
    785       lib3ds_mesh_write(p,f); 
    786       if (!lib3ds_chunk_write_end(&c,f)) { 
     798      lib3ds_string_write(p->name,strm); 
     799      lib3ds_mesh_write(p,strm); 
     800      if (!lib3ds_chunk_write_end(&c,strm)) { 
    787801        return(LIB3DS_FALSE); 
    788802      } 
     
    790804  } 
    791805 
    792   if (!lib3ds_chunk_write_end(&c,f)) { 
     806  if (!lib3ds_chunk_write_end(&c,strm)) { 
    793807    return(LIB3DS_FALSE); 
    794808  } 
     
    799813 
    800814static Lib3dsBool 
    801 nodes_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f) 
     815nodes_write(Lib3dsNode *node, Lib3dsFile *file, iostream *strm) 
    802816{ 
    803817  { 
    804818    Lib3dsNode *p; 
    805819    for (p=node->childs; p!=0; p=p->next) { 
    806       if (!lib3ds_node_write(p, file, f)) { 
     820      if (!lib3ds_node_write(p, file, strm)) { 
    807821        return(LIB3DS_FALSE); 
    808822      } 
    809       nodes_write(p, file, f); 
     823      nodes_write(p, file, strm); 
    810824    } 
    811825  } 
     
    815829 
    816830static Lib3dsBool 
    817 kfdata_write(Lib3dsFile *file, FILE *f) 
     831kfdata_write(Lib3dsFile *file, iostream *strm) 
    818832{ 
    819833  Lib3dsChunk c; 
    820834   
    821835  c.chunk=LIB3DS_KFDATA; 
    822   if (!lib3ds_chunk_write_start(&c,f)) { 
     836  if (!lib3ds_chunk_write_start(&c,strm)) { 
    823837    return(LIB3DS_FALSE); 
    824838  } 
     
    828842    c.chunk=LIB3DS_KFHDR; 
    829843    c.size=6 + 2 + strlen(file->name)+1 +4; 
    830     lib3ds_chunk_write(&c,f); 
    831     lib3ds_intw_write(file->keyf_revision,f); 
    832     lib3ds_string_write(file->name, f); 
    833     lib3ds_intd_write(file->frames, f); 
     844    lib3ds_chunk_write(&c,strm); 
     845    lib3ds_intw_write(file->keyf_revision,strm); 
     846    lib3ds_string_write(file->name, strm); 
     847    lib3ds_intd_write(file->frames, strm); 
    834848  } 
    835849  { /*---- LIB3DS_KFSEG ----*/ 
     
    837851    c.chunk=LIB3DS_KFSEG; 
    838852    c.size=14; 
    839     lib3ds_chunk_write(&c,f); 
    840     lib3ds_intd_write(file->segment_from,f); 
    841     lib3ds_intd_write(file->segment_to,f); 
     853    lib3ds_chunk_write(&c,strm); 
     854    lib3ds_intd_write(file->segment_from,strm); 
     855    lib3ds_intd_write(file->segment_to,strm); 
    842856  } 
    843857  { /*---- LIB3DS_KFCURTIME ----*/ 
     
    845859    c.chunk=LIB3DS_KFCURTIME; 
    846860    c.size=10; 
    847     lib3ds_chunk_write(&c,f); 
    848     lib3ds_intd_write(file->current_frame,f); 
    849   } 
    850   lib3ds_viewport_write(&file->viewport_keyf, f); 
     861    lib3ds_chunk_write(&c,strm); 
     862    lib3ds_intd_write(file->current_frame,strm); 
     863  } 
     864  lib3ds_viewport_write(&file->viewport_keyf, strm); 
    851865   
    852866  { 
    853867    Lib3dsNode *p; 
    854868    for (p=file->nodes; p!=0; p=p->next) { 
    855       if (!lib3ds_node_write(p, file, f)) { 
     869      if (!lib3ds_node_write(p, file, strm)) { 
    856870        return(LIB3DS_FALSE); 
    857871      } 
    858       if (!nodes_write(p, file, f)) { 
     872      if (!nodes_write(p, file, strm)) { 
    859873        return(LIB3DS_FALSE); 
    860874      } 
     
    862876  } 
    863877   
    864   if (!lib3ds_chunk_write_end(&c,f)) { 
     878  if (!lib3ds_chunk_write_end(&c,strm)) { 
    865879    return(LIB3DS_FALSE); 
    866880  } 
     
    873887 */ 
    874888Lib3dsBool 
    875 lib3ds_file_write(Lib3dsFile *file, FILE *f) 
     889lib3ds_file_write(Lib3dsFile *file, iostream *strm) 
    876890{ 
    877891  Lib3dsChunk c; 
    878892 
    879893  c.chunk=LIB3DS_M3DMAGIC; 
    880   if (!lib3ds_chunk_write_start(&c,f)) { 
     894  if (!lib3ds_chunk_write_start(&c,strm)) { 
    881895    LIB3DS_ERROR_LOG; 
    882896    return(LIB3DS_FALSE); 
     
    888902    c.chunk=LIB3DS_M3D_VERSION; 
    889903    c.size=10; 
    890     lib3ds_chunk_write(&c,f); 
    891     lib3ds_dword_write(file->mesh_version, f); 
    892   } 
    893  
    894   if (!mdata_write(file, f)) { 
     904    lib3ds_chunk_write(&c,strm); 
     905    lib3ds_dword_write(file->mesh_version, strm); 
     906  } 
     907 
     908  if (!mdata_write(file, strm)) { 
    895909    return(LIB3DS_FALSE); 
    896910  } 
    897   if (!kfdata_write(file, f)) { 
     911  if (!kfdata_write(file, strm)) { 
    898912    return(LIB3DS_FALSE); 
    899913  } 
    900914 
    901   if (!lib3ds_chunk_write_end(&c,f)) { 
     915  if (!lib3ds_chunk_write_end(&c,strm)) { 
    902916    return(LIB3DS_FALSE); 
    903917  }