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/readwrite.cpp

    r9571 r10076  
    2424#include <osg/Endian> 
    2525 
     26 
    2627/*! 
    2728 * \defgroup readwrite Portable Binary Input/Ouput 
     
    3031 */ 
    3132 
    32  
    3333static bool s_requiresByteSwap = false; 
    3434 
     
    5050 */ 
    5151Lib3dsByte 
    52 lib3ds_byte_read(FILE *f) 
     52lib3ds_byte_read(iostream *strm) 
    5353{ 
    5454  Lib3dsByte b; 
    5555 
    56   ASSERT(f); 
    57   int result = fread(&b,1,1,f); 
    58   if (result==0) return 0; 
     56  ASSERT(strm); 
     57  strm->read((char*)&b,1); 
    5958  return(b); 
    6059} 
     
    6968 */ 
    7069Lib3dsWord 
    71 lib3ds_word_read(FILE *f) 
     70lib3ds_word_read(iostream *strm) 
    7271{ 
    7372  Lib3dsByte b[2]; 
    7473  Lib3dsWord w; 
    7574 
    76   ASSERT(f); 
    77   int result = fread(b,2,1,f); 
    78   if (result==0) return 0; 
    79  
     75  ASSERT(strm);   
     76  strm->read((char*)&b,2); 
    8077  w=((Lib3dsWord)b[1] << 8) | 
    8178    ((Lib3dsWord)b[0]); 
     
    9491 */ 
    9592Lib3dsDword 
    96 lib3ds_dword_read(FILE *f) 
     93lib3ds_dword_read(iostream *strm) 
    9794{ 
    9895  Lib3dsByte b[4]; 
    9996  Lib3dsDword d;         
    10097                          
    101   ASSERT(f); 
    102   int result = fread(b,4,1,f); 
    103   if (result==0) return 0; 
    104  
     98  ASSERT(strm);   
     99  strm->read((char*)&b,4); 
    105100  d=((Lib3dsDword)b[3] << 24) | 
    106101    ((Lib3dsDword)b[2] << 16) | 
     
    121116 */ 
    122117Lib3dsIntb 
    123 lib3ds_intb_read(FILE *f) 
     118lib3ds_intb_read(iostream *strm) 
    124119{ 
    125120  Lib3dsIntb b; 
    126121 
    127   ASSERT(f); 
    128   int result = fread(&b,1,1,f); 
    129   if (result==0) return 0; 
    130  
     122  ASSERT(strm);   
     123  strm->read((char*)&b,1); 
    131124  return(b); 
    132125} 
     
    143136 */ 
    144137Lib3dsIntw 
    145 lib3ds_intw_read(FILE *f) 
     138lib3ds_intw_read(iostream *strm) 
    146139{ 
    147140  Lib3dsByte b[2]; 
    148141 
    149   ASSERT(f); 
    150   int result = fread(b,2,1,f); 
    151   if (result==0) return 0; 
     142  ASSERT(strm); 
     143  strm->read((char*)&b,2); 
    152144 
    153145  if (s_requiresByteSwap) 
     
    170162 */ 
    171163Lib3dsIntd 
    172 lib3ds_intd_read(FILE *f) 
    173 { 
    174   Lib3dsByte b[4]; 
     164lib3ds_intd_read(iostream *strm) 
     165{ 
     166  Lib3dsByte b[4];      
    175167                          
    176   ASSERT(f); 
    177   int result = fread(b,4,1,f); 
    178   if (result==0) return 0; 
     168  ASSERT(strm); 
     169  strm->read((char*)&b,4); 
    179170 
    180171  if (s_requiresByteSwap) 
     
    184175 
    185176  return (*((Lib3dsIntd*)b)); 
     177 
    186178} 
    187179 
     
    197189 */ 
    198190Lib3dsFloat 
    199 lib3ds_float_read(FILE *f) 
     191lib3ds_float_read(iostream *strm) 
    200192{ 
    201193  Lib3dsByte b[4]; 
    202194 
    203   ASSERT(f); 
    204   int result = fread(b,4,1,f); 
    205   if (result==0) return 0; 
     195  ASSERT(strm); 
     196  b[0]=b[1]=b[2]=b[3]=0; 
     197  strm->read((char*)&b,4);   
    206198 
    207199  if (s_requiresByteSwap) 
     
    226218 */ 
    227219Lib3dsBool 
    228 lib3ds_vector_read(Lib3dsVector v, FILE *f) 
    229 { 
    230   v[0]=lib3ds_float_read(f); 
    231   v[1]=lib3ds_float_read(f); 
    232   v[2]=lib3ds_float_read(f); 
    233  
    234   if (ferror(f)) { 
    235     return(LIB3DS_FALSE); 
    236   } 
    237    
     220lib3ds_vector_read(Lib3dsVector v, iostream *strm) 
     221{ 
     222  v[0]=lib3ds_float_read(strm); 
     223  v[1]=lib3ds_float_read(strm); 
     224  v[2]=lib3ds_float_read(strm); 
     225 
     226  if (strm->fail()) { 
     227    return(LIB3DS_FALSE); 
     228  } 
     229 
    238230  /*printf("lib3ds_vector_read %f %f %f\n",v[0],v[1],v[2]);*/ 
    239    
    240   return(LIB3DS_TRUE); 
    241 } 
    242  
    243  
    244 /*! 
    245  * \ingroup readwrite 
    246  */ 
    247 Lib3dsBool 
    248 lib3ds_rgb_read(Lib3dsRgb rgb, FILE *f) 
    249 { 
    250   rgb[0]=lib3ds_float_read(f); 
    251   rgb[1]=lib3ds_float_read(f); 
    252   rgb[2]=lib3ds_float_read(f); 
    253  
    254   if (ferror(f)) { 
     231 
     232  return(LIB3DS_TRUE); 
     233} 
     234 
     235 
     236/*! 
     237 * \ingroup readwrite 
     238 */ 
     239Lib3dsBool 
     240lib3ds_rgb_read(Lib3dsRgb rgb, iostream *strm) 
     241{ 
     242  rgb[0]=lib3ds_float_read(strm); 
     243  rgb[1]=lib3ds_float_read(strm); 
     244  rgb[2]=lib3ds_float_read(strm); 
     245 
     246  if (strm->fail()) { 
    255247    return(LIB3DS_FALSE); 
    256248  } 
     
    273265 */ 
    274266Lib3dsBool 
    275 lib3ds_string_read(char *s, int buflen, FILE *f) 
     267lib3ds_string_read(char *s, int buflen, iostream *strm) 
    276268{ 
    277269  int k=0; 
    278   ASSERT(f); 
    279   while ((*s++=char(fgetc(f)))!=0) { 
    280     if (++k>=buflen) { 
    281       return(LIB3DS_FALSE); 
    282     } 
    283   } 
    284   if (ferror(f)) { 
    285     return(LIB3DS_FALSE); 
    286   } 
    287   return(LIB3DS_TRUE); 
    288 } 
    289  
     270  ASSERT(s); 
     271  s--; 
     272  do 
     273  { 
     274      s++; 
     275      k++; 
     276      strm->read(s,1); 
     277  } while ((*s!=0) && (k<buflen)); 
     278 
     279  if (strm->fail()) { 
     280    return(LIB3DS_FALSE); 
     281  } 
     282  return(LIB3DS_TRUE); 
     283} 
    290284 
    291285/*! 
     
    300294 */ 
    301295Lib3dsBool 
    302 lib3ds_byte_write(Lib3dsByte b, FILE *f) 
    303 { 
    304   ASSERT(f); 
    305   if (fwrite(&b,1,1,f)!=1) { 
     296lib3ds_byte_write(Lib3dsByte b, iostream *strm) 
     297{ 
     298  ASSERT(strm); 
     299  strm->write((char*)&b,1); 
     300  if (strm->fail()) { 
    306301    return(LIB3DS_FALSE); 
    307302  } 
     
    321316 */ 
    322317Lib3dsBool 
    323 lib3ds_word_write(Lib3dsWord w, FILE *f) 
     318lib3ds_word_write(Lib3dsWord w, iostream *strm) 
    324319{ 
    325320  Lib3dsByte b[2]; 
    326321 
    327   ASSERT(f); 
     322  ASSERT(strm); 
    328323  b[1]=(Lib3dsByte)(((Lib3dsWord)w & 0xFF00) >> 8); 
    329324  b[0]=(Lib3dsByte)((Lib3dsWord)w & 0x00FF); 
    330   if (fwrite(b,2,1,f)!=1) { 
     325  strm->write((char*)b,2); 
     326  if (strm->fail()) { 
    331327    return(LIB3DS_FALSE); 
    332328  } 
     
    346342 */ 
    347343Lib3dsBool 
    348 lib3ds_dword_write(Lib3dsDword d, FILE *f) 
     344lib3ds_dword_write(Lib3dsDword d, iostream *strm) 
    349345{ 
    350346  Lib3dsByte b[4]; 
    351347 
    352   ASSERT(f); 
     348  ASSERT(strm); 
    353349  b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24); 
    354350  b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16); 
    355351  b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8); 
    356352  b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF)); 
    357   if (fwrite(b,4,1,f)!=1) { 
     353 
     354  strm->write((char*)b,4); 
     355  if (strm->fail()) { 
    358356    return(LIB3DS_FALSE); 
    359357  } 
     
    373371 */ 
    374372Lib3dsBool 
    375 lib3ds_intb_write(Lib3dsIntb b, FILE *f) 
    376 { 
    377   ASSERT(f); 
    378   if (fwrite(&b,1,1,f)!=1) { 
     373lib3ds_intb_write(Lib3dsIntb b, iostream *strm) 
     374{ 
     375  ASSERT(strm); 
     376  strm->write((char*)b,1); 
     377  if (strm->fail()) { 
    379378    return(LIB3DS_FALSE); 
    380379  } 
     
    394393 */ 
    395394Lib3dsBool 
    396 lib3ds_intw_write(Lib3dsIntw w, FILE *f) 
     395lib3ds_intw_write(Lib3dsIntw w, iostream *strm) 
    397396{ 
    398397  Lib3dsByte b[2]; 
    399398 
    400   ASSERT(f); 
     399  ASSERT(strm); 
    401400  b[1]=(Lib3dsByte)(((Lib3dsWord)w & 0xFF00) >> 8); 
    402401  b[0]=(Lib3dsByte)((Lib3dsWord)w & 0x00FF); 
    403   if (fwrite(b,2,1,f)!=1) { 
     402 
     403  strm->write((char*)b,2); 
     404  if (strm->fail()) { 
    404405    return(LIB3DS_FALSE); 
    405406  } 
     
    419420 */ 
    420421Lib3dsBool 
    421 lib3ds_intd_write(Lib3dsIntd d, FILE *f) 
     422lib3ds_intd_write(Lib3dsIntd d, iostream *strm) 
    422423{ 
    423424  Lib3dsByte b[4]; 
    424425 
    425   ASSERT(f); 
     426  ASSERT(strm); 
    426427  b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24); 
    427428  b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16); 
    428429  b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8); 
    429430  b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF)); 
    430   if (fwrite(b,4,1,f)!=1) { 
     431 
     432  strm->write((char*)b,4); 
     433  if (strm->fail()) { 
    431434    return(LIB3DS_FALSE); 
    432435  } 
     
    445448 * \return   True on success, False otherwise. 
    446449 */ 
    447   
    448   
    449 Lib3dsBool 
    450 lib3ds_float_write(Lib3dsFloat l, FILE *f) 
    451 { 
     450Lib3dsBool 
     451lib3ds_float_write(Lib3dsFloat l, iostream *strm) 
     452{ 
     453  ASSERT(strm); 
    452454 
    453455  Lib3dsByte b[4]; 
     
    468470      b[3] = *ptr++; 
    469471  } 
    470    
    471   if (fwrite(b,4,1,f)!=1) { 
     472 
     473  strm->write((char*)b,4); 
     474  if (strm->fail()) { 
    472475    return(LIB3DS_FALSE); 
    473476  } 
     
    486489 */ 
    487490Lib3dsBool 
    488 lib3ds_vector_write(Lib3dsVector v, FILE *f) 
    489 { 
    490   if (!lib3ds_float_write(v[0], f)) { 
    491     return(LIB3DS_FALSE); 
    492   } 
    493   if (!lib3ds_float_write(v[1], f)) { 
    494     return(LIB3DS_FALSE); 
    495   } 
    496   if (!lib3ds_float_write(v[2], f)) { 
    497     return(LIB3DS_FALSE); 
    498   } 
    499   return(LIB3DS_TRUE); 
    500 } 
    501  
    502  
    503 /*! 
    504  * \ingroup readwrite 
    505  */ 
    506 Lib3dsBool 
    507 lib3ds_rgb_write(Lib3dsRgb rgb, FILE *f) 
    508 { 
    509   if (!lib3ds_float_write(rgb[0], f)) { 
    510     return(LIB3DS_FALSE); 
    511   } 
    512   if (!lib3ds_float_write(rgb[1], f)) { 
    513     return(LIB3DS_FALSE); 
    514   } 
    515   if (!lib3ds_float_write(rgb[2], f)) { 
     491lib3ds_vector_write(Lib3dsVector v, iostream *strm) 
     492{ 
     493  if (!lib3ds_float_write(v[0], strm)) { 
     494    return(LIB3DS_FALSE); 
     495  } 
     496  if (!lib3ds_float_write(v[1], strm)) { 
     497    return(LIB3DS_FALSE); 
     498  } 
     499  if (!lib3ds_float_write(v[2], strm)) { 
     500    return(LIB3DS_FALSE); 
     501  } 
     502  return(LIB3DS_TRUE); 
     503} 
     504 
     505 
     506/*! 
     507 * \ingroup readwrite 
     508 */ 
     509Lib3dsBool 
     510lib3ds_rgb_write(Lib3dsRgb rgb, iostream *strm) 
     511{ 
     512  if (!lib3ds_float_write(rgb[0], strm)) { 
     513    return(LIB3DS_FALSE); 
     514  } 
     515  if (!lib3ds_float_write(rgb[1], strm)) { 
     516    return(LIB3DS_FALSE); 
     517  } 
     518  if (!lib3ds_float_write(rgb[2], strm)) { 
    516519    return(LIB3DS_FALSE); 
    517520  } 
     
    531534 */ 
    532535Lib3dsBool 
    533 lib3ds_string_write(const char *s, FILE *f) 
     536lib3ds_string_write(const char *s, iostream *strm) 
    534537{ 
    535538  ASSERT(s); 
    536   ASSERT(f); 
    537   do fputc(*s,f); while (*s++); 
    538   if (ferror(f)) { 
    539     return(LIB3DS_FALSE); 
    540   } 
    541   return(LIB3DS_TRUE); 
    542 } 
    543  
     539  ASSERT(strm); 
     540  do strm->write(s,1); while (*s++); 
     541  if (strm->fail()) { 
     542    return(LIB3DS_FALSE); 
     543  } 
     544  return(LIB3DS_TRUE); 
     545} 
     546