Show
Ignore:
Timestamp:
04/22/09 17:46:24 (6 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/mesh.cpp

    r5453 r10076  
    4343 
    4444static Lib3dsBool 
    45 face_array_read(Lib3dsMesh *mesh, FILE *f) 
     45face_array_read(Lib3dsMesh *mesh, iostream *strm) 
    4646{ 
    4747  Lib3dsChunk c; 
     
    5050  int faces; 
    5151 
    52   if (!lib3ds_chunk_read_start(&c, LIB3DS_FACE_ARRAY, f)) { 
     52  if (!lib3ds_chunk_read_start(&c, LIB3DS_FACE_ARRAY, strm)) { 
    5353    return(LIB3DS_FALSE); 
    5454  } 
    5555  lib3ds_mesh_free_face_list(mesh); 
    5656   
    57   faces=lib3ds_word_read(f); 
     57  faces=lib3ds_word_read(strm); 
    5858  if (faces) { 
    5959    if (!lib3ds_mesh_new_face_list(mesh, faces)) { 
     
    6363    for (i=0; i<faces; ++i) { 
    6464      strcpy(mesh->faceL[i].material, ""); 
    65       mesh->faceL[i].points[0]=lib3ds_word_read(f); 
    66       mesh->faceL[i].points[1]=lib3ds_word_read(f); 
    67       mesh->faceL[i].points[2]=lib3ds_word_read(f); 
    68       mesh->faceL[i].flags=lib3ds_word_read(f); 
    69     } 
    70     lib3ds_chunk_read_tell(&c, f); 
    71  
    72     while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) { 
     65      mesh->faceL[i].points[0]=lib3ds_word_read(strm); 
     66      mesh->faceL[i].points[1]=lib3ds_word_read(strm); 
     67      mesh->faceL[i].points[2]=lib3ds_word_read(strm); 
     68      mesh->faceL[i].flags=lib3ds_word_read(strm); 
     69    } 
     70    lib3ds_chunk_read_tell(&c, strm); 
     71 
     72    while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) { 
    7373      switch (chunk) { 
    7474        case LIB3DS_SMOOTH_GROUP: 
     
    7777 
    7878            for (i=0; i<mesh->faces; ++i) { 
    79               mesh->faceL[i].smoothing=lib3ds_dword_read(f); 
     79              mesh->faceL[i].smoothing=lib3ds_dword_read(strm); 
    8080            } 
    8181          } 
     
    8888            unsigned index; 
    8989 
    90             if (!lib3ds_string_read(name, 64, f)) { 
     90            if (!lib3ds_string_read(name, 64, strm)) { 
    9191              return(LIB3DS_FALSE); 
    9292            } 
    93             faces=lib3ds_word_read(f); 
     93            faces=lib3ds_word_read(strm); 
    9494            for (i=0; i<faces; ++i) { 
    95               index=lib3ds_word_read(f); 
     95              index=lib3ds_word_read(strm); 
    9696              ASSERT(index<mesh->faces); 
    9797              strcpy(mesh->faceL[index].material, name); 
     
    103103            char name[64]; 
    104104 
    105             if (!lib3ds_string_read(name, 64, f)) { 
     105            if (!lib3ds_string_read(name, 64, strm)) { 
    106106              return(LIB3DS_FALSE); 
    107107            } 
    108108            strcpy(mesh->box_map.front, name); 
    109             if (!lib3ds_string_read(name, 64, f)) { 
     109            if (!lib3ds_string_read(name, 64, strm)) { 
    110110              return(LIB3DS_FALSE); 
    111111            } 
    112112            strcpy(mesh->box_map.back, name); 
    113             if (!lib3ds_string_read(name, 64, f)) { 
     113            if (!lib3ds_string_read(name, 64, strm)) { 
    114114              return(LIB3DS_FALSE); 
    115115            } 
    116116            strcpy(mesh->box_map.left, name); 
    117             if (!lib3ds_string_read(name, 64, f)) { 
     117            if (!lib3ds_string_read(name, 64, strm)) { 
    118118              return(LIB3DS_FALSE); 
    119119            } 
    120120            strcpy(mesh->box_map.right, name); 
    121             if (!lib3ds_string_read(name, 64, f)) { 
     121            if (!lib3ds_string_read(name, 64, strm)) { 
    122122              return(LIB3DS_FALSE); 
    123123            } 
    124124            strcpy(mesh->box_map.top, name); 
    125             if (!lib3ds_string_read(name, 64, f)) { 
     125            if (!lib3ds_string_read(name, 64, strm)) { 
    126126              return(LIB3DS_FALSE); 
    127127            } 
     
    135135     
    136136  } 
    137   lib3ds_chunk_read_end(&c, f); 
     137  lib3ds_chunk_read_end(&c, strm); 
    138138  return(LIB3DS_TRUE); 
    139139} 
     
    524524 */ 
    525525Lib3dsBool 
    526 lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f) 
     526lib3ds_mesh_read(Lib3dsMesh *mesh, iostream *strm) 
    527527{ 
    528528  Lib3dsChunk c; 
    529529  Lib3dsWord chunk; 
    530530 
    531   if (!lib3ds_chunk_read_start(&c, LIB3DS_N_TRI_OBJECT, f)) { 
    532     return(LIB3DS_FALSE); 
    533   } 
    534  
    535   while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) { 
     531  if (!lib3ds_chunk_read_start(&c, LIB3DS_N_TRI_OBJECT, strm)) { 
     532    return(LIB3DS_FALSE); 
     533  } 
     534 
     535  while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) { 
    536536    switch (chunk) { 
    537537      case LIB3DS_MESH_MATRIX: 
     
    542542          for (i=0; i<4; i++) { 
    543543            for (j=0; j<3; j++) { 
    544               mesh->matrix[i][j]=lib3ds_float_read(f); 
     544              mesh->matrix[i][j]=lib3ds_float_read(strm); 
    545545            } 
    546546          } 
     
    549549      case LIB3DS_MESH_COLOR: 
    550550        { 
    551           mesh->color=lib3ds_byte_read(f); 
     551          mesh->color=lib3ds_byte_read(strm); 
    552552        } 
    553553        break; 
     
    558558           
    559559          lib3ds_mesh_free_point_list(mesh); 
    560           points=lib3ds_word_read(f); 
     560          points=lib3ds_word_read(strm); 
    561561          if (points) { 
    562562            if (!lib3ds_mesh_new_point_list(mesh, points)) { 
     
    566566            for (i=0; i<mesh->points; ++i) { 
    567567              for (j=0; j<3; ++j) { 
    568                 mesh->pointL[i].pos[j]=lib3ds_float_read(f); 
     568                mesh->pointL[i].pos[j]=lib3ds_float_read(strm); 
    569569              } 
    570570            } 
     
    580580           
    581581          lib3ds_mesh_free_flag_list(mesh); 
    582           flags=lib3ds_word_read(f); 
     582          flags=lib3ds_word_read(strm); 
    583583          if (flags) { 
    584584            if (!lib3ds_mesh_new_flag_list(mesh, flags)) { 
     
    587587            } 
    588588            for (i=0; i<mesh->flags; ++i) { 
    589               mesh->flagL[i]=lib3ds_word_read(f); 
     589              mesh->flagL[i]=lib3ds_word_read(strm); 
    590590            } 
    591591            ASSERT((!mesh->points) || (mesh->flags==mesh->points)); 
     
    596596      case LIB3DS_FACE_ARRAY: 
    597597        { 
    598           lib3ds_chunk_read_reset(&c, f); 
    599           if (!face_array_read(mesh, f)) { 
     598          lib3ds_chunk_read_reset(&c, strm); 
     599          if (!face_array_read(mesh, strm)) { 
    600600            return(LIB3DS_FALSE); 
    601601          } 
     
    607607 
    608608          for (i=0; i<2; ++i) { 
    609             mesh->map_data.tile[i]=lib3ds_float_read(f); 
     609            mesh->map_data.tile[i]=lib3ds_float_read(strm); 
    610610          } 
    611611          for (i=0; i<3; ++i) { 
    612             mesh->map_data.pos[i]=lib3ds_float_read(f); 
    613           } 
    614           mesh->map_data.scale=lib3ds_float_read(f); 
     612            mesh->map_data.pos[i]=lib3ds_float_read(strm); 
     613          } 
     614          mesh->map_data.scale=lib3ds_float_read(strm); 
    615615 
    616616          lib3ds_matrix_identity(mesh->map_data.matrix); 
    617617          for (i=0; i<4; i++) { 
    618618            for (j=0; j<3; j++) { 
    619               mesh->map_data.matrix[i][j]=lib3ds_float_read(f); 
     619              mesh->map_data.matrix[i][j]=lib3ds_float_read(strm); 
    620620            } 
    621621          } 
    622622          for (i=0; i<2; ++i) { 
    623             mesh->map_data.planar_size[i]=lib3ds_float_read(f); 
    624           } 
    625           mesh->map_data.cylinder_height=lib3ds_float_read(f); 
     623            mesh->map_data.planar_size[i]=lib3ds_float_read(strm); 
     624          } 
     625          mesh->map_data.cylinder_height=lib3ds_float_read(strm); 
    626626        } 
    627627        break; 
     
    632632           
    633633          lib3ds_mesh_free_texel_list(mesh); 
    634           texels=lib3ds_word_read(f); 
     634          texels=lib3ds_word_read(strm); 
    635635          if (texels) { 
    636636            if (!lib3ds_mesh_new_texel_list(mesh, texels)) { 
     
    639639            } 
    640640            for (i=0; i<mesh->texels; ++i) { 
    641               mesh->texelL[i][0]=lib3ds_float_read(f); 
    642               mesh->texelL[i][1]=lib3ds_float_read(f); 
     641              mesh->texelL[i][0]=lib3ds_float_read(strm); 
     642              mesh->texelL[i][1]=lib3ds_float_read(strm); 
    643643            } 
    644644            ASSERT((!mesh->points) || (mesh->texels==mesh->points)); 
     
    667667  } 
    668668   
    669   lib3ds_chunk_read_end(&c, f); 
     669  lib3ds_chunk_read_end(&c, strm); 
    670670  return(LIB3DS_TRUE); 
    671671} 
     
    673673 
    674674static Lib3dsBool 
    675 point_array_write(Lib3dsMesh *mesh, FILE *f) 
     675point_array_write(Lib3dsMesh *mesh, iostream *strm) 
    676676{ 
    677677  Lib3dsChunk c; 
     
    684684  c.chunk=LIB3DS_POINT_ARRAY; 
    685685  c.size=8+12*mesh->points; 
    686   lib3ds_chunk_write(&c, f); 
    687    
    688   lib3ds_word_write((Lib3dsWord)mesh->points, f); 
     686  lib3ds_chunk_write(&c, strm); 
     687   
     688  lib3ds_word_write((Lib3dsWord)mesh->points, strm); 
    689689  for (i=0; i<mesh->points; ++i) { 
    690     lib3ds_vector_write(mesh->pointL[i].pos, f); 
     690    lib3ds_vector_write(mesh->pointL[i].pos, strm); 
    691691  } 
    692692  return(LIB3DS_TRUE); 
     
    695695 
    696696static Lib3dsBool 
    697 flag_array_write(Lib3dsMesh *mesh, FILE *f) 
     697flag_array_write(Lib3dsMesh *mesh, iostream *strm) 
    698698{ 
    699699  Lib3dsChunk c; 
     
    706706  c.chunk=LIB3DS_POINT_FLAG_ARRAY; 
    707707  c.size=8+2*mesh->flags; 
    708   lib3ds_chunk_write(&c, f); 
    709    
    710   lib3ds_word_write((Lib3dsWord)mesh->flags, f); 
     708  lib3ds_chunk_write(&c, strm); 
     709   
     710  lib3ds_word_write((Lib3dsWord)mesh->flags, strm); 
    711711  for (i=0; i<mesh->flags; ++i) { 
    712     lib3ds_word_write(mesh->flagL[i], f); 
     712    lib3ds_word_write(mesh->flagL[i], strm); 
    713713  } 
    714714  return(LIB3DS_TRUE); 
     
    717717 
    718718static Lib3dsBool 
    719 face_array_write(Lib3dsMesh *mesh, FILE *f) 
     719face_array_write(Lib3dsMesh *mesh, iostream *strm) 
    720720{ 
    721721  Lib3dsChunk c; 
     
    726726  ASSERT(mesh->faces<0x10000); 
    727727  c.chunk=LIB3DS_FACE_ARRAY; 
    728   if (!lib3ds_chunk_write_start(&c, f)) { 
     728  if (!lib3ds_chunk_write_start(&c, strm)) { 
    729729    return(LIB3DS_FALSE); 
    730730  } 
     
    732732    unsigned i; 
    733733 
    734     lib3ds_word_write((Lib3dsWord)mesh->faces, f); 
     734    lib3ds_word_write((Lib3dsWord)mesh->faces, strm); 
    735735    for (i=0; i<mesh->faces; ++i) { 
    736       lib3ds_word_write(mesh->faceL[i].points[0], f); 
    737       lib3ds_word_write(mesh->faceL[i].points[1], f); 
    738       lib3ds_word_write(mesh->faceL[i].points[2], f); 
    739       lib3ds_word_write(mesh->faceL[i].flags, f); 
     736      lib3ds_word_write(mesh->faceL[i].points[0], strm); 
     737      lib3ds_word_write(mesh->faceL[i].points[1], strm); 
     738      lib3ds_word_write(mesh->faceL[i].points[2], strm); 
     739      lib3ds_word_write(mesh->faceL[i].flags, strm); 
    740740    } 
    741741  } 
     
    761761        c.chunk=LIB3DS_MSH_MAT_GROUP; 
    762762        c.size=6+ strlen(mesh->faceL[i].material)+1 +2+2*num; 
    763         lib3ds_chunk_write(&c, f); 
    764         lib3ds_string_write(mesh->faceL[i].material, f); 
    765         lib3ds_word_write(num, f); 
    766         lib3ds_word_write((Lib3dsWord)i, f); 
     763        lib3ds_chunk_write(&c, strm); 
     764        lib3ds_string_write(mesh->faceL[i].material, strm); 
     765        lib3ds_word_write(num, strm); 
     766        lib3ds_word_write((Lib3dsWord)i, strm); 
    767767         
    768768        for (j=i+1; j<mesh->faces; ++j) { 
    769769          if (strcmp(mesh->faceL[i].material, mesh->faceL[j].material)==0) { 
    770             lib3ds_word_write((Lib3dsWord)j, f); 
     770            lib3ds_word_write((Lib3dsWord)j, strm); 
    771771            matf[j]=1; 
    772772          } 
     
    783783    c.chunk=LIB3DS_SMOOTH_GROUP; 
    784784    c.size=6+4*mesh->faces; 
    785     lib3ds_chunk_write(&c, f); 
     785    lib3ds_chunk_write(&c, strm); 
    786786     
    787787    for (i=0; i<mesh->faces; ++i) { 
    788       lib3ds_dword_write(mesh->faceL[i].smoothing, f); 
     788      lib3ds_dword_write(mesh->faceL[i].smoothing, strm); 
    789789    } 
    790790  } 
     
    801801     
    802802      c.chunk=LIB3DS_MSH_BOXMAP; 
    803       if (!lib3ds_chunk_write_start(&c, f)) { 
     803      if (!lib3ds_chunk_write_start(&c, strm)) { 
    804804        return(LIB3DS_FALSE); 
    805805      } 
    806806       
    807       lib3ds_string_write(mesh->box_map.front, f); 
    808       lib3ds_string_write(mesh->box_map.back, f); 
    809       lib3ds_string_write(mesh->box_map.left, f); 
    810       lib3ds_string_write(mesh->box_map.right, f); 
    811       lib3ds_string_write(mesh->box_map.top, f); 
    812       lib3ds_string_write(mesh->box_map.bottom, f); 
     807      lib3ds_string_write(mesh->box_map.front, strm); 
     808      lib3ds_string_write(mesh->box_map.back, strm); 
     809      lib3ds_string_write(mesh->box_map.left, strm); 
     810      lib3ds_string_write(mesh->box_map.right, strm); 
     811      lib3ds_string_write(mesh->box_map.top, strm); 
     812      lib3ds_string_write(mesh->box_map.bottom, strm); 
    813813       
    814       if (!lib3ds_chunk_write_end(&c, f)) { 
     814      if (!lib3ds_chunk_write_end(&c, strm)) { 
    815815        return(LIB3DS_FALSE); 
    816816      } 
     
    818818  } 
    819819 
    820   if (!lib3ds_chunk_write_end(&c, f)) { 
     820  if (!lib3ds_chunk_write_end(&c, strm)) { 
    821821    return(LIB3DS_FALSE); 
    822822  } 
     
    826826 
    827827static Lib3dsBool 
    828 texel_array_write(Lib3dsMesh *mesh, FILE *f) 
     828texel_array_write(Lib3dsMesh *mesh, iostream *strm) 
    829829{ 
    830830  Lib3dsChunk c; 
     
    837837  c.chunk=LIB3DS_TEX_VERTS; 
    838838  c.size=8+8*mesh->texels; 
    839   lib3ds_chunk_write(&c, f); 
    840    
    841   lib3ds_word_write((Lib3dsWord)mesh->texels, f); 
     839  lib3ds_chunk_write(&c, strm); 
     840   
     841  lib3ds_word_write((Lib3dsWord)mesh->texels, strm); 
    842842  for (i=0; i<mesh->texels; ++i) { 
    843     lib3ds_float_write(mesh->texelL[i][0], f); 
    844     lib3ds_float_write(mesh->texelL[i][1], f); 
     843    lib3ds_float_write(mesh->texelL[i][0], strm); 
     844    lib3ds_float_write(mesh->texelL[i][1], strm); 
    845845  } 
    846846  return(LIB3DS_TRUE); 
     
    852852 */ 
    853853Lib3dsBool 
    854 lib3ds_mesh_write(Lib3dsMesh *mesh, FILE *f) 
     854lib3ds_mesh_write(Lib3dsMesh *mesh, iostream *strm) 
    855855{ 
    856856  Lib3dsChunk c; 
    857857 
    858858  c.chunk=LIB3DS_N_TRI_OBJECT; 
    859   if (!lib3ds_chunk_write_start(&c,f)) { 
    860     return(LIB3DS_FALSE); 
    861   } 
    862   if (!point_array_write(mesh, f)) { 
    863     return(LIB3DS_FALSE); 
    864   } 
    865   if (!texel_array_write(mesh, f)) { 
     859  if (!lib3ds_chunk_write_start(&c,strm)) { 
     860    return(LIB3DS_FALSE); 
     861  } 
     862  if (!point_array_write(mesh, strm)) { 
     863    return(LIB3DS_FALSE); 
     864  } 
     865  if (!texel_array_write(mesh, strm)) { 
    866866    return(LIB3DS_FALSE); 
    867867  } 
     
    873873    c.chunk=LIB3DS_MESH_TEXTURE_INFO; 
    874874    c.size=92; 
    875     if (!lib3ds_chunk_write(&c,f)) { 
     875    if (!lib3ds_chunk_write(&c,strm)) { 
    876876      return(LIB3DS_FALSE); 
    877877    } 
    878878 
    879     lib3ds_word_write(mesh->map_data.maptype, f); 
     879    lib3ds_word_write(mesh->map_data.maptype, strm); 
    880880 
    881881    for (i=0; i<2; ++i) { 
    882       lib3ds_float_write(mesh->map_data.tile[i], f); 
     882      lib3ds_float_write(mesh->map_data.tile[i], strm); 
    883883    } 
    884884    for (i=0; i<3; ++i) { 
    885       lib3ds_float_write(mesh->map_data.pos[i], f); 
    886     } 
    887     lib3ds_float_write(mesh->map_data.scale, f); 
     885      lib3ds_float_write(mesh->map_data.pos[i], strm); 
     886    } 
     887    lib3ds_float_write(mesh->map_data.scale, strm); 
    888888 
    889889    for (i=0; i<4; i++) { 
    890890      for (j=0; j<3; j++) { 
    891         lib3ds_float_write(mesh->map_data.matrix[i][j], f); 
     891        lib3ds_float_write(mesh->map_data.matrix[i][j], strm); 
    892892      } 
    893893    } 
    894894    for (i=0; i<2; ++i) { 
    895       lib3ds_float_write(mesh->map_data.planar_size[i], f); 
    896     } 
    897     lib3ds_float_write(mesh->map_data.cylinder_height, f); 
    898   } 
    899  
    900   if (!flag_array_write(mesh, f)) { 
     895      lib3ds_float_write(mesh->map_data.planar_size[i], strm); 
     896    } 
     897    lib3ds_float_write(mesh->map_data.cylinder_height, strm); 
     898  } 
     899 
     900  if (!flag_array_write(mesh, strm)) { 
    901901    return(LIB3DS_FALSE); 
    902902  } 
     
    907907    c.chunk=LIB3DS_MESH_MATRIX; 
    908908    c.size=54; 
    909     if (!lib3ds_chunk_write(&c,f)) { 
     909    if (!lib3ds_chunk_write(&c,strm)) { 
    910910      return(LIB3DS_FALSE); 
    911911    } 
    912912    for (i=0; i<4; i++) { 
    913913      for (j=0; j<3; j++) { 
    914         lib3ds_float_write(mesh->matrix[i][j], f); 
     914        lib3ds_float_write(mesh->matrix[i][j], strm); 
    915915      } 
    916916    } 
     
    922922    c.chunk=LIB3DS_MESH_COLOR; 
    923923    c.size=7; 
    924     if (!lib3ds_chunk_write(&c,f)) { 
     924    if (!lib3ds_chunk_write(&c,strm)) { 
    925925      return(LIB3DS_FALSE); 
    926926    } 
    927     lib3ds_byte_write(mesh->color, f); 
    928   } 
    929   if (!face_array_write(mesh, f)) { 
    930     return(LIB3DS_FALSE); 
    931   } 
    932  
    933   if (!lib3ds_chunk_write_end(&c,f)) { 
     927    lib3ds_byte_write(mesh->color, strm); 
     928  } 
     929  if (!face_array_write(mesh, strm)) { 
     930    return(LIB3DS_FALSE); 
     931  } 
     932 
     933  if (!lib3ds_chunk_write_end(&c,strm)) { 
    934934    return(LIB3DS_FALSE); 
    935935  }