FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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).

Browse Source 
From Robert Osfield, ammendments of the above to better support reading of files from local directories.
This commit is contained in:
Robert Osfield
2009-04-22 15:46:24 +00:00
parent 517afd3050
commit e8d9dd142d
29 changed files with 1259 additions and 1154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
src/osgPlugins/3ds/ReaderWriter3DS.cpp
View File

@@ -34,6 +34,7 @@
#include <set>
#include <map>
#include <iostream>
#include <sstream>
using namespace std;
using namespace osg;
@@ -95,8 +96,10 @@ class ReaderWriter3DS : public osgDB::ReaderWriter
virtual const char* className() const { return "3DS Auto Studio Reader"; }
virtual ReadResult readNode(const std::string& file, const osgDB::ReaderWriter::Options* options) const;
virtual ReadResult readNode(std::istream& fin, const Options* options) const;
protected:
ReadResult constructFrom3dsFile(Lib3dsFile *f,const std::string& filename, const Options* options) const;
class ReaderObject
@@ -440,9 +443,29 @@ osg::Node* ReaderWriter3DS::ReaderObject::processNode(StateSetMap drawStateMap,L
}
}
osgDB::ReaderWriter::ReadResult ReaderWriter3DS::readNode(std::istream& fin, const osgDB::ReaderWriter::Options* options) const
{
osgDB::ReaderWriter::ReadResult result = ReadResult::FILE_NOT_HANDLED;
std::string optFileName = "";
if (options)
{
optFileName = options->getPluginStringData("STREAM_FILENAME");
}
Lib3dsFile *f = lib3ds_stream_load((iostream *) &fin);
if (f)
{
result = constructFrom3dsFile(f,optFileName,options);
lib3ds_file_free(f);
}
return(result);
}
osgDB::ReaderWriter::ReadResult ReaderWriter3DS::readNode(const std::string& file, const osgDB::ReaderWriter::Options* options) const
{
osgDB::ReaderWriter::ReadResult result = ReadResult::FILE_NOT_HANDLED;
std::string ext = osgDB::getLowerCaseFileExtension(file);
if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;
@@ -450,7 +473,22 @@ osgDB::ReaderWriter::ReadResult ReaderWriter3DS::readNode(const std::string& fil
std::string fileName = osgDB::findDataFile( file, options );
if (fileName.empty()) return ReadResult::FILE_NOT_FOUND;
Lib3dsFile *f = lib3ds_file_load(fileName.c_str());
Lib3dsFile *f = lib3ds_file_load(fileName.c_str(),options);
if (f)
{
osg::ref_ptr<Options> local_opt = options ? static_cast<Options*>(options->clone(osg::CopyOp::SHALLOW_COPY)) : new Options;
local_opt->getDatabasePathList().push_front(osgDB::getFilePath(fileName));
result = constructFrom3dsFile(f,file,local_opt.get());
lib3ds_file_free(f);
}
return result;
}
osgDB::ReaderWriter::ReadResult ReaderWriter3DS::constructFrom3dsFile(Lib3dsFile *f,const std::string& fileName, const osgDB::ReaderWriter::Options* options) const
{
if (f==NULL) return ReadResult::FILE_NOT_HANDLED;
// MIKEC
@@ -461,7 +499,7 @@ osgDB::ReaderWriter::ReadResult ReaderWriter3DS::readNode(const std::string& fil
ReaderObject reader;
reader._directory = osgDB::getFilePath(fileName);
reader._directory = options->getDatabasePathList().empty() ? osgDB::getFilePath(fileName) : options->getDatabasePathList().front();
osg::Group* group = new osg::Group;
group->setName(fileName);
@@ -515,8 +553,6 @@ osgDB::ReaderWriter::ReadResult ReaderWriter3DS::readNode(const std::string& fil
group->accept(pv);
}
lib3ds_file_free(f);
return group;
}
@@ -690,17 +726,26 @@ osg::Texture2D* ReaderWriter3DS::ReaderObject::createTexture(Lib3dsTextureMap *
{
if (texture && *(texture->name))
{
osg::notify(osg::NOTICE)<<"texture->name="<<texture->name<<", _directory="<<_directory<<std::endl;
std::string fileName = osgDB::findFileInDirectory(texture->name,_directory,osgDB::CASE_INSENSITIVE);
if (fileName.empty())
{
// file not found in .3ds file's directory, so we'll look in the datafile path list.
fileName = osgDB::findDataFile(texture->name,options, osgDB::CASE_INSENSITIVE);
}
if (fileName.empty())
{
osg::notify(osg::WARN) << "texture '"<<texture->name<<"' not found"<< std::endl;
return NULL;
if (osgDB::containsServerAddress(_directory))
{
// if 3DS file is loaded from http, just attempt to load texture from same location.
fileName = _directory + "/" + texture->name;
} else {
osg::notify(osg::WARN) << "texture '"<<texture->name<<"' not found"<< std::endl;
return NULL;
}
}
if (label) osg::notify(osg::DEBUG_INFO) << label;
@@ -821,7 +866,7 @@ osg::StateSet* ReaderWriter3DS::ReaderObject::createStateSet(Lib3dsMaterial *mat
// stateset->setTextureAttribute(0,texenv);
}
if (transparency>0.0f || textureTransparancy || mat->opacity_map.flags!=0)
if (transparency>0.0f || textureTransparancy)
{
stateset->setMode(GL_BLEND,osg::StateAttribute::ON);
stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);

130
src/osgPlugins/3ds/atmosphere.cpp
View File

@@ -33,27 +33,27 @@
static Lib3dsBool
fog_read(Lib3dsFog *fog, FILE *f)
fog_read(Lib3dsFog *fog, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_FOG, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_FOG, strm)) {
return(LIB3DS_FALSE);
}
fog->near_plane=lib3ds_float_read(f);
fog->near_density=lib3ds_float_read(f);
fog->far_plane=lib3ds_float_read(f);
fog->far_density=lib3ds_float_read(f);
lib3ds_chunk_read_tell(&c, f);
fog->near_plane=lib3ds_float_read(strm);
fog->near_density=lib3ds_float_read(strm);
fog->far_plane=lib3ds_float_read(strm);
fog->far_density=lib3ds_float_read(strm);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_LIN_COLOR_F:
{
int i;
for (i=0; i<3; ++i) {
fog->col[i]=lib3ds_float_read(f);
fog->col[i]=lib3ds_float_read(strm);
}
}
break;
@@ -69,60 +69,60 @@ fog_read(Lib3dsFog *fog, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
layer_fog_read(Lib3dsLayerFog *fog, FILE *f)
layer_fog_read(Lib3dsLayerFog *fog, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_LAYER_FOG, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_LAYER_FOG, strm)) {
return(LIB3DS_FALSE);
}
fog->near_y=lib3ds_float_read(f);
fog->far_y=lib3ds_float_read(f);
fog->density=lib3ds_float_read(f);
fog->flags=lib3ds_dword_read(f);
lib3ds_chunk_read_tell(&c, f);
fog->near_y=lib3ds_float_read(strm);
fog->far_y=lib3ds_float_read(strm);
fog->density=lib3ds_float_read(strm);
fog->flags=lib3ds_dword_read(strm);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_LIN_COLOR_F:
lib3ds_rgb_read(fog->col,f);
lib3ds_rgb_read(fog->col,strm);
break;
case LIB3DS_COLOR_F:
lib3ds_rgb_read(fog->col,f);
lib3ds_rgb_read(fog->col,strm);
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
distance_cue_read(Lib3dsDistanceCue *cue, FILE *f)
distance_cue_read(Lib3dsDistanceCue *cue, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_DISTANCE_CUE, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_DISTANCE_CUE, strm)) {
return(LIB3DS_FALSE);
}
cue->near_plane=lib3ds_float_read(f);
cue->near_dimming=lib3ds_float_read(f);
cue->far_plane=lib3ds_float_read(f);
cue->far_dimming=lib3ds_float_read(f);
lib3ds_chunk_read_tell(&c, f);
cue->near_plane=lib3ds_float_read(strm);
cue->near_dimming=lib3ds_float_read(strm);
cue->far_plane=lib3ds_float_read(strm);
cue->far_dimming=lib3ds_float_read(strm);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_DCUE_BGND:
{
@@ -134,7 +134,7 @@ distance_cue_read(Lib3dsDistanceCue *cue, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -143,35 +143,35 @@ distance_cue_read(Lib3dsDistanceCue *cue, FILE *f)
* \ingroup atmosphere
*/
Lib3dsBool
lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, FILE *f)
lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, iostream *strm)
{
Lib3dsChunk c;
if (!lib3ds_chunk_read(&c, f)) {
if (!lib3ds_chunk_read(&c, strm)) {
return(LIB3DS_FALSE);
}
switch (c.chunk) {
case LIB3DS_FOG:
{
lib3ds_chunk_read_reset(&c, f);
if (!fog_read(&atmosphere->fog, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!fog_read(&atmosphere->fog, strm)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_LAYER_FOG:
{
lib3ds_chunk_read_reset(&c, f);
if (!layer_fog_read(&atmosphere->layer_fog, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!layer_fog_read(&atmosphere->layer_fog, strm)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_DISTANCE_CUE:
{
lib3ds_chunk_read_reset(&c, f);
if (!distance_cue_read(&atmosphere->dist_cue, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!distance_cue_read(&atmosphere->dist_cue, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -201,32 +201,32 @@ lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, FILE *f)
* \ingroup atmosphere
*/
Lib3dsBool
lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, FILE *f)
lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, iostream *strm)
{
if (atmosphere->fog.use) { /*---- LIB3DS_FOG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_FOG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_float_write(atmosphere->fog.near_plane,f);
lib3ds_float_write(atmosphere->fog.near_density,f);
lib3ds_float_write(atmosphere->fog.far_plane,f);
lib3ds_float_write(atmosphere->fog.far_density,f);
lib3ds_float_write(atmosphere->fog.near_plane,strm);
lib3ds_float_write(atmosphere->fog.near_density,strm);
lib3ds_float_write(atmosphere->fog.far_plane,strm);
lib3ds_float_write(atmosphere->fog.far_density,strm);
{
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_rgb_write(atmosphere->fog.col,f);
lib3ds_chunk_write(&c,strm);
lib3ds_rgb_write(atmosphere->fog.col,strm);
}
if (atmosphere->fog.fog_background) {
Lib3dsChunk c;
c.chunk=LIB3DS_FOG_BGND;
c.size=6;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -235,37 +235,37 @@ lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_LAYER_FOG;
c.size=40;
lib3ds_chunk_write(&c,f);
lib3ds_float_write(atmosphere->layer_fog.near_y,f);
lib3ds_float_write(atmosphere->layer_fog.far_y,f);
lib3ds_float_write(atmosphere->layer_fog.near_y,f);
lib3ds_dword_write(atmosphere->layer_fog.flags,f);
lib3ds_chunk_write(&c,strm);
lib3ds_float_write(atmosphere->layer_fog.near_y,strm);
lib3ds_float_write(atmosphere->layer_fog.far_y,strm);
lib3ds_float_write(atmosphere->layer_fog.near_y,strm);
lib3ds_dword_write(atmosphere->layer_fog.flags,strm);
{
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_rgb_write(atmosphere->fog.col,f);
lib3ds_chunk_write(&c,strm);
lib3ds_rgb_write(atmosphere->fog.col,strm);
}
}
if (atmosphere->dist_cue.use) { /*---- LIB3DS_DISTANCE_CUE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DISTANCE_CUE;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_float_write(atmosphere->dist_cue.near_plane,f);
lib3ds_float_write(atmosphere->dist_cue.near_dimming,f);
lib3ds_float_write(atmosphere->dist_cue.far_plane,f);
lib3ds_float_write(atmosphere->dist_cue.far_dimming,f);
lib3ds_float_write(atmosphere->dist_cue.near_plane,strm);
lib3ds_float_write(atmosphere->dist_cue.near_dimming,strm);
lib3ds_float_write(atmosphere->dist_cue.far_plane,strm);
lib3ds_float_write(atmosphere->dist_cue.far_dimming,strm);
if (atmosphere->dist_cue.cue_background) {
Lib3dsChunk c;
c.chunk=LIB3DS_DCUE_BGND;
c.size=6;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -274,21 +274,21 @@ lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_USE_FOG;
c.size=6;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
}
if (atmosphere->layer_fog.use) { /*---- LIB3DS_USE_LAYER_FOG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_USE_LAYER_FOG;
c.size=6;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
}
if (atmosphere->dist_cue.use) { /*---- LIB3DS_USE_DISTANCE_CUE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_USE_V_GRADIENT;
c.size=6;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
}
return(LIB3DS_TRUE);

7
src/osgPlugins/3ds/atmosphere.h
View File

@@ -27,6 +27,9 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
@@ -91,8 +94,8 @@ struct _Lib3dsAtmosphere {
Lib3dsDistanceCue dist_cue;
};
extern LIB3DSAPI Lib3dsBool lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, iostream *strm);
#ifdef __cplusplus
}

78
src/osgPlugins/3ds/background.cpp
View File

@@ -35,35 +35,35 @@
static Lib3dsBool
solid_bgnd_read(Lib3dsBackground *background, FILE *f)
solid_bgnd_read(Lib3dsBackground *background, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_SOLID_BGND, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_SOLID_BGND, strm)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_LIN_COLOR_F:
lib3ds_rgb_read(background->solid.col, f);
lib3ds_rgb_read(background->solid.col, strm);
break;
case LIB3DS_COLOR_F:
lib3ds_rgb_read(background->solid.col, f);
lib3ds_rgb_read(background->solid.col, strm);
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
v_gradient_read(Lib3dsBackground *background, FILE *f)
v_gradient_read(Lib3dsBackground *background, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
@@ -72,21 +72,21 @@ v_gradient_read(Lib3dsBackground *background, FILE *f)
int have_lin=0;
if (!lib3ds_chunk_read_start(&c, LIB3DS_V_GRADIENT, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_V_GRADIENT, strm)) {
return(LIB3DS_FALSE);
}
background->gradient.percent=lib3ds_float_read(f);
lib3ds_chunk_read_tell(&c, f);
background->gradient.percent=lib3ds_float_read(strm);
lib3ds_chunk_read_tell(&c, strm);
index[0]=index[1]=0;
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_COLOR_F:
lib3ds_rgb_read(col[0][index[0]],f);
lib3ds_rgb_read(col[0][index[0]],strm);
index[0]++;
break;
case LIB3DS_LIN_COLOR_F:
lib3ds_rgb_read(col[1][index[1]],f);
lib3ds_rgb_read(col[1][index[1]],strm);
index[1]++;
have_lin=1;
break;
@@ -102,7 +102,7 @@ v_gradient_read(Lib3dsBackground *background, FILE *f)
background->gradient.bottom[i]=col[have_lin][2][i];
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -111,34 +111,34 @@ v_gradient_read(Lib3dsBackground *background, FILE *f)
* \ingroup background
*/
Lib3dsBool
lib3ds_background_read(Lib3dsBackground *background, FILE *f)
lib3ds_background_read(Lib3dsBackground *background, iostream *strm)
{
Lib3dsChunk c;
if (!lib3ds_chunk_read(&c, f)) {
if (!lib3ds_chunk_read(&c, strm)) {
return(LIB3DS_FALSE);
}
switch (c.chunk) {
case LIB3DS_BIT_MAP:
{
if (!lib3ds_string_read(background->bitmap.name, 64, f)) {
if (!lib3ds_string_read(background->bitmap.name, 64, strm)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_SOLID_BGND:
{
lib3ds_chunk_read_reset(&c, f);
if (!solid_bgnd_read(background, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!solid_bgnd_read(background, strm)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_V_GRADIENT:
{
lib3ds_chunk_read_reset(&c, f);
if (!v_gradient_read(background, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!v_gradient_read(background, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -165,19 +165,19 @@ lib3ds_background_read(Lib3dsBackground *background, FILE *f)
static Lib3dsBool
colorf_write(Lib3dsRgba rgb, FILE *f)
colorf_write(Lib3dsRgba rgb, iostream *strm)
{
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_rgb_write(rgb,f);
lib3ds_chunk_write(&c,strm);
lib3ds_rgb_write(rgb,strm);
c.chunk=LIB3DS_LIN_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_rgb_write(rgb,f);
lib3ds_chunk_write(&c,strm);
lib3ds_rgb_write(rgb,strm);
return(LIB3DS_TRUE);
}
@@ -199,22 +199,22 @@ colorf_defined(Lib3dsRgba rgb)
* \ingroup background
*/
Lib3dsBool
lib3ds_background_write(Lib3dsBackground *background, FILE *f)
lib3ds_background_write(Lib3dsBackground *background, iostream *strm)
{
if (strlen(background->bitmap.name)) { /*---- LIB3DS_BIT_MAP ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_BIT_MAP;
c.size=6+1+strlen(background->bitmap.name);
lib3ds_chunk_write(&c,f);
lib3ds_string_write(background->bitmap.name, f);
lib3ds_chunk_write(&c,strm);
lib3ds_string_write(background->bitmap.name, strm);
}
if (colorf_defined(background->solid.col)) { /*---- LIB3DS_SOLID_BGND ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SOLID_BGND;
c.size=42;
lib3ds_chunk_write(&c,f);
colorf_write(background->solid.col,f);
lib3ds_chunk_write(&c,strm);
colorf_write(background->solid.col,strm);
}
if (colorf_defined(background->gradient.top) ||
@@ -223,32 +223,32 @@ lib3ds_background_write(Lib3dsBackground *background, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_V_GRADIENT;
c.size=118;
lib3ds_chunk_write(&c,f);
lib3ds_float_write(background->gradient.percent,f);
colorf_write(background->gradient.top,f);
colorf_write(background->gradient.middle,f);
colorf_write(background->gradient.bottom,f);
lib3ds_chunk_write(&c,strm);
lib3ds_float_write(background->gradient.percent,strm);
colorf_write(background->gradient.top,strm);
colorf_write(background->gradient.middle,strm);
colorf_write(background->gradient.bottom,strm);
}
if (background->bitmap.use) { /*---- LIB3DS_USE_BIT_MAP ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_USE_BIT_MAP;
c.size=6;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
}
if (background->solid.use) { /*---- LIB3DS_USE_SOLID_BGND ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_USE_SOLID_BGND;
c.size=6;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
}
if (background->gradient.use) { /*---- LIB3DS_USE_V_GRADIENT ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_USE_V_GRADIENT;
c.size=6;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
}
return(LIB3DS_TRUE);

7
src/osgPlugins/3ds/background.h
View File

@@ -27,6 +27,9 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
@@ -71,8 +74,8 @@ struct _Lib3dsBackground {
Lib3dsGradient gradient;
};
extern LIB3DSAPI Lib3dsBool lib3ds_background_read(Lib3dsBackground *background, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_background_write(Lib3dsBackground *background, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_background_read(Lib3dsBackground *background, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_background_write(Lib3dsBackground *background, iostream *strm);
#ifdef __cplusplus
}

46
src/osgPlugins/3ds/camera.cpp
View File

@@ -96,27 +96,27 @@ lib3ds_camera_dump(Lib3dsCamera *camera)
* \ingroup camera
*/
Lib3dsBool
lib3ds_camera_read(Lib3dsCamera *camera, FILE *f)
lib3ds_camera_read(Lib3dsCamera *camera, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_N_CAMERA, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_N_CAMERA, strm)) {
return(LIB3DS_FALSE);
}
{
int i;
for (i=0; i<3; ++i) {
camera->position[i]=lib3ds_float_read(f);
camera->position[i]=lib3ds_float_read(strm);
}
for (i=0; i<3; ++i) {
camera->target[i]=lib3ds_float_read(f);
camera->target[i]=lib3ds_float_read(strm);
}
}
camera->roll=lib3ds_float_read(f);
camera->roll=lib3ds_float_read(strm);
{
float s;
s=lib3ds_float_read(f);
s=lib3ds_float_read(strm);
if (fabs(s)<LIB3DS_EPSILON) {
camera->fov=45.0;
}
@@ -124,9 +124,9 @@ lib3ds_camera_read(Lib3dsCamera *camera, FILE *f)
camera->fov=2400.0f/s;
}
}
lib3ds_chunk_read_tell(&c, f);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_CAM_SEE_CONE:
{
@@ -135,8 +135,8 @@ lib3ds_camera_read(Lib3dsCamera *camera, FILE *f)
break;
case LIB3DS_CAM_RANGES:
{
camera->near_range=lib3ds_float_read(f);
camera->far_range=lib3ds_float_read(f);
camera->near_range=lib3ds_float_read(strm);
camera->far_range=lib3ds_float_read(strm);
}
break;
default:
@@ -144,7 +144,7 @@ lib3ds_camera_read(Lib3dsCamera *camera, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -153,41 +153,41 @@ lib3ds_camera_read(Lib3dsCamera *camera, FILE *f)
* \ingroup camera
*/
Lib3dsBool
lib3ds_camera_write(Lib3dsCamera *camera, FILE *f)
lib3ds_camera_write(Lib3dsCamera *camera, iostream *strm)
{
Lib3dsChunk c;
c.chunk=LIB3DS_N_CAMERA;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_vector_write(camera->position, f);
lib3ds_vector_write(camera->target, f);
lib3ds_float_write(camera->roll, f);
lib3ds_vector_write(camera->position, strm);
lib3ds_vector_write(camera->target, strm);
lib3ds_float_write(camera->roll, strm);
if (fabs(camera->fov)<LIB3DS_EPSILON) {
lib3ds_float_write(2400.0f/45.0f, f);
lib3ds_float_write(2400.0f/45.0f, strm);
}
else {
lib3ds_float_write(2400.0f/camera->fov, f);
lib3ds_float_write(2400.0f/camera->fov, strm);
}
if (camera->see_cone) {
Lib3dsChunk c;
c.chunk=LIB3DS_CAM_SEE_CONE;
c.size=6;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
}
{
Lib3dsChunk c;
c.chunk=LIB3DS_CAM_RANGES;
c.size=14;
lib3ds_chunk_write(&c, f);
lib3ds_float_write(camera->near_range, f);
lib3ds_float_write(camera->far_range, f);
lib3ds_chunk_write(&c, strm);
lib3ds_float_write(camera->near_range, strm);
lib3ds_float_write(camera->far_range, strm);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);

7
src/osgPlugins/3ds/camera.h
View File

@@ -27,6 +27,9 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
@@ -50,8 +53,8 @@ struct _Lib3dsCamera {
extern LIB3DSAPI Lib3dsCamera* lib3ds_camera_new(const char *name);
extern LIB3DSAPI void lib3ds_camera_free(Lib3dsCamera *mesh);
extern LIB3DSAPI void lib3ds_camera_dump(Lib3dsCamera *camera);
extern LIB3DSAPI Lib3dsBool lib3ds_camera_read(Lib3dsCamera *camera, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_camera_write(Lib3dsCamera *camera, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_camera_read(Lib3dsCamera *camera, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_camera_write(Lib3dsCamera *camera, iostream *strm);
#ifdef __cplusplus
}

68
src/osgPlugins/3ds/chunk.cpp
View File

@@ -93,20 +93,20 @@ lib3ds_chunk_enable_dump(Lib3dsBool enable, Lib3dsBool unknown)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_chunk_read(Lib3dsChunk *c, FILE *f)
lib3ds_chunk_read(Lib3dsChunk *c, iostream *strm)
{
ASSERT(c);
ASSERT(f);
c->cur=ftell(f);
c->chunk=lib3ds_word_read(f);
c->size=lib3ds_dword_read(f);
ASSERT(strm);
c->cur=strm->tellg();
c->chunk=lib3ds_word_read(strm);
c->size=lib3ds_dword_read(strm);
c->end=c->cur+c->size;
c->cur+=6;
if (ferror(f) || (c->size<6)) {
if (strm->fail()||(c->size<6)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
}
@@ -114,11 +114,11 @@ lib3ds_chunk_read(Lib3dsChunk *c, FILE *f)
* \ingroup chunk
*/
Lib3dsBool
lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, FILE *f)
lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, iostream *strm)
{
ASSERT(c);
ASSERT(f);
if (!lib3ds_chunk_read(c, f)) {
ASSERT(strm);
if (!lib3ds_chunk_read(c, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_debug_enter(c);
@@ -130,9 +130,9 @@ lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, FILE *f)
* \ingroup chunk
*/
void
lib3ds_chunk_read_tell(Lib3dsChunk *c, FILE *f)
lib3ds_chunk_read_tell(Lib3dsChunk *c, iostream *strm)
{
c->cur=ftell(f);
c->cur=strm->tellg();
}
@@ -140,7 +140,7 @@ lib3ds_chunk_read_tell(Lib3dsChunk *c, FILE *f)
* \ingroup chunk
*/
Lib3dsWord
lib3ds_chunk_read_next(Lib3dsChunk *c, FILE *f)
lib3ds_chunk_read_next(Lib3dsChunk *c, iostream *strm)
{
Lib3dsChunk d;
@@ -149,9 +149,9 @@ lib3ds_chunk_read_next(Lib3dsChunk *c, FILE *f)
return(0);
}
fseek(f, (long)c->cur, SEEK_SET);
d.chunk=lib3ds_word_read(f);
d.size=lib3ds_dword_read(f);
strm->seekg((long)c->cur,ios_base::beg);
d.chunk=lib3ds_word_read(strm);
d.size=lib3ds_dword_read(strm);
lib3ds_chunk_debug_dump(&d);
c->cur+=d.size;
return(d.chunk);
@@ -162,9 +162,9 @@ lib3ds_chunk_read_next(Lib3dsChunk *c, FILE *f)
* \ingroup chunk
*/
void
lib3ds_chunk_read_reset(Lib3dsChunk *, FILE *f)
{
fseek(f, -6, SEEK_CUR);
lib3ds_chunk_read_reset(Lib3dsChunk *, iostream *strm)
{
strm->seekg(-6,ios_base::cur);
}
@@ -172,10 +172,10 @@ lib3ds_chunk_read_reset(Lib3dsChunk *, FILE *f)
* \ingroup chunk
*/
void
lib3ds_chunk_read_end(Lib3dsChunk *c, FILE *f)
lib3ds_chunk_read_end(Lib3dsChunk *c, iostream *strm)
{
lib3ds_chunk_debug_leave(c);
fseek(f, c->end, SEEK_SET);
strm->seekg(c->end,ios_base::beg);
}
@@ -190,14 +190,14 @@ lib3ds_chunk_read_end(Lib3dsChunk *c, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_chunk_write(Lib3dsChunk *c, FILE *f)
lib3ds_chunk_write(Lib3dsChunk *c, iostream *strm)
{
ASSERT(c);
if (!lib3ds_word_write(c->chunk, f)) {
if (!lib3ds_word_write(c->chunk, strm)) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}
if (!lib3ds_dword_write(c->size, f)) {
if (!lib3ds_dword_write(c->size, strm)) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}
@@ -209,15 +209,15 @@ lib3ds_chunk_write(Lib3dsChunk *c, FILE *f)
* \ingroup chunk
*/
Lib3dsBool
lib3ds_chunk_write_start(Lib3dsChunk *c, FILE *f)
lib3ds_chunk_write_start(Lib3dsChunk *c, iostream *strm)
{
ASSERT(c);
c->size=0;
c->cur=ftell(f);
if (!lib3ds_word_write(c->chunk, f)) {
c->cur=strm->tellp();
if (!lib3ds_word_write(c->chunk, strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_dword_write(c->size, f)) {
if (!lib3ds_dword_write(c->size, strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -228,19 +228,19 @@ lib3ds_chunk_write_start(Lib3dsChunk *c, FILE *f)
* \ingroup chunk
*/
Lib3dsBool
lib3ds_chunk_write_end(Lib3dsChunk *c, FILE *f)
lib3ds_chunk_write_end(Lib3dsChunk *c, iostream *strm)
{
ASSERT(c);
c->size=ftell(f) - c->cur;
fseek(f, c->cur+2, SEEK_SET);
if (!lib3ds_dword_write(c->size, f)) {
c->size=(Lib3dsDword)(strm->tellp()) - c->cur;
strm->seekp(c->cur+2,ios_base::beg);
if (!lib3ds_dword_write(c->size, strm)) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}
c->cur+=c->size;
fseek(f, c->cur, SEEK_SET);
if (ferror(f)) {
strm->seekp(c->cur, ios_base::beg);
if (strm->fail()) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}

22
src/osgPlugins/3ds/chunk.h
View File

@@ -27,10 +27,14 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
typedef enum _Lib3dsChunks {
LIB3DS_NULL_CHUNK =0x0000,
LIB3DS_M3DMAGIC =0x4D4D, /*3DS file*/
@@ -267,15 +271,15 @@ typedef struct _Lib3dsChunk {
} Lib3dsChunk;
extern LIB3DSAPI void lib3ds_chunk_enable_dump(Lib3dsBool enable, Lib3dsBool unknown);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_read(Lib3dsChunk *c, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, FILE *f);
extern LIB3DSAPI void lib3ds_chunk_read_tell(Lib3dsChunk *c, FILE *f);
extern LIB3DSAPI Lib3dsWord lib3ds_chunk_read_next(Lib3dsChunk *c, FILE *f);
extern LIB3DSAPI void lib3ds_chunk_read_reset(Lib3dsChunk *c, FILE *f);
extern LIB3DSAPI void lib3ds_chunk_read_end(Lib3dsChunk *c, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write(Lib3dsChunk *c, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write_start(Lib3dsChunk *c, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write_end(Lib3dsChunk *c, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_read(Lib3dsChunk *c, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_read_start(Lib3dsChunk *c, Lib3dsWord chunk, iostream *strm);
extern LIB3DSAPI void lib3ds_chunk_read_tell(Lib3dsChunk *c, iostream *strm);
extern LIB3DSAPI Lib3dsWord lib3ds_chunk_read_next(Lib3dsChunk *c, iostream *strm);
extern LIB3DSAPI void lib3ds_chunk_read_reset(Lib3dsChunk *c, iostream *strm);
extern LIB3DSAPI void lib3ds_chunk_read_end(Lib3dsChunk *c, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write(Lib3dsChunk *c, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write_start(Lib3dsChunk *c, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_chunk_write_end(Lib3dsChunk *c, iostream *strm);
extern LIB3DSAPI const char* lib3ds_chunk_name(Lib3dsWord chunk);
extern LIB3DSAPI void lib3ds_chunk_unknown(Lib3dsWord chunk);
extern LIB3DSAPI void lib3ds_chunk_dump_info(const char *format, ...);

336
src/osgPlugins/3ds/file.cpp
View File

@@ -37,8 +37,11 @@
#include <dmalloc.h>
#endif
#include <osgDB/FileUtils>
#include <istream>
#include <stdio.h>
//#include <strstream>
#include <sstream>
#include <fstream>
/*!
* \defgroup file Files
@@ -65,30 +68,43 @@
* \ingroup file
*/
Lib3dsFile*
lib3ds_file_load(const char *filename)
lib3ds_file_load(const char *filename, const osgDB::ReaderWriter::Options* options)
{
FILE *f;
Lib3dsFile *file;
f=osgDB::fopen(filename, "rb");
if (!f) {
return(0);
Lib3dsFile *file = NULL;
std::stringstream bufferedStream;
ifstream inputStream(filename,ios::in|ios::binary);
if (!inputStream.fail())
{
bufferedStream.operator<<(inputStream.rdbuf());
bufferedStream.seekp(ios_base::beg);
file = lib3ds_stream_load(&bufferedStream);
inputStream.close();
}
file=lib3ds_file_new();
if (!file) {
fclose(f);
return(0);
}
if (!lib3ds_file_read(file, f)) {
free(file);
fclose(f);
return(0);
}
fclose(f);
return(file);
}
Lib3dsFile*
lib3ds_stream_load(iostream * strm)
{
Lib3dsFile *file = NULL;
if (strm)
{
file=lib3ds_file_new();
if (file)
{
if (!lib3ds_file_read(file,strm))
{
free(file);
file = NULL;
}
}
else
file = NULL;
}
return(file);
}
/*!
* Saves a .3DS file from memory to disk.
@@ -106,18 +122,16 @@ lib3ds_file_load(const char *filename)
Lib3dsBool
lib3ds_file_save(Lib3dsFile *file, const char *filename)
{
FILE *f;
fstream strm;
f=osgDB::fopen(filename, "wb");
if (!f) {
return(LIB3DS_FALSE);
}
strm.open(filename,ios_base::out | ios_base::binary);
if (strm.fail()) return (LIB3DS_FALSE);
if (!lib3ds_file_write(file, f)) {
fclose(f);
if (!lib3ds_file_write(file, &strm)) {
strm.close();
return(LIB3DS_FALSE);
}
fclose(f);
strm.close();
return(LIB3DS_TRUE);
}
@@ -213,22 +227,22 @@ lib3ds_file_eval(Lib3dsFile *file, Lib3dsFloat t)
static Lib3dsBool
named_object_read(Lib3dsFile *file, FILE *f)
named_object_read(Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
char name[64];
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_NAMED_OBJECT, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_NAMED_OBJECT, strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_string_read(name, 64, f)) {
if (!lib3ds_string_read(name, 64, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_dump_info(" NAME=%s", name);
lib3ds_chunk_read_tell(&c, f);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_N_TRI_OBJECT:
{
@@ -238,8 +252,8 @@ named_object_read(Lib3dsFile *file, FILE *f)
if (!mesh) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_mesh_read(mesh, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_mesh_read(mesh, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_mesh(file, mesh);
@@ -253,8 +267,8 @@ named_object_read(Lib3dsFile *file, FILE *f)
if (!camera) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_camera_read(camera, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_camera_read(camera, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_camera(file, camera);
@@ -268,8 +282,8 @@ named_object_read(Lib3dsFile *file, FILE *f)
if (!light) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_light_read(light, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_light_read(light, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_light(file, light);
@@ -280,29 +294,29 @@ named_object_read(Lib3dsFile *file, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
ambient_read(Lib3dsFile *file, FILE *f)
ambient_read(Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
Lib3dsBool have_lin=LIB3DS_FALSE;
if (!lib3ds_chunk_read_start(&c, LIB3DS_AMBIENT_LIGHT, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_AMBIENT_LIGHT, strm)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_LIN_COLOR_F:
{
int i;
for (i=0; i<3; ++i) {
file->ambient[i]=lib3ds_float_read(f);
file->ambient[i]=lib3ds_float_read(strm);
}
}
have_lin=LIB3DS_TRUE;
@@ -314,7 +328,7 @@ ambient_read(Lib3dsFile *file, FILE *f)
if (!have_lin) {
int i;
for (i=0; i<3; ++i) {
file->ambient[i]=lib3ds_float_read(f);
file->ambient[i]=lib3ds_float_read(strm);
}
}
}
@@ -324,31 +338,31 @@ ambient_read(Lib3dsFile *file, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
mdata_read(Lib3dsFile *file, FILE *f)
mdata_read(Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_MDATA, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_MDATA, strm)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_MESH_VERSION:
{
file->mesh_version=lib3ds_intd_read(f);
file->mesh_version=lib3ds_intd_read(strm);
}
break;
case LIB3DS_MASTER_SCALE:
{
file->master_scale=lib3ds_float_read(f);
file->master_scale=lib3ds_float_read(strm);
}
break;
case LIB3DS_SHADOW_MAP_SIZE:
@@ -359,8 +373,8 @@ mdata_read(Lib3dsFile *file, FILE *f)
case LIB3DS_SHADOW_FILTER:
case LIB3DS_RAY_BIAS:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_shadow_read(&file->shadow, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_shadow_read(&file->shadow, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -368,8 +382,8 @@ mdata_read(Lib3dsFile *file, FILE *f)
case LIB3DS_VIEWPORT_LAYOUT:
case LIB3DS_DEFAULT_VIEW:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_viewport_read(&file->viewport, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_viewport_read(&file->viewport, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -378,14 +392,14 @@ mdata_read(Lib3dsFile *file, FILE *f)
{
int i;
for (i=0; i<3; ++i) {
file->construction_plane[i]=lib3ds_float_read(f);
file->construction_plane[i]=lib3ds_float_read(strm);
}
}
break;
case LIB3DS_AMBIENT_LIGHT:
{
lib3ds_chunk_read_reset(&c, f);
if (!ambient_read(file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!ambient_read(file, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -397,8 +411,8 @@ mdata_read(Lib3dsFile *file, FILE *f)
case LIB3DS_USE_SOLID_BGND:
case LIB3DS_USE_V_GRADIENT:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_background_read(&file->background, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_background_read(&file->background, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -410,8 +424,8 @@ mdata_read(Lib3dsFile *file, FILE *f)
case LIB3DS_USE_LAYER_FOG:
case LIB3DS_USE_DISTANCE_CUE:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_atmosphere_read(&file->atmosphere, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_atmosphere_read(&file->atmosphere, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -424,8 +438,8 @@ mdata_read(Lib3dsFile *file, FILE *f)
if (!material) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_material_read(material, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_material_read(material, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_material(file, material);
@@ -433,8 +447,8 @@ mdata_read(Lib3dsFile *file, FILE *f)
break;
case LIB3DS_NAMED_OBJECT:
{
lib3ds_chunk_read_reset(&c, f);
if (!named_object_read(file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!named_object_read(file, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -444,48 +458,48 @@ mdata_read(Lib3dsFile *file, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
kfdata_read(Lib3dsFile *file, FILE *f)
kfdata_read(Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_KFDATA, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_KFDATA, strm)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_KFHDR:
{
file->keyf_revision=lib3ds_word_read(f);
if (!lib3ds_string_read(file->name, 12+1, f)) {
file->keyf_revision=lib3ds_word_read(strm);
if (!lib3ds_string_read(file->name, 12+1, strm)) {
return(LIB3DS_FALSE);
}
file->frames=lib3ds_intd_read(f);
file->frames=lib3ds_intd_read(strm);
}
break;
case LIB3DS_KFSEG:
{
file->segment_from=lib3ds_intd_read(f);
file->segment_to=lib3ds_intd_read(f);
file->segment_from=lib3ds_intd_read(strm);
file->segment_to=lib3ds_intd_read(strm);
}
break;
case LIB3DS_KFCURTIME:
{
file->current_frame=lib3ds_intd_read(f);
file->current_frame=lib3ds_intd_read(strm);
}
break;
case LIB3DS_VIEWPORT_LAYOUT:
case LIB3DS_DEFAULT_VIEW:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_viewport_read(&file->viewport_keyf, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_viewport_read(&file->viewport_keyf, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -498,8 +512,8 @@ kfdata_read(Lib3dsFile *file, FILE *f)
if (!node) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_node_read(node, file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_node_read(node, file, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
@@ -513,8 +527,8 @@ kfdata_read(Lib3dsFile *file, FILE *f)
if (!node) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_node_read(node, file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_node_read(node, file, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
@@ -528,8 +542,8 @@ kfdata_read(Lib3dsFile *file, FILE *f)
if (!node) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_node_read(node, file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_node_read(node, file, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
@@ -543,8 +557,8 @@ kfdata_read(Lib3dsFile *file, FILE *f)
if (!node) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_node_read(node, file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_node_read(node, file, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
@@ -559,8 +573,8 @@ kfdata_read(Lib3dsFile *file, FILE *f)
if (!node) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_node_read(node, file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_node_read(node, file, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
@@ -574,8 +588,8 @@ kfdata_read(Lib3dsFile *file, FILE *f)
if (!node) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_node_read(node, file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!lib3ds_node_read(node, file, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
@@ -586,7 +600,7 @@ kfdata_read(Lib3dsFile *file, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -595,19 +609,19 @@ kfdata_read(Lib3dsFile *file, FILE *f)
* \ingroup file
*/
Lib3dsBool
lib3ds_file_read(Lib3dsFile *file, FILE *f)
lib3ds_file_read(Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, 0, f)) {
if (!lib3ds_chunk_read_start(&c, 0, strm)) {
return(LIB3DS_FALSE);
}
switch (c.chunk) {
case LIB3DS_MDATA:
{
lib3ds_chunk_read_reset(&c, f);
if (!mdata_read(file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!mdata_read(file, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -616,25 +630,25 @@ lib3ds_file_read(Lib3dsFile *file, FILE *f)
case LIB3DS_MLIBMAGIC:
case LIB3DS_CMAGIC:
{
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_M3D_VERSION:
{
file->mesh_version=lib3ds_dword_read(f);
file->mesh_version=lib3ds_dword_read(strm);
}
break;
case LIB3DS_MDATA:
{
lib3ds_chunk_read_reset(&c, f);
if (!mdata_read(file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!mdata_read(file, strm)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_KFDATA:
{
lib3ds_chunk_read_reset(&c, f);
if (!kfdata_read(file, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!kfdata_read(file, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -650,36 +664,36 @@ lib3ds_file_read(Lib3dsFile *file, FILE *f)
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
colorf_write(Lib3dsRgba rgb, FILE *f)
colorf_write(Lib3dsRgba rgb, iostream *strm)
{
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_rgb_write(rgb,f);
lib3ds_chunk_write(&c,strm);
lib3ds_rgb_write(rgb,strm);
c.chunk=LIB3DS_LIN_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_rgb_write(rgb,f);
lib3ds_chunk_write(&c,strm);
lib3ds_rgb_write(rgb,strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
mdata_write(Lib3dsFile *file, FILE *f)
mdata_write(Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
c.chunk=LIB3DS_MDATA;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
@@ -687,15 +701,15 @@ mdata_write(Lib3dsFile *file, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_MESH_VERSION;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_intd_write(file->mesh_version,f);
lib3ds_chunk_write(&c,strm);
lib3ds_intd_write(file->mesh_version,strm);
}
{ /*---- LIB3DS_MASTER_SCALE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_MASTER_SCALE;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_float_write(file->master_scale,f);
lib3ds_chunk_write(&c,strm);
lib3ds_float_write(file->master_scale,strm);
}
{ /*---- LIB3DS_O_CONSTS ----*/
int i;
@@ -708,8 +722,8 @@ mdata_write(Lib3dsFile *file, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_O_CONSTS;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(file->construction_plane,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(file->construction_plane,strm);
}
}
@@ -724,18 +738,18 @@ mdata_write(Lib3dsFile *file, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_AMBIENT_LIGHT;
c.size=42;
lib3ds_chunk_write(&c,f);
colorf_write(file->ambient,f);
lib3ds_chunk_write(&c,strm);
colorf_write(file->ambient,strm);
}
}
lib3ds_background_write(&file->background, f);
lib3ds_atmosphere_write(&file->atmosphere, f);
lib3ds_shadow_write(&file->shadow, f);
lib3ds_viewport_write(&file->viewport, f);
lib3ds_background_write(&file->background, strm);
lib3ds_atmosphere_write(&file->atmosphere, strm);
lib3ds_shadow_write(&file->shadow, strm);
lib3ds_viewport_write(&file->viewport, strm);
{
Lib3dsMaterial *p;
for (p=file->materials; p!=0; p=p->next) {
if (!lib3ds_material_write(p,f)) {
if (!lib3ds_material_write(p,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -746,12 +760,12 @@ mdata_write(Lib3dsFile *file, FILE *f)
for (p=file->cameras; p!=0; p=p->next) {
c.chunk=LIB3DS_NAMED_OBJECT;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_string_write(p->name,f);
lib3ds_camera_write(p,f);
if (!lib3ds_chunk_write_end(&c,f)) {
lib3ds_string_write(p->name,strm);
lib3ds_camera_write(p,strm);
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -762,12 +776,12 @@ mdata_write(Lib3dsFile *file, FILE *f)
for (p=file->lights; p!=0; p=p->next) {
c.chunk=LIB3DS_NAMED_OBJECT;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_string_write(p->name,f);
lib3ds_light_write(p,f);
if (!lib3ds_chunk_write_end(&c,f)) {
lib3ds_string_write(p->name,strm);
lib3ds_light_write(p,strm);
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -778,18 +792,18 @@ mdata_write(Lib3dsFile *file, FILE *f)
for (p=file->meshes; p!=0; p=p->next) {
c.chunk=LIB3DS_NAMED_OBJECT;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_string_write(p->name,f);
lib3ds_mesh_write(p,f);
if (!lib3ds_chunk_write_end(&c,f)) {
lib3ds_string_write(p->name,strm);
lib3ds_mesh_write(p,strm);
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -798,15 +812,15 @@ mdata_write(Lib3dsFile *file, FILE *f)
static Lib3dsBool
nodes_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
nodes_write(Lib3dsNode *node, Lib3dsFile *file, iostream *strm)
{
{
Lib3dsNode *p;
for (p=node->childs; p!=0; p=p->next) {
if (!lib3ds_node_write(p, file, f)) {
if (!lib3ds_node_write(p, file, strm)) {
return(LIB3DS_FALSE);
}
nodes_write(p, file, f);
nodes_write(p, file, strm);
}
}
return(LIB3DS_TRUE);
@@ -814,12 +828,12 @@ nodes_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
static Lib3dsBool
kfdata_write(Lib3dsFile *file, FILE *f)
kfdata_write(Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
c.chunk=LIB3DS_KFDATA;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
@@ -827,41 +841,41 @@ kfdata_write(Lib3dsFile *file, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_KFHDR;
c.size=6 + 2 + strlen(file->name)+1 +4;
lib3ds_chunk_write(&c,f);
lib3ds_intw_write(file->keyf_revision,f);
lib3ds_string_write(file->name, f);
lib3ds_intd_write(file->frames, f);
lib3ds_chunk_write(&c,strm);
lib3ds_intw_write(file->keyf_revision,strm);
lib3ds_string_write(file->name, strm);
lib3ds_intd_write(file->frames, strm);
}
{ /*---- LIB3DS_KFSEG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_KFSEG;
c.size=14;
lib3ds_chunk_write(&c,f);
lib3ds_intd_write(file->segment_from,f);
lib3ds_intd_write(file->segment_to,f);
lib3ds_chunk_write(&c,strm);
lib3ds_intd_write(file->segment_from,strm);
lib3ds_intd_write(file->segment_to,strm);
}
{ /*---- LIB3DS_KFCURTIME ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_KFCURTIME;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_intd_write(file->current_frame,f);
lib3ds_chunk_write(&c,strm);
lib3ds_intd_write(file->current_frame,strm);
}
lib3ds_viewport_write(&file->viewport_keyf, f);
lib3ds_viewport_write(&file->viewport_keyf, strm);
{
Lib3dsNode *p;
for (p=file->nodes; p!=0; p=p->next) {
if (!lib3ds_node_write(p, file, f)) {
if (!lib3ds_node_write(p, file, strm)) {
return(LIB3DS_FALSE);
}
if (!nodes_write(p, file, f)) {
if (!nodes_write(p, file, strm)) {
return(LIB3DS_FALSE);
}
}
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -872,12 +886,12 @@ kfdata_write(Lib3dsFile *file, FILE *f)
* \ingroup file
*/
Lib3dsBool
lib3ds_file_write(Lib3dsFile *file, FILE *f)
lib3ds_file_write(Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
c.chunk=LIB3DS_M3DMAGIC;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}
@@ -887,18 +901,18 @@ lib3ds_file_write(Lib3dsFile *file, FILE *f)
c.chunk=LIB3DS_M3D_VERSION;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_dword_write(file->mesh_version, f);
lib3ds_chunk_write(&c,strm);
lib3ds_dword_write(file->mesh_version, strm);
}
if (!mdata_write(file, f)) {
if (!mdata_write(file, strm)) {
return(LIB3DS_FALSE);
}
if (!kfdata_write(file, f)) {
if (!kfdata_write(file, strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);

12
src/osgPlugins/3ds/file.h
View File

@@ -35,11 +35,16 @@
#ifndef INCLUDED_LIB3DS_VIEWPORT_H
#include "viewport.h"
#endif
#include <osgDB/Registry>
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
/*!
* 3ds file structure
* \ingroup file
@@ -67,13 +72,14 @@ struct _Lib3dsFile {
Lib3dsNode *nodes;
};
extern LIB3DSAPI Lib3dsFile* lib3ds_file_load(const char *filename);
extern LIB3DSAPI Lib3dsFile* lib3ds_file_load(const char *filename, const osgDB::ReaderWriter::Options* options);
extern LIB3DSAPI Lib3dsFile* lib3ds_stream_load(iostream * strm);
extern LIB3DSAPI Lib3dsBool lib3ds_file_save(Lib3dsFile *file, const char *filename);
extern LIB3DSAPI Lib3dsFile* lib3ds_file_new();
extern LIB3DSAPI void lib3ds_file_free(Lib3dsFile *file);
extern LIB3DSAPI void lib3ds_file_eval(Lib3dsFile *file, Lib3dsFloat t);
extern LIB3DSAPI Lib3dsBool lib3ds_file_read(Lib3dsFile *file, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_file_write(Lib3dsFile *file, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_file_read(Lib3dsFile *file, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_file_write(Lib3dsFile *file, iostream *strm);
extern LIB3DSAPI void lib3ds_file_insert_material(Lib3dsFile *file, Lib3dsMaterial *material);
extern LIB3DSAPI void lib3ds_file_remove_material(Lib3dsFile *file, Lib3dsMaterial *material);
extern LIB3DSAPI Lib3dsMaterial* lib3ds_file_material_by_name(Lib3dsFile *file, const char *name);

128
src/osgPlugins/3ds/light.cpp
View File

@@ -121,28 +121,28 @@ lib3ds_light_dump(Lib3dsLight *light)
* \ingroup light
*/
static Lib3dsBool
spotlight_read(Lib3dsLight *light, FILE *f)
spotlight_read(Lib3dsLight *light, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
int i;
if (!lib3ds_chunk_read_start(&c, LIB3DS_DL_SPOTLIGHT, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_DL_SPOTLIGHT, strm)) {
return(LIB3DS_FALSE);
}
light->spot_light=LIB3DS_TRUE;
for (i=0; i<3; ++i) {
light->spot[i]=lib3ds_float_read(f);
light->spot[i]=lib3ds_float_read(strm);
}
light->hot_spot = lib3ds_float_read(f);
light->fall_off = lib3ds_float_read(f);
lib3ds_chunk_read_tell(&c, f);
light->hot_spot = lib3ds_float_read(strm);
light->fall_off = lib3ds_float_read(strm);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_DL_SPOT_ROLL:
{
light->roll=lib3ds_float_read(f);
light->roll=lib3ds_float_read(strm);
}
break;
case LIB3DS_DL_SHADOWED:
@@ -152,9 +152,9 @@ spotlight_read(Lib3dsLight *light, FILE *f)
break;
case LIB3DS_DL_LOCAL_SHADOW2:
{
light->shadow_bias=lib3ds_float_read(f);
light->shadow_filter=lib3ds_float_read(f);
light->shadow_size=lib3ds_intw_read(f);
light->shadow_bias=lib3ds_float_read(strm);
light->shadow_filter=lib3ds_float_read(strm);
light->shadow_size=lib3ds_intw_read(strm);
}
break;
case LIB3DS_DL_SEE_CONE:
@@ -169,13 +169,13 @@ spotlight_read(Lib3dsLight *light, FILE *f)
break;
case LIB3DS_DL_SPOT_ASPECT:
{
light->spot_aspect=lib3ds_float_read(f);
light->spot_aspect=lib3ds_float_read(strm);
}
break;
case LIB3DS_DL_SPOT_PROJECTOR:
{
light->use_projector=LIB3DS_TRUE;
if (!lib3ds_string_read(light->projector, 64, f)) {
if (!lib3ds_string_read(light->projector, 64, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -186,7 +186,7 @@ spotlight_read(Lib3dsLight *light, FILE *f)
break;
case LIB3DS_DL_RAY_BIAS:
{
light->ray_bias=lib3ds_float_read(f);
light->ray_bias=lib3ds_float_read(strm);
}
break;
case LIB3DS_DL_RAYSHAD:
@@ -199,7 +199,7 @@ spotlight_read(Lib3dsLight *light, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -208,29 +208,29 @@ spotlight_read(Lib3dsLight *light, FILE *f)
* \ingroup light
*/
Lib3dsBool
lib3ds_light_read(Lib3dsLight *light, FILE *f)
lib3ds_light_read(Lib3dsLight *light, iostream * strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_N_DIRECT_LIGHT, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_N_DIRECT_LIGHT, strm)) {
return(LIB3DS_FALSE);
}
{
int i;
for (i=0; i<3; ++i) {
light->position[i]=lib3ds_float_read(f);
light->position[i]=lib3ds_float_read(strm);
}
}
lib3ds_chunk_read_tell(&c, f);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_COLOR_F:
{
int i;
for (i=0; i<3; ++i) {
light->color[i]=lib3ds_float_read(f);
light->color[i]=lib3ds_float_read(strm);
}
}
break;
@@ -241,17 +241,17 @@ lib3ds_light_read(Lib3dsLight *light, FILE *f)
break;
case LIB3DS_DL_OUTER_RANGE:
{
light->outer_range=lib3ds_float_read(f);
light->outer_range=lib3ds_float_read(strm);
}
break;
case LIB3DS_DL_INNER_RANGE:
{
light->inner_range=lib3ds_float_read(f);
light->inner_range=lib3ds_float_read(strm);
}
break;
case LIB3DS_DL_MULTIPLIER:
{
light->multiplier=lib3ds_float_read(f);
light->multiplier=lib3ds_float_read(strm);
}
break;
case LIB3DS_DL_EXCLUDE:
@@ -261,13 +261,13 @@ lib3ds_light_read(Lib3dsLight *light, FILE *f)
}
case LIB3DS_DL_ATTENUATE:
{
light->attenuation=lib3ds_float_read(f);
light->attenuation=lib3ds_float_read(strm);
}
break;
case LIB3DS_DL_SPOTLIGHT:
{
lib3ds_chunk_read_reset(&c, f);
if (!spotlight_read(light, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!spotlight_read(light, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -277,7 +277,7 @@ lib3ds_light_read(Lib3dsLight *light, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -286,79 +286,79 @@ lib3ds_light_read(Lib3dsLight *light, FILE *f)
* \ingroup light
*/
Lib3dsBool
lib3ds_light_write(Lib3dsLight *light, FILE *f)
lib3ds_light_write(Lib3dsLight *light, iostream *strm)
{
Lib3dsChunk c;
c.chunk=LIB3DS_N_DIRECT_LIGHT;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_vector_write(light->position, f);
lib3ds_vector_write(light->position, strm);
{ /*---- LIB3DS_COLOR_F ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c, f);
lib3ds_rgb_write(light->color,f);
lib3ds_chunk_write(&c, strm);
lib3ds_rgb_write(light->color,strm);
}
if (light->off) { /*---- LIB3DS_DL_OFF ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_OFF;
c.size=6;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
}
{ /*---- LIB3DS_DL_OUTER_RANGE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_OUTER_RANGE;
c.size=10;
lib3ds_chunk_write(&c, f);
lib3ds_float_write(light->outer_range,f);
lib3ds_chunk_write(&c, strm);
lib3ds_float_write(light->outer_range,strm);
}
{ /*---- LIB3DS_DL_INNER_RANGE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_INNER_RANGE;
c.size=10;
lib3ds_chunk_write(&c, f);
lib3ds_float_write(light->inner_range,f);
lib3ds_chunk_write(&c, strm);
lib3ds_float_write(light->inner_range,strm);
}
{ /*---- LIB3DS_DL_MULTIPLIER ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_MULTIPLIER;
c.size=10;
lib3ds_chunk_write(&c, f);
lib3ds_float_write(light->multiplier, f);
lib3ds_chunk_write(&c, strm);
lib3ds_float_write(light->multiplier, strm);
}
if (light->attenuation) { /*---- LIB3DS_DL_ATTENUATE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_ATTENUATE;
c.size=6;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
}
if (light->spot_light) {
Lib3dsChunk c;
c.chunk=LIB3DS_DL_SPOTLIGHT;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_vector_write(light->spot, f);
lib3ds_float_write(light->hot_spot, f);
lib3ds_float_write(light->fall_off, f);
lib3ds_vector_write(light->spot, strm);
lib3ds_float_write(light->hot_spot, strm);
lib3ds_float_write(light->fall_off, strm);
{ /*---- LIB3DS_DL_SPOT_ROLL ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_SPOT_ROLL;
c.size=10;
lib3ds_chunk_write(&c, f);
lib3ds_float_write(light->roll,f);
lib3ds_chunk_write(&c, strm);
lib3ds_float_write(light->roll,strm);
}
if (light->shadowed) { /*---- LIB3DS_DL_SHADOWED ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_SHADOWED;
c.size=6;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
}
if ((fabs(light->shadow_bias)>LIB3DS_EPSILON) ||
(fabs(light->shadow_filter)>LIB3DS_EPSILON) ||
@@ -366,61 +366,61 @@ lib3ds_light_write(Lib3dsLight *light, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_DL_LOCAL_SHADOW2;
c.size=16;
lib3ds_chunk_write(&c, f);
lib3ds_float_write(light->shadow_bias,f);
lib3ds_float_write(light->shadow_filter,f);
lib3ds_intw_write(light->shadow_size,f);
lib3ds_chunk_write(&c, strm);
lib3ds_float_write(light->shadow_bias,strm);
lib3ds_float_write(light->shadow_filter,strm);
lib3ds_intw_write(light->shadow_size,strm);
}
if (light->see_cone) { /*---- LIB3DS_DL_SEE_CONE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_SEE_CONE;
c.size=6;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
}
if (light->rectangular_spot) { /*---- LIB3DS_DL_SPOT_RECTANGULAR ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_SPOT_RECTANGULAR;
c.size=6;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
}
if (fabs(light->spot_aspect)>LIB3DS_EPSILON) { /*---- LIB3DS_DL_SPOT_ASPECT ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_SPOT_ASPECT;
c.size=10;
lib3ds_chunk_write(&c, f);
lib3ds_float_write(light->spot_aspect,f);
lib3ds_chunk_write(&c, strm);
lib3ds_float_write(light->spot_aspect,strm);
}
if (light->use_projector) { /*---- LIB3DS_DL_SPOT_PROJECTOR ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_SPOT_PROJECTOR;
c.size=10;
lib3ds_chunk_write(&c, f);
lib3ds_string_write(light->projector,f);
lib3ds_chunk_write(&c, strm);
lib3ds_string_write(light->projector,strm);
}
if (light->spot_overshoot) { /*---- LIB3DS_DL_SPOT_OVERSHOOT ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_SPOT_OVERSHOOT;
c.size=6;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
}
if (fabs(light->ray_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_DL_RAY_BIAS ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_RAY_BIAS;
c.size=10;
lib3ds_chunk_write(&c, f);
lib3ds_float_write(light->ray_bias,f);
lib3ds_chunk_write(&c, strm);
lib3ds_float_write(light->ray_bias,strm);
}
if (light->ray_shadows) { /*---- LIB3DS_DL_RAYSHAD ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_DL_RAYSHAD;
c.size=6;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);

8
src/osgPlugins/3ds/light.h
View File

@@ -27,10 +27,14 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
/*!
* Light
* \ingroup light
@@ -68,8 +72,8 @@ struct _Lib3dsLight {
extern LIB3DSAPI Lib3dsLight* lib3ds_light_new(const char *name);
extern LIB3DSAPI void lib3ds_light_free(Lib3dsLight *mesh);
extern LIB3DSAPI void lib3ds_light_dump(Lib3dsLight *light);
extern LIB3DSAPI Lib3dsBool lib3ds_light_read(Lib3dsLight *light, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_light_write(Lib3dsLight *light, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_light_read(Lib3dsLight *light, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_light_write(Lib3dsLight *light, iostream *strm);
#ifdef __cplusplus
}

406
src/osgPlugins/3ds/material.cpp
View File

File diff suppressed because it is too large Load Diff

7
src/osgPlugins/3ds/material.h
View File

@@ -27,6 +27,9 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
@@ -156,8 +159,8 @@ struct _Lib3dsMaterial {
extern LIB3DSAPI Lib3dsMaterial* lib3ds_material_new();
extern LIB3DSAPI void lib3ds_material_free(Lib3dsMaterial *material);
extern LIB3DSAPI void lib3ds_material_dump(Lib3dsMaterial *material);
extern LIB3DSAPI Lib3dsBool lib3ds_material_read(Lib3dsMaterial *material, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_material_write(Lib3dsMaterial *material, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_material_read(Lib3dsMaterial *material, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_material_write(Lib3dsMaterial *material, iostream *strm);
#ifdef __cplusplus
}

192
src/osgPlugins/3ds/mesh.cpp
View File

@@ -42,19 +42,19 @@
static Lib3dsBool
face_array_read(Lib3dsMesh *mesh, FILE *f)
face_array_read(Lib3dsMesh *mesh, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
int i;
int faces;
if (!lib3ds_chunk_read_start(&c, LIB3DS_FACE_ARRAY, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_FACE_ARRAY, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_mesh_free_face_list(mesh);
faces=lib3ds_word_read(f);
faces=lib3ds_word_read(strm);
if (faces) {
if (!lib3ds_mesh_new_face_list(mesh, faces)) {
LIB3DS_ERROR_LOG;
@@ -62,21 +62,21 @@ face_array_read(Lib3dsMesh *mesh, FILE *f)
}
for (i=0; i<faces; ++i) {
strcpy(mesh->faceL[i].material, "");
mesh->faceL[i].points[0]=lib3ds_word_read(f);
mesh->faceL[i].points[1]=lib3ds_word_read(f);
mesh->faceL[i].points[2]=lib3ds_word_read(f);
mesh->faceL[i].flags=lib3ds_word_read(f);
mesh->faceL[i].points[0]=lib3ds_word_read(strm);
mesh->faceL[i].points[1]=lib3ds_word_read(strm);
mesh->faceL[i].points[2]=lib3ds_word_read(strm);
mesh->faceL[i].flags=lib3ds_word_read(strm);
}
lib3ds_chunk_read_tell(&c, f);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_SMOOTH_GROUP:
{
unsigned i;
for (i=0; i<mesh->faces; ++i) {
mesh->faceL[i].smoothing=lib3ds_dword_read(f);
mesh->faceL[i].smoothing=lib3ds_dword_read(strm);
}
}
break;
@@ -87,12 +87,12 @@ face_array_read(Lib3dsMesh *mesh, FILE *f)
unsigned i;
unsigned index;
if (!lib3ds_string_read(name, 64, f)) {
if (!lib3ds_string_read(name, 64, strm)) {
return(LIB3DS_FALSE);
}
faces=lib3ds_word_read(f);
faces=lib3ds_word_read(strm);
for (i=0; i<faces; ++i) {
index=lib3ds_word_read(f);
index=lib3ds_word_read(strm);
ASSERT(index<mesh->faces);
strcpy(mesh->faceL[index].material, name);
}
@@ -102,27 +102,27 @@ face_array_read(Lib3dsMesh *mesh, FILE *f)
{
char name[64];
if (!lib3ds_string_read(name, 64, f)) {
if (!lib3ds_string_read(name, 64, strm)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.front, name);
if (!lib3ds_string_read(name, 64, f)) {
if (!lib3ds_string_read(name, 64, strm)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.back, name);
if (!lib3ds_string_read(name, 64, f)) {
if (!lib3ds_string_read(name, 64, strm)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.left, name);
if (!lib3ds_string_read(name, 64, f)) {
if (!lib3ds_string_read(name, 64, strm)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.right, name);
if (!lib3ds_string_read(name, 64, f)) {
if (!lib3ds_string_read(name, 64, strm)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.top, name);
if (!lib3ds_string_read(name, 64, f)) {
if (!lib3ds_string_read(name, 64, strm)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.bottom, name);
@@ -134,7 +134,7 @@ face_array_read(Lib3dsMesh *mesh, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -523,16 +523,16 @@ lib3ds_mesh_dump(Lib3dsMesh *mesh)
* \ingroup mesh
*/
Lib3dsBool
lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
lib3ds_mesh_read(Lib3dsMesh *mesh, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_N_TRI_OBJECT, f)) {
if (!lib3ds_chunk_read_start(&c, LIB3DS_N_TRI_OBJECT, strm)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_MESH_MATRIX:
{
@@ -541,14 +541,14 @@ lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
lib3ds_matrix_identity(mesh->matrix);
for (i=0; i<4; i++) {
for (j=0; j<3; j++) {
mesh->matrix[i][j]=lib3ds_float_read(f);
mesh->matrix[i][j]=lib3ds_float_read(strm);
}
}
}
break;
case LIB3DS_MESH_COLOR:
{
mesh->color=lib3ds_byte_read(f);
mesh->color=lib3ds_byte_read(strm);
}
break;
case LIB3DS_POINT_ARRAY:
@@ -557,7 +557,7 @@ lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
unsigned points;
lib3ds_mesh_free_point_list(mesh);
points=lib3ds_word_read(f);
points=lib3ds_word_read(strm);
if (points) {
if (!lib3ds_mesh_new_point_list(mesh, points)) {
LIB3DS_ERROR_LOG;
@@ -565,7 +565,7 @@ lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
}
for (i=0; i<mesh->points; ++i) {
for (j=0; j<3; ++j) {
mesh->pointL[i].pos[j]=lib3ds_float_read(f);
mesh->pointL[i].pos[j]=lib3ds_float_read(strm);
}
}
ASSERT((!mesh->flags) || (mesh->points==mesh->flags));
@@ -579,14 +579,14 @@ lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
unsigned flags;
lib3ds_mesh_free_flag_list(mesh);
flags=lib3ds_word_read(f);
flags=lib3ds_word_read(strm);
if (flags) {
if (!lib3ds_mesh_new_flag_list(mesh, flags)) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}
for (i=0; i<mesh->flags; ++i) {
mesh->flagL[i]=lib3ds_word_read(f);
mesh->flagL[i]=lib3ds_word_read(strm);
}
ASSERT((!mesh->points) || (mesh->flags==mesh->points));
ASSERT((!mesh->texels) || (mesh->flags==mesh->texels));
@@ -595,8 +595,8 @@ lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
break;
case LIB3DS_FACE_ARRAY:
{
lib3ds_chunk_read_reset(&c, f);
if (!face_array_read(mesh, f)) {
lib3ds_chunk_read_reset(&c, strm);
if (!face_array_read(mesh, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -606,23 +606,23 @@ lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
int i,j;
for (i=0; i<2; ++i) {
mesh->map_data.tile[i]=lib3ds_float_read(f);
mesh->map_data.tile[i]=lib3ds_float_read(strm);
}
for (i=0; i<3; ++i) {
mesh->map_data.pos[i]=lib3ds_float_read(f);
mesh->map_data.pos[i]=lib3ds_float_read(strm);
}
mesh->map_data.scale=lib3ds_float_read(f);
mesh->map_data.scale=lib3ds_float_read(strm);
lib3ds_matrix_identity(mesh->map_data.matrix);
for (i=0; i<4; i++) {
for (j=0; j<3; j++) {
mesh->map_data.matrix[i][j]=lib3ds_float_read(f);
mesh->map_data.matrix[i][j]=lib3ds_float_read(strm);
}
}
for (i=0; i<2; ++i) {
mesh->map_data.planar_size[i]=lib3ds_float_read(f);
mesh->map_data.planar_size[i]=lib3ds_float_read(strm);
}
mesh->map_data.cylinder_height=lib3ds_float_read(f);
mesh->map_data.cylinder_height=lib3ds_float_read(strm);
}
break;
case LIB3DS_TEX_VERTS:
@@ -631,15 +631,15 @@ lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
unsigned texels;
lib3ds_mesh_free_texel_list(mesh);
texels=lib3ds_word_read(f);
texels=lib3ds_word_read(strm);
if (texels) {
if (!lib3ds_mesh_new_texel_list(mesh, texels)) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}
for (i=0; i<mesh->texels; ++i) {
mesh->texelL[i][0]=lib3ds_float_read(f);
mesh->texelL[i][1]=lib3ds_float_read(f);
mesh->texelL[i][0]=lib3ds_float_read(strm);
mesh->texelL[i][1]=lib3ds_float_read(strm);
}
ASSERT((!mesh->points) || (mesh->texels==mesh->points));
ASSERT((!mesh->flags) || (mesh->texels==mesh->flags));
@@ -666,13 +666,13 @@ lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
static Lib3dsBool
point_array_write(Lib3dsMesh *mesh, FILE *f)
point_array_write(Lib3dsMesh *mesh, iostream *strm)
{
Lib3dsChunk c;
unsigned i;
@@ -683,18 +683,18 @@ point_array_write(Lib3dsMesh *mesh, FILE *f)
ASSERT(mesh->points<0x10000);
c.chunk=LIB3DS_POINT_ARRAY;
c.size=8+12*mesh->points;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
lib3ds_word_write((Lib3dsWord)mesh->points, f);
lib3ds_word_write((Lib3dsWord)mesh->points, strm);
for (i=0; i<mesh->points; ++i) {
lib3ds_vector_write(mesh->pointL[i].pos, f);
lib3ds_vector_write(mesh->pointL[i].pos, strm);
}
return(LIB3DS_TRUE);
}
static Lib3dsBool
flag_array_write(Lib3dsMesh *mesh, FILE *f)
flag_array_write(Lib3dsMesh *mesh, iostream *strm)
{
Lib3dsChunk c;
unsigned i;
@@ -705,18 +705,18 @@ flag_array_write(Lib3dsMesh *mesh, FILE *f)
ASSERT(mesh->flags<0x10000);
c.chunk=LIB3DS_POINT_FLAG_ARRAY;
c.size=8+2*mesh->flags;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
lib3ds_word_write((Lib3dsWord)mesh->flags, f);
lib3ds_word_write((Lib3dsWord)mesh->flags, strm);
for (i=0; i<mesh->flags; ++i) {
lib3ds_word_write(mesh->flagL[i], f);
lib3ds_word_write(mesh->flagL[i], strm);
}
return(LIB3DS_TRUE);
}
static Lib3dsBool
face_array_write(Lib3dsMesh *mesh, FILE *f)
face_array_write(Lib3dsMesh *mesh, iostream *strm)
{
Lib3dsChunk c;
@@ -725,18 +725,18 @@ face_array_write(Lib3dsMesh *mesh, FILE *f)
}
ASSERT(mesh->faces<0x10000);
c.chunk=LIB3DS_FACE_ARRAY;
if (!lib3ds_chunk_write_start(&c, f)) {
if (!lib3ds_chunk_write_start(&c, strm)) {
return(LIB3DS_FALSE);
}
{
unsigned i;
lib3ds_word_write((Lib3dsWord)mesh->faces, f);
lib3ds_word_write((Lib3dsWord)mesh->faces, strm);
for (i=0; i<mesh->faces; ++i) {
lib3ds_word_write(mesh->faceL[i].points[0], f);
lib3ds_word_write(mesh->faceL[i].points[1], f);
lib3ds_word_write(mesh->faceL[i].points[2], f);
lib3ds_word_write(mesh->faceL[i].flags, f);
lib3ds_word_write(mesh->faceL[i].points[0], strm);
lib3ds_word_write(mesh->faceL[i].points[1], strm);
lib3ds_word_write(mesh->faceL[i].points[2], strm);
lib3ds_word_write(mesh->faceL[i].flags, strm);
}
}
@@ -760,14 +760,14 @@ face_array_write(Lib3dsMesh *mesh, FILE *f)
c.chunk=LIB3DS_MSH_MAT_GROUP;
c.size=6+ strlen(mesh->faceL[i].material)+1 +2+2*num;
lib3ds_chunk_write(&c, f);
lib3ds_string_write(mesh->faceL[i].material, f);
lib3ds_word_write(num, f);
lib3ds_word_write((Lib3dsWord)i, f);
lib3ds_chunk_write(&c, strm);
lib3ds_string_write(mesh->faceL[i].material, strm);
lib3ds_word_write(num, strm);
lib3ds_word_write((Lib3dsWord)i, strm);
for (j=i+1; j<mesh->faces; ++j) {
if (strcmp(mesh->faceL[i].material, mesh->faceL[j].material)==0) {
lib3ds_word_write((Lib3dsWord)j, f);
lib3ds_word_write((Lib3dsWord)j, strm);
matf[j]=1;
}
}
@@ -782,10 +782,10 @@ face_array_write(Lib3dsMesh *mesh, FILE *f)
c.chunk=LIB3DS_SMOOTH_GROUP;
c.size=6+4*mesh->faces;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
for (i=0; i<mesh->faces; ++i) {
lib3ds_dword_write(mesh->faceL[i].smoothing, f);
lib3ds_dword_write(mesh->faceL[i].smoothing, strm);
}
}
@@ -800,24 +800,24 @@ face_array_write(Lib3dsMesh *mesh, FILE *f)
strlen(mesh->box_map.bottom)) {
c.chunk=LIB3DS_MSH_BOXMAP;
if (!lib3ds_chunk_write_start(&c, f)) {
if (!lib3ds_chunk_write_start(&c, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_string_write(mesh->box_map.front, f);
lib3ds_string_write(mesh->box_map.back, f);
lib3ds_string_write(mesh->box_map.left, f);
lib3ds_string_write(mesh->box_map.right, f);
lib3ds_string_write(mesh->box_map.top, f);
lib3ds_string_write(mesh->box_map.bottom, f);
lib3ds_string_write(mesh->box_map.front, strm);
lib3ds_string_write(mesh->box_map.back, strm);
lib3ds_string_write(mesh->box_map.left, strm);
lib3ds_string_write(mesh->box_map.right, strm);
lib3ds_string_write(mesh->box_map.top, strm);
lib3ds_string_write(mesh->box_map.bottom, strm);
if (!lib3ds_chunk_write_end(&c, f)) {
if (!lib3ds_chunk_write_end(&c, strm)) {
return(LIB3DS_FALSE);
}
}
}
if (!lib3ds_chunk_write_end(&c, f)) {
if (!lib3ds_chunk_write_end(&c, strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -825,7 +825,7 @@ face_array_write(Lib3dsMesh *mesh, FILE *f)
static Lib3dsBool
texel_array_write(Lib3dsMesh *mesh, FILE *f)
texel_array_write(Lib3dsMesh *mesh, iostream *strm)
{
Lib3dsChunk c;
unsigned i;
@@ -836,12 +836,12 @@ texel_array_write(Lib3dsMesh *mesh, FILE *f)
ASSERT(mesh->texels<0x10000);
c.chunk=LIB3DS_TEX_VERTS;
c.size=8+8*mesh->texels;
lib3ds_chunk_write(&c, f);
lib3ds_chunk_write(&c, strm);
lib3ds_word_write((Lib3dsWord)mesh->texels, f);
lib3ds_word_write((Lib3dsWord)mesh->texels, strm);
for (i=0; i<mesh->texels; ++i) {
lib3ds_float_write(mesh->texelL[i][0], f);
lib3ds_float_write(mesh->texelL[i][1], f);
lib3ds_float_write(mesh->texelL[i][0], strm);
lib3ds_float_write(mesh->texelL[i][1], strm);
}
return(LIB3DS_TRUE);
}
@@ -851,18 +851,18 @@ texel_array_write(Lib3dsMesh *mesh, FILE *f)
* \ingroup mesh
*/
Lib3dsBool
lib3ds_mesh_write(Lib3dsMesh *mesh, FILE *f)
lib3ds_mesh_write(Lib3dsMesh *mesh, iostream *strm)
{
Lib3dsChunk c;
c.chunk=LIB3DS_N_TRI_OBJECT;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!point_array_write(mesh, f)) {
if (!point_array_write(mesh, strm)) {
return(LIB3DS_FALSE);
}
if (!texel_array_write(mesh, f)) {
if (!texel_array_write(mesh, strm)) {
return(LIB3DS_FALSE);
}
@@ -872,32 +872,32 @@ lib3ds_mesh_write(Lib3dsMesh *mesh, FILE *f)
c.chunk=LIB3DS_MESH_TEXTURE_INFO;
c.size=92;
if (!lib3ds_chunk_write(&c,f)) {
if (!lib3ds_chunk_write(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_word_write(mesh->map_data.maptype, f);
lib3ds_word_write(mesh->map_data.maptype, strm);
for (i=0; i<2; ++i) {
lib3ds_float_write(mesh->map_data.tile[i], f);
lib3ds_float_write(mesh->map_data.tile[i], strm);
}
for (i=0; i<3; ++i) {
lib3ds_float_write(mesh->map_data.pos[i], f);
lib3ds_float_write(mesh->map_data.pos[i], strm);
}
lib3ds_float_write(mesh->map_data.scale, f);
lib3ds_float_write(mesh->map_data.scale, strm);
for (i=0; i<4; i++) {
for (j=0; j<3; j++) {
lib3ds_float_write(mesh->map_data.matrix[i][j], f);
lib3ds_float_write(mesh->map_data.matrix[i][j], strm);
}
}
for (i=0; i<2; ++i) {
lib3ds_float_write(mesh->map_data.planar_size[i], f);
lib3ds_float_write(mesh->map_data.planar_size[i], strm);
}
lib3ds_float_write(mesh->map_data.cylinder_height, f);
lib3ds_float_write(mesh->map_data.cylinder_height, strm);
}
if (!flag_array_write(mesh, f)) {
if (!flag_array_write(mesh, strm)) {
return(LIB3DS_FALSE);
}
{ /*---- LIB3DS_MESH_MATRIX ----*/
@@ -906,12 +906,12 @@ lib3ds_mesh_write(Lib3dsMesh *mesh, FILE *f)
c.chunk=LIB3DS_MESH_MATRIX;
c.size=54;
if (!lib3ds_chunk_write(&c,f)) {
if (!lib3ds_chunk_write(&c,strm)) {
return(LIB3DS_FALSE);
}
for (i=0; i<4; i++) {
for (j=0; j<3; j++) {
lib3ds_float_write(mesh->matrix[i][j], f);
lib3ds_float_write(mesh->matrix[i][j], strm);
}
}
}
@@ -921,16 +921,16 @@ lib3ds_mesh_write(Lib3dsMesh *mesh, FILE *f)
c.chunk=LIB3DS_MESH_COLOR;
c.size=7;
if (!lib3ds_chunk_write(&c,f)) {
if (!lib3ds_chunk_write(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_byte_write(mesh->color, f);
lib3ds_byte_write(mesh->color, strm);
}
if (!face_array_write(mesh, f)) {
if (!face_array_write(mesh, strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);

9
src/osgPlugins/3ds/mesh.h
View File

@@ -27,10 +27,15 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
/*!
* Triangular mesh point
* \ingroup mesh
@@ -125,8 +130,8 @@ extern LIB3DSAPI void lib3ds_mesh_free_face_list(Lib3dsMesh *mesh);
extern LIB3DSAPI void lib3ds_mesh_bounding_box(Lib3dsMesh *mesh, Lib3dsVector min, Lib3dsVector max);
extern LIB3DSAPI void lib3ds_mesh_calculate_normals(Lib3dsMesh *mesh, Lib3dsVector *normalL);
extern LIB3DSAPI void lib3ds_mesh_dump(Lib3dsMesh *mesh);
extern LIB3DSAPI Lib3dsBool lib3ds_mesh_read(Lib3dsMesh *mesh, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_mesh_write(Lib3dsMesh *mesh, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_mesh_read(Lib3dsMesh *mesh, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_mesh_write(Lib3dsMesh *mesh, iostream *strm);
#ifdef __cplusplus
}

200
src/osgPlugins/3ds/node.cpp
View File

@@ -407,13 +407,13 @@ lib3ds_node_dump(Lib3dsNode *node, Lib3dsIntd level)
* \ingroup node
*/
Lib3dsBool
lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
ASSERT(node);
if (!lib3ds_chunk_read_start(&c, 0, f)) {
if (!lib3ds_chunk_read_start(&c, 0, strm)) {
return(LIB3DS_FALSE);
}
switch (c.chunk) {
@@ -429,22 +429,22 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_NODE_ID:
{
node->node_id=lib3ds_word_read(f);
node->node_id=lib3ds_word_read(strm);
lib3ds_chunk_dump_info(" ID = %d", (short)node->node_id);
}
break;
case LIB3DS_NODE_HDR:
{
if (!lib3ds_string_read(node->name, 64, f)) {
if (!lib3ds_string_read(node->name, 64, strm)) {
return(LIB3DS_FALSE);
}
node->flags1=lib3ds_word_read(f);
node->flags2=lib3ds_word_read(f);
node->parent_id=lib3ds_word_read(f);
node->flags1=lib3ds_word_read(strm);
node->flags2=lib3ds_word_read(strm);
node->parent_id=lib3ds_word_read(strm);
lib3ds_chunk_dump_info(" NAME =%s", node->name);
lib3ds_chunk_dump_info(" PARENT=%d", (short)node->parent_id);
}
@@ -454,7 +454,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
if (node->type==LIB3DS_OBJECT_NODE) {
int i;
for (i=0; i<3; ++i) {
node->data.object.pivot[i]=lib3ds_float_read(f);
node->data.object.pivot[i]=lib3ds_float_read(strm);
}
}
else {
@@ -465,7 +465,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_INSTANCE_NAME:
{
if (node->type==LIB3DS_OBJECT_NODE) {
if (!lib3ds_string_read(node->data.object.instance, 64, f)) {
if (!lib3ds_string_read(node->data.object.instance, 64, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -479,10 +479,10 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
if (node->type==LIB3DS_OBJECT_NODE) {
int i;
for (i=0; i<3; ++i) {
node->data.object.bbox_min[i]=lib3ds_float_read(f);
node->data.object.bbox_min[i]=lib3ds_float_read(strm);
}
for (i=0; i<3; ++i) {
node->data.object.bbox_max[i]=lib3ds_float_read(f);
node->data.object.bbox_max[i]=lib3ds_float_read(strm);
}
}
else {
@@ -496,10 +496,10 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
switch (node->type) {
case LIB3DS_AMBIENT_NODE:
result=lib3ds_lin3_track_read(&node->data.ambient.col_track, f);
result=lib3ds_lin3_track_read(&node->data.ambient.col_track, strm);
break;
case LIB3DS_LIGHT_NODE:
result=lib3ds_lin3_track_read(&node->data.light.col_track, f);
result=lib3ds_lin3_track_read(&node->data.light.col_track, strm);
break;
default:
lib3ds_chunk_unknown(chunk);
@@ -515,19 +515,19 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
switch (node->type) {
case LIB3DS_OBJECT_NODE:
result=lib3ds_lin3_track_read(&node->data.object.pos_track, f);
result=lib3ds_lin3_track_read(&node->data.object.pos_track, strm);
break;
case LIB3DS_CAMERA_NODE:
result=lib3ds_lin3_track_read(&node->data.camera.pos_track, f);
result=lib3ds_lin3_track_read(&node->data.camera.pos_track, strm);
break;
case LIB3DS_TARGET_NODE:
result=lib3ds_lin3_track_read(&node->data.target.pos_track, f);
result=lib3ds_lin3_track_read(&node->data.target.pos_track, strm);
break;
case LIB3DS_LIGHT_NODE:
result=lib3ds_lin3_track_read(&node->data.light.pos_track, f);
result=lib3ds_lin3_track_read(&node->data.light.pos_track, strm);
break;
case LIB3DS_SPOT_NODE:
result=lib3ds_lin3_track_read(&node->data.spot.pos_track, f);
result=lib3ds_lin3_track_read(&node->data.spot.pos_track, strm);
break;
default:
lib3ds_chunk_unknown(chunk);
@@ -540,7 +540,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_ROT_TRACK_TAG:
{
if (node->type==LIB3DS_OBJECT_NODE) {
if (!lib3ds_quat_track_read(&node->data.object.rot_track, f)) {
if (!lib3ds_quat_track_read(&node->data.object.rot_track, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -552,7 +552,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_SCL_TRACK_TAG:
{
if (node->type==LIB3DS_OBJECT_NODE) {
if (!lib3ds_lin3_track_read(&node->data.object.scl_track, f)) {
if (!lib3ds_lin3_track_read(&node->data.object.scl_track, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -564,7 +564,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_FOV_TRACK_TAG:
{
if (node->type==LIB3DS_CAMERA_NODE) {
if (!lib3ds_lin1_track_read(&node->data.camera.fov_track, f)) {
if (!lib3ds_lin1_track_read(&node->data.camera.fov_track, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -576,7 +576,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_HOT_TRACK_TAG:
{
if (node->type==LIB3DS_LIGHT_NODE) {
if (!lib3ds_lin1_track_read(&node->data.light.hotspot_track, f)) {
if (!lib3ds_lin1_track_read(&node->data.light.hotspot_track, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -588,7 +588,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_FALL_TRACK_TAG:
{
if (node->type==LIB3DS_LIGHT_NODE) {
if (!lib3ds_lin1_track_read(&node->data.light.falloff_track, f)) {
if (!lib3ds_lin1_track_read(&node->data.light.falloff_track, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -603,10 +603,10 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
switch (node->type) {
case LIB3DS_CAMERA_NODE:
result=lib3ds_lin1_track_read(&node->data.camera.roll_track, f);
result=lib3ds_lin1_track_read(&node->data.camera.roll_track, strm);
break;
case LIB3DS_LIGHT_NODE:
result=lib3ds_lin1_track_read(&node->data.light.roll_track, f);
result=lib3ds_lin1_track_read(&node->data.light.roll_track, strm);
break;
default:
lib3ds_chunk_unknown(chunk);
@@ -619,7 +619,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_HIDE_TRACK_TAG:
{
if (node->type==LIB3DS_OBJECT_NODE) {
if (!lib3ds_bool_track_read(&node->data.object.hide_track, f)) {
if (!lib3ds_bool_track_read(&node->data.object.hide_track, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -631,7 +631,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_MORPH_SMOOTH:
{
if (node->type==LIB3DS_OBJECT_NODE) {
node->data.object.morph_smooth=lib3ds_float_read(f);
node->data.object.morph_smooth=lib3ds_float_read(strm);
}
else {
lib3ds_chunk_unknown(chunk);
@@ -641,7 +641,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
case LIB3DS_MORPH_TRACK_TAG:
{
if (node->type==LIB3DS_OBJECT_NODE) {
if (!lib3ds_morph_track_read(&node->data.object.morph_track, f)) {
if (!lib3ds_morph_track_read(&node->data.object.morph_track, strm)) {
return(LIB3DS_FALSE);
}
}
@@ -655,7 +655,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
}
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -664,7 +664,7 @@ lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, FILE *f)
* \ingroup node
*/
Lib3dsBool
lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, iostream *strm)
{
Lib3dsChunk c;
@@ -695,7 +695,7 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
default:
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
@@ -703,19 +703,19 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_NODE_ID;
c.size=8;
lib3ds_chunk_write(&c,f);
lib3ds_intw_write(node->node_id,f);
lib3ds_chunk_write(&c,strm);
lib3ds_intw_write(node->node_id,strm);
}
{ /*---- LIB3DS_NODE_HDR ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_NODE_HDR;
c.size=6+ 1+strlen(node->name) +2+2+2;
lib3ds_chunk_write(&c,f);
lib3ds_string_write(node->name,f);
lib3ds_word_write(node->flags1,f);
lib3ds_word_write(node->flags2,f);
lib3ds_word_write(node->parent_id,f);
lib3ds_chunk_write(&c,strm);
lib3ds_string_write(node->name,strm);
lib3ds_word_write(node->flags1,strm);
lib3ds_word_write(node->flags2,strm);
lib3ds_word_write(node->parent_id,strm);
}
switch (c.chunk) {
@@ -723,13 +723,13 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
{ /*---- LIB3DS_COL_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_COL_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.ambient.col_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.ambient.col_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -739,8 +739,8 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_PIVOT;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(node->data.object.pivot,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(node->data.object.pivot,strm);
}
{ /*---- LIB3DS_INSTANCE_NAME ----*/
Lib3dsChunk c;
@@ -750,8 +750,8 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
c.chunk=LIB3DS_INSTANCE_NAME;
c.size=6+1+strlen(name);
lib3ds_chunk_write(&c,f);
lib3ds_string_write(name,f);
lib3ds_chunk_write(&c,strm);
lib3ds_string_write(name,strm);
}
}
{
@@ -767,60 +767,60 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_BOUNDBOX;
c.size=30;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(node->data.object.bbox_min, f);
lib3ds_vector_write(node->data.object.bbox_max, f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(node->data.object.bbox_min, strm);
lib3ds_vector_write(node->data.object.bbox_max, strm);
}
}
{ /*---- LIB3DS_POS_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_POS_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.object.pos_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.object.pos_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_ROT_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_ROT_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_quat_track_write(&node->data.object.rot_track,f)) {
if (!lib3ds_quat_track_write(&node->data.object.rot_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_SCL_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SCL_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.object.scl_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.object.scl_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
if (node->data.object.hide_track.keyL) { /*---- LIB3DS_HIDE_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_HIDE_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_bool_track_write(&node->data.object.hide_track,f)) {
if (!lib3ds_bool_track_write(&node->data.object.hide_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -828,47 +828,47 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_MORPH_SMOOTH;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_float_write(node->data.object.morph_smooth,f);
lib3ds_chunk_write(&c,strm);
lib3ds_float_write(node->data.object.morph_smooth,strm);
}
break;
case LIB3DS_CAMERA_NODE_TAG:
{ /*---- LIB3DS_POS_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_POS_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.camera.pos_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.camera.pos_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_FOV_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_FOV_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin1_track_write(&node->data.camera.fov_track,f)) {
if (!lib3ds_lin1_track_write(&node->data.camera.fov_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_ROLL_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_ROLL_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin1_track_write(&node->data.camera.roll_track,f)) {
if (!lib3ds_lin1_track_write(&node->data.camera.roll_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -877,13 +877,13 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
{ /*---- LIB3DS_POS_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_POS_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.target.pos_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.target.pos_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -892,26 +892,26 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
{ /*---- LIB3DS_POS_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_POS_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.light.pos_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.light.pos_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_COL_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_COL_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.light.col_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.light.col_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -920,65 +920,65 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
{ /*---- LIB3DS_POS_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_POS_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.light.pos_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.light.pos_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_COL_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_COL_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.light.col_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.light.col_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_HOT_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_HOT_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin1_track_write(&node->data.light.hotspot_track,f)) {
if (!lib3ds_lin1_track_write(&node->data.light.hotspot_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_FALL_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_FALL_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin1_track_write(&node->data.light.falloff_track,f)) {
if (!lib3ds_lin1_track_write(&node->data.light.falloff_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
{ /*---- LIB3DS_ROLL_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_ROLL_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin1_track_write(&node->data.light.roll_track,f)) {
if (!lib3ds_lin1_track_write(&node->data.light.roll_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -987,13 +987,13 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
{ /*---- LIB3DS_POS_TRACK_TAG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_POS_TRACK_TAG;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_lin3_track_write(&node->data.spot.pos_track,f)) {
if (!lib3ds_lin3_track_write(&node->data.spot.pos_track,strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -1002,7 +1002,7 @@ lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f)
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);

8
src/osgPlugins/3ds/node.h
View File

@@ -27,10 +27,14 @@
#include "tracks.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
/*!
* Scene graph ambient color node data
* \ingroup node
@@ -159,8 +163,8 @@ extern LIB3DSAPI Lib3dsNode* lib3ds_node_by_name(Lib3dsNode *node, const char* n
Lib3dsNodeTypes type);
extern LIB3DSAPI Lib3dsNode* lib3ds_node_by_id(Lib3dsNode *node, Lib3dsWord node_id);
extern LIB3DSAPI void lib3ds_node_dump(Lib3dsNode *node, Lib3dsIntd level);
extern LIB3DSAPI Lib3dsBool lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *file, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *file, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, iostream *strm);
#ifdef __cplusplus
}

181
src/osgPlugins/3ds/readwrite.cpp
View File

@@ -23,13 +23,13 @@
#include "readwrite.h"
#include <osg/Endian>
/*!
* \defgroup readwrite Portable Binary Input/Ouput
*
* \author J.E. Hoffmann <je-h@gmx.net>
*/
static bool s_requiresByteSwap = false;
extern LIB3DSAPI void setByteOrder()
@@ -49,13 +49,12 @@ extern LIB3DSAPI void setByteOrder()
* \return The byte read.
*/
Lib3dsByte
lib3ds_byte_read(FILE *f)
lib3ds_byte_read(iostream *strm)
{
Lib3dsByte b;
ASSERT(f);
int result = fread(&b,1,1,f);
if (result==0) return 0;
ASSERT(strm);
strm->read((char*)&b,1);
return(b);
}
@@ -68,15 +67,13 @@ lib3ds_byte_read(FILE *f)
* \return The word read.
*/
Lib3dsWord
lib3ds_word_read(FILE *f)
lib3ds_word_read(iostream *strm)
{
Lib3dsByte b[2];
Lib3dsWord w;
ASSERT(f);
int result = fread(b,2,1,f);
if (result==0) return 0;
ASSERT(strm);
strm->read((char*)&b,2);
w=((Lib3dsWord)b[1] << 8) |
((Lib3dsWord)b[0]);
return(w);
@@ -93,15 +90,13 @@ lib3ds_word_read(FILE *f)
* \return The dword read.
*/
Lib3dsDword
lib3ds_dword_read(FILE *f)
lib3ds_dword_read(iostream *strm)
{
Lib3dsByte b[4];
Lib3dsDword d;
ASSERT(f);
int result = fread(b,4,1,f);
if (result==0) return 0;
ASSERT(strm);
strm->read((char*)&b,4);
d=((Lib3dsDword)b[3] << 24) |
((Lib3dsDword)b[2] << 16) |
((Lib3dsDword)b[1] << 8) |
@@ -120,14 +115,12 @@ lib3ds_dword_read(FILE *f)
* \return The signed byte read.
*/
Lib3dsIntb
lib3ds_intb_read(FILE *f)
lib3ds_intb_read(iostream *strm)
{
Lib3dsIntb b;
ASSERT(f);
int result = fread(&b,1,1,f);
if (result==0) return 0;
ASSERT(strm);
strm->read((char*)&b,1);
return(b);
}
@@ -142,13 +135,12 @@ lib3ds_intb_read(FILE *f)
* \return The signed word read.
*/
Lib3dsIntw
lib3ds_intw_read(FILE *f)
lib3ds_intw_read(iostream *strm)
{
Lib3dsByte b[2];
ASSERT(f);
int result = fread(b,2,1,f);
if (result==0) return 0;
ASSERT(strm);
strm->read((char*)&b,2);
if (s_requiresByteSwap)
{
@@ -169,13 +161,12 @@ lib3ds_intw_read(FILE *f)
* \return The signed dword read.
*/
Lib3dsIntd
lib3ds_intd_read(FILE *f)
lib3ds_intd_read(iostream *strm)
{
Lib3dsByte b[4];
Lib3dsByte b[4];
ASSERT(f);
int result = fread(b,4,1,f);
if (result==0) return 0;
ASSERT(strm);
strm->read((char*)&b,4);
if (s_requiresByteSwap)
{
@@ -183,6 +174,7 @@ lib3ds_intd_read(FILE *f)
}
return (*((Lib3dsIntd*)b));
}
@@ -196,13 +188,13 @@ lib3ds_intd_read(FILE *f)
* \return The float read.
*/
Lib3dsFloat
lib3ds_float_read(FILE *f)
lib3ds_float_read(iostream *strm)
{
Lib3dsByte b[4];
ASSERT(f);
int result = fread(b,4,1,f);
if (result==0) return 0;
ASSERT(strm);
b[0]=b[1]=b[2]=b[3]=0;
strm->read((char*)&b,4);
if (s_requiresByteSwap)
{
@@ -225,18 +217,18 @@ lib3ds_float_read(FILE *f)
* \return The float read.
*/
Lib3dsBool
lib3ds_vector_read(Lib3dsVector v, FILE *f)
lib3ds_vector_read(Lib3dsVector v, iostream *strm)
{
v[0]=lib3ds_float_read(f);
v[1]=lib3ds_float_read(f);
v[2]=lib3ds_float_read(f);
v[0]=lib3ds_float_read(strm);
v[1]=lib3ds_float_read(strm);
v[2]=lib3ds_float_read(strm);
if (ferror(f)) {
if (strm->fail()) {
return(LIB3DS_FALSE);
}
/*printf("lib3ds_vector_read %f %f %f\n",v[0],v[1],v[2]);*/
return(LIB3DS_TRUE);
}
@@ -245,13 +237,13 @@ lib3ds_vector_read(Lib3dsVector v, FILE *f)
* \ingroup readwrite
*/
Lib3dsBool
lib3ds_rgb_read(Lib3dsRgb rgb, FILE *f)
lib3ds_rgb_read(Lib3dsRgb rgb, iostream *strm)
{
rgb[0]=lib3ds_float_read(f);
rgb[1]=lib3ds_float_read(f);
rgb[2]=lib3ds_float_read(f);
rgb[0]=lib3ds_float_read(strm);
rgb[1]=lib3ds_float_read(strm);
rgb[2]=lib3ds_float_read(strm);
if (ferror(f)) {
if (strm->fail()) {
return(LIB3DS_FALSE);
}
/*printf("lib3ds_rgb_read %f %f %f\n",rgb[0],rgb[1],rgb[2]);*/
@@ -272,22 +264,24 @@ lib3ds_rgb_read(Lib3dsRgb rgb, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_string_read(char *s, int buflen, FILE *f)
lib3ds_string_read(char *s, int buflen, iostream *strm)
{
int k=0;
ASSERT(f);
while ((*s++=char(fgetc(f)))!=0) {
if (++k>=buflen) {
return(LIB3DS_FALSE);
}
}
if (ferror(f)) {
ASSERT(s);
s--;
do
{
s++;
k++;
strm->read(s,1);
} while ((*s!=0) && (k<buflen));
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
}
/*!
* \ingroup readwrite
*
@@ -299,10 +293,11 @@ lib3ds_string_read(char *s, int buflen, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_byte_write(Lib3dsByte b, FILE *f)
lib3ds_byte_write(Lib3dsByte b, iostream *strm)
{
ASSERT(f);
if (fwrite(&b,1,1,f)!=1) {
ASSERT(strm);
strm->write((char*)&b,1);
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -320,14 +315,15 @@ lib3ds_byte_write(Lib3dsByte b, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_word_write(Lib3dsWord w, FILE *f)
lib3ds_word_write(Lib3dsWord w, iostream *strm)
{
Lib3dsByte b[2];
ASSERT(f);
ASSERT(strm);
b[1]=(Lib3dsByte)(((Lib3dsWord)w & 0xFF00) >> 8);
b[0]=(Lib3dsByte)((Lib3dsWord)w & 0x00FF);
if (fwrite(b,2,1,f)!=1) {
strm->write((char*)b,2);
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -345,16 +341,18 @@ lib3ds_word_write(Lib3dsWord w, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_dword_write(Lib3dsDword d, FILE *f)
lib3ds_dword_write(Lib3dsDword d, iostream *strm)
{
Lib3dsByte b[4];
ASSERT(f);
ASSERT(strm);
b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24);
b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16);
b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8);
b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF));
if (fwrite(b,4,1,f)!=1) {
strm->write((char*)b,4);
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -372,10 +370,11 @@ lib3ds_dword_write(Lib3dsDword d, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_intb_write(Lib3dsIntb b, FILE *f)
lib3ds_intb_write(Lib3dsIntb b, iostream *strm)
{
ASSERT(f);
if (fwrite(&b,1,1,f)!=1) {
ASSERT(strm);
strm->write((char*)b,1);
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -393,14 +392,16 @@ lib3ds_intb_write(Lib3dsIntb b, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_intw_write(Lib3dsIntw w, FILE *f)
lib3ds_intw_write(Lib3dsIntw w, iostream *strm)
{
Lib3dsByte b[2];
ASSERT(f);
ASSERT(strm);
b[1]=(Lib3dsByte)(((Lib3dsWord)w & 0xFF00) >> 8);
b[0]=(Lib3dsByte)((Lib3dsWord)w & 0x00FF);
if (fwrite(b,2,1,f)!=1) {
strm->write((char*)b,2);
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -418,16 +419,18 @@ lib3ds_intw_write(Lib3dsIntw w, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_intd_write(Lib3dsIntd d, FILE *f)
lib3ds_intd_write(Lib3dsIntd d, iostream *strm)
{
Lib3dsByte b[4];
ASSERT(f);
ASSERT(strm);
b[3]=(Lib3dsByte)(((Lib3dsDword)d & 0xFF000000) >> 24);
b[2]=(Lib3dsByte)(((Lib3dsDword)d & 0x00FF0000) >> 16);
b[1]=(Lib3dsByte)(((Lib3dsDword)d & 0x0000FF00) >> 8);
b[0]=(Lib3dsByte)(((Lib3dsDword)d & 0x000000FF));
if (fwrite(b,4,1,f)!=1) {
strm->write((char*)b,4);
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -444,11 +447,10 @@ lib3ds_intd_write(Lib3dsIntd d, FILE *f)
*
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_float_write(Lib3dsFloat l, FILE *f)
lib3ds_float_write(Lib3dsFloat l, iostream *strm)
{
ASSERT(strm);
Lib3dsByte b[4];
Lib3dsByte* ptr = (Lib3dsByte*) (&l);
@@ -467,8 +469,9 @@ lib3ds_float_write(Lib3dsFloat l, FILE *f)
b[2] = *ptr++;
b[3] = *ptr++;
}
if (fwrite(b,4,1,f)!=1) {
strm->write((char*)b,4);
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -485,15 +488,15 @@ lib3ds_float_write(Lib3dsFloat l, FILE *f)
* \param f Input file stream.
*/
Lib3dsBool
lib3ds_vector_write(Lib3dsVector v, FILE *f)
lib3ds_vector_write(Lib3dsVector v, iostream *strm)
{
if (!lib3ds_float_write(v[0], f)) {
if (!lib3ds_float_write(v[0], strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_float_write(v[1], f)) {
if (!lib3ds_float_write(v[1], strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_float_write(v[2], f)) {
if (!lib3ds_float_write(v[2], strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -504,15 +507,15 @@ lib3ds_vector_write(Lib3dsVector v, FILE *f)
* \ingroup readwrite
*/
Lib3dsBool
lib3ds_rgb_write(Lib3dsRgb rgb, FILE *f)
lib3ds_rgb_write(Lib3dsRgb rgb, iostream *strm)
{
if (!lib3ds_float_write(rgb[0], f)) {
if (!lib3ds_float_write(rgb[0], strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_float_write(rgb[1], f)) {
if (!lib3ds_float_write(rgb[1], strm)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_float_write(rgb[2], f)) {
if (!lib3ds_float_write(rgb[2], strm)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -530,12 +533,12 @@ lib3ds_rgb_write(Lib3dsRgb rgb, FILE *f)
* \return True on success, False otherwise.
*/
Lib3dsBool
lib3ds_string_write(const char *s, FILE *f)
lib3ds_string_write(const char *s, iostream *strm)
{
ASSERT(s);
ASSERT(f);
do fputc(*s,f); while (*s++);
if (ferror(f)) {
ASSERT(strm);
do strm->write(s,1); while (*s++);
if (strm->fail()) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);

44
src/osgPlugins/3ds/readwrite.h
View File

@@ -27,32 +27,34 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
extern LIB3DSAPI void setByteOrder();
extern LIB3DSAPI Lib3dsByte lib3ds_byte_read(FILE *f);
extern LIB3DSAPI Lib3dsWord lib3ds_word_read(FILE *f);
extern LIB3DSAPI Lib3dsDword lib3ds_dword_read(FILE *f);
extern LIB3DSAPI Lib3dsIntb lib3ds_intb_read(FILE *f);
extern LIB3DSAPI Lib3dsIntw lib3ds_intw_read(FILE *f);
extern LIB3DSAPI Lib3dsIntd lib3ds_intd_read(FILE *f);
extern LIB3DSAPI Lib3dsFloat lib3ds_float_read(FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_vector_read(Lib3dsVector v, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_rgb_read(Lib3dsRgb rgb, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_string_read(char *s, int buflen, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_byte_write(Lib3dsByte b, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_word_write(Lib3dsWord w, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_dword_write(Lib3dsDword d, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_intb_write(Lib3dsIntb b, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_intw_write(Lib3dsIntw w, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_intd_write(Lib3dsIntd d, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_float_write(Lib3dsFloat l, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_vector_write(Lib3dsVector v, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_rgb_write(Lib3dsRgb rgb, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_string_write(const char *s, FILE *f);
extern LIB3DSAPI Lib3dsByte lib3ds_byte_read(iostream *strm);
extern LIB3DSAPI Lib3dsWord lib3ds_word_read(iostream *strm);
extern LIB3DSAPI Lib3dsDword lib3ds_dword_read(iostream *strm);
extern LIB3DSAPI Lib3dsIntb lib3ds_intb_read(iostream *strm);
extern LIB3DSAPI Lib3dsIntw lib3ds_intw_read(iostream *strm);
extern LIB3DSAPI Lib3dsIntd lib3ds_intd_read(iostream *strm);
extern LIB3DSAPI Lib3dsFloat lib3ds_float_read(iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_vector_read(Lib3dsVector v, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_rgb_read(Lib3dsRgb rgb, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_string_read(char *s, int buflen, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_byte_write(Lib3dsByte b, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_word_write(Lib3dsWord w, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_dword_write(Lib3dsDword d, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_intb_write(Lib3dsIntb b, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_intw_write(Lib3dsIntw w, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_intd_write(Lib3dsIntd d, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_float_write(Lib3dsFloat l, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_vector_write(Lib3dsVector v, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_rgb_write(Lib3dsRgb rgb, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_string_write(const char *s, iostream *strm);
#ifdef __cplusplus
}

48
src/osgPlugins/3ds/shadow.cpp
View File

@@ -37,48 +37,48 @@
* \ingroup shadow
*/
Lib3dsBool
lib3ds_shadow_read(Lib3dsShadow *shadow, FILE *f)
lib3ds_shadow_read(Lib3dsShadow *shadow, iostream *strm)
{
Lib3dsChunk c;
if (!lib3ds_chunk_read(&c, f)) {
if (!lib3ds_chunk_read(&c, strm)) {
return(LIB3DS_FALSE);
}
switch (c.chunk) {
case LIB3DS_SHADOW_MAP_SIZE:
{
shadow->map_size=lib3ds_intw_read(f);
shadow->map_size=lib3ds_intw_read(strm);
}
break;
case LIB3DS_LO_SHADOW_BIAS:
{
shadow->lo_bias=lib3ds_float_read(f);
shadow->lo_bias=lib3ds_float_read(strm);
}
break;
case LIB3DS_HI_SHADOW_BIAS:
{
shadow->hi_bias=lib3ds_float_read(f);
shadow->hi_bias=lib3ds_float_read(strm);
}
break;
case LIB3DS_SHADOW_SAMPLES:
{
shadow->samples=lib3ds_intw_read(f);
shadow->samples=lib3ds_intw_read(strm);
}
break;
case LIB3DS_SHADOW_RANGE:
{
shadow->range=lib3ds_intd_read(f);
shadow->range=lib3ds_intd_read(strm);
}
break;
case LIB3DS_SHADOW_FILTER:
{
shadow->filter=lib3ds_float_read(f);
shadow->filter=lib3ds_float_read(strm);
}
break;
case LIB3DS_RAY_BIAS:
{
shadow->ray_bias=lib3ds_float_read(f);
shadow->ray_bias=lib3ds_float_read(strm);
}
break;
}
@@ -91,61 +91,61 @@ lib3ds_shadow_read(Lib3dsShadow *shadow, FILE *f)
* \ingroup shadow
*/
Lib3dsBool
lib3ds_shadow_write(Lib3dsShadow *shadow, FILE *f)
lib3ds_shadow_write(Lib3dsShadow *shadow, iostream *strm)
{
if (fabs(shadow->lo_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_LO_SHADOW_BIAS ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_LO_SHADOW_BIAS;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_float_write(shadow->lo_bias,f);
lib3ds_chunk_write(&c,strm);
lib3ds_float_write(shadow->lo_bias,strm);
}
if (fabs(shadow->hi_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_HI_SHADOW_BIAS ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_HI_SHADOW_BIAS;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_float_write(shadow->hi_bias,f);
lib3ds_chunk_write(&c,strm);
lib3ds_float_write(shadow->hi_bias,strm);
}
if (shadow->map_size) { /*---- LIB3DS_SHADOW_MAP_SIZE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SHADOW_MAP_SIZE;
c.size=8;
lib3ds_chunk_write(&c,f);
lib3ds_intw_write(shadow->map_size,f);
lib3ds_chunk_write(&c,strm);
lib3ds_intw_write(shadow->map_size,strm);
}
if (shadow->samples) { /*---- LIB3DS_SHADOW_SAMPLES ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SHADOW_SAMPLES;
c.size=8;
lib3ds_chunk_write(&c,f);
lib3ds_intw_write(shadow->samples,f);
lib3ds_chunk_write(&c,strm);
lib3ds_intw_write(shadow->samples,strm);
}
if (shadow->range) { /*---- LIB3DS_SHADOW_RANGE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SHADOW_RANGE;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_intd_write(shadow->range,f);
lib3ds_chunk_write(&c,strm);
lib3ds_intd_write(shadow->range,strm);
}
if (fabs(shadow->filter)>LIB3DS_EPSILON) { /*---- LIB3DS_SHADOW_FILTER ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SHADOW_FILTER;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_float_write(shadow->filter,f);
lib3ds_chunk_write(&c,strm);
lib3ds_float_write(shadow->filter,strm);
}
if (fabs(shadow->ray_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_RAY_BIAS ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_RAY_BIAS;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_float_write(shadow->ray_bias,f);
lib3ds_chunk_write(&c,strm);
lib3ds_float_write(shadow->ray_bias,strm);
}
return(LIB3DS_TRUE);
}

7
src/osgPlugins/3ds/shadow.h
View File

@@ -27,6 +27,9 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
@@ -45,8 +48,8 @@ struct _Lib3dsShadow {
Lib3dsFloat ray_bias;
};
extern LIB3DSAPI Lib3dsBool lib3ds_shadow_read(Lib3dsShadow *shadow, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_shadow_write(Lib3dsShadow *shadow, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_shadow_read(Lib3dsShadow *shadow, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_shadow_write(Lib3dsShadow *shadow, iostream *strm);
#ifdef __cplusplus
}

37
src/osgPlugins/3ds/tcb.cpp
View File

@@ -77,28 +77,29 @@ lib3ds_tcb(Lib3dsTcb *p, Lib3dsTcb *pc, Lib3dsTcb *c, Lib3dsTcb *nc, Lib3dsTcb *
* \ingroup tcb
*/
Lib3dsBool
lib3ds_tcb_read(Lib3dsTcb *tcb, FILE *f)
lib3ds_tcb_read(Lib3dsTcb *tcb, iostream *strm)
{
Lib3dsWord flags;
tcb->frame=lib3ds_intd_read(f);
tcb->flags=flags=lib3ds_word_read(f);
tcb->frame=lib3ds_intd_read(strm);
tcb->flags=flags=lib3ds_word_read(strm);
if (flags&LIB3DS_USE_TENSION) {
tcb->tens=lib3ds_float_read(f);
tcb->tens=lib3ds_float_read(strm);
}
if (flags&LIB3DS_USE_CONTINUITY) {
tcb->cont=lib3ds_float_read(f);
tcb->cont=lib3ds_float_read(strm);
}
if (flags&LIB3DS_USE_BIAS) {
tcb->bias=lib3ds_float_read(f);
tcb->bias=lib3ds_float_read(strm);
}
if (flags&LIB3DS_USE_EASE_TO) {
tcb->ease_to=lib3ds_float_read(f);
tcb->ease_to=lib3ds_float_read(strm);
}
if (flags&LIB3DS_USE_EASE_FROM) {
tcb->ease_from=lib3ds_float_read(f);
tcb->ease_from=lib3ds_float_read(strm);
}
if (ferror(f)) {
if (strm->fail()){
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
@@ -109,26 +110,26 @@ lib3ds_tcb_read(Lib3dsTcb *tcb, FILE *f)
* \ingroup tcb
*/
Lib3dsBool
lib3ds_tcb_write(Lib3dsTcb *tcb, FILE *f)
lib3ds_tcb_write(Lib3dsTcb *tcb, iostream *strm)
{
lib3ds_intd_write(tcb->frame,f);
lib3ds_word_write(tcb->flags,f);
lib3ds_intd_write(tcb->frame,strm);
lib3ds_word_write(tcb->flags,strm);
if (tcb->flags&LIB3DS_USE_TENSION) {
lib3ds_float_write(tcb->tens,f);
lib3ds_float_write(tcb->tens,strm);
}
if (tcb->flags&LIB3DS_USE_CONTINUITY) {
lib3ds_float_write(tcb->cont,f);
lib3ds_float_write(tcb->cont,strm);
}
if (tcb->flags&LIB3DS_USE_BIAS) {
lib3ds_float_write(tcb->bias,f);
lib3ds_float_write(tcb->bias,strm);
}
if (tcb->flags&LIB3DS_USE_EASE_TO) {
lib3ds_float_write(tcb->ease_to,f);
lib3ds_float_write(tcb->ease_to,strm);
}
if (tcb->flags&LIB3DS_USE_EASE_FROM) {
lib3ds_float_write(tcb->ease_from,f);
lib3ds_float_write(tcb->ease_from,strm);
}
if (ferror(f)) {
if (strm->fail()){
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);

9
src/osgPlugins/3ds/tcb.h
View File

@@ -27,10 +27,15 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
typedef enum _Lib3dsTcbFlags{
LIB3DS_USE_TENSION =0x0001,
LIB3DS_USE_CONTINUITY =0x0002,
@@ -52,8 +57,8 @@ typedef struct _Lib3dsTcb {
extern LIB3DSAPI void lib3ds_tcb(Lib3dsTcb *p, Lib3dsTcb *pc, Lib3dsTcb *c,
Lib3dsTcb *nc, Lib3dsTcb *n, Lib3dsFloat *ksm, Lib3dsFloat *ksp,
Lib3dsFloat *kdm, Lib3dsFloat *kdp);
extern LIB3DSAPI Lib3dsBool lib3ds_tcb_read(Lib3dsTcb *tcb, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_tcb_write(Lib3dsTcb *tcb, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_tcb_read(Lib3dsTcb *tcb, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_tcb_write(Lib3dsTcb *tcb, iostream *strm);
#ifdef __cplusplus
}

116
src/osgPlugins/3ds/tracks.cpp
View File

@@ -196,20 +196,20 @@ lib3ds_bool_track_eval(Lib3dsBoolTrack *track, Lib3dsBool *p, Lib3dsFloat t)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_bool_track_read(Lib3dsBoolTrack *track, FILE *f)
lib3ds_bool_track_read(Lib3dsBoolTrack *track, iostream *strm)
{
int keys;
int i;
Lib3dsBoolKey *k;
track->flags=lib3ds_word_read(f);
lib3ds_dword_read(f);
lib3ds_dword_read(f);
keys=lib3ds_intd_read(f);
track->flags=lib3ds_word_read(strm);
lib3ds_dword_read(strm);
lib3ds_dword_read(strm);
keys=lib3ds_intd_read(strm);
for (i=0; i<keys; ++i) {
k=lib3ds_bool_key_new();
if (!lib3ds_tcb_read(&k->tcb, f)) {
if (!lib3ds_tcb_read(&k->tcb, strm)) {
return(LIB3DS_FALSE);
}
lib3ds_bool_track_insert(track, k);
@@ -223,20 +223,20 @@ lib3ds_bool_track_read(Lib3dsBoolTrack *track, FILE *f)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_bool_track_write(Lib3dsBoolTrack *track, FILE *f)
lib3ds_bool_track_write(Lib3dsBoolTrack *track, iostream *strm)
{
Lib3dsBoolKey *k;
Lib3dsDword num=0;
for (k=track->keyL; k; k=k->next) {
++num;
}
lib3ds_word_write((Lib3dsWord)track->flags,f);
lib3ds_dword_write(0,f);
lib3ds_dword_write(0,f);
lib3ds_dword_write(num,f);
lib3ds_word_write((Lib3dsWord)track->flags,strm);
lib3ds_dword_write(0,strm);
lib3ds_dword_write(0,strm);
lib3ds_dword_write(num,strm);
for (k=track->keyL; k; k=k->next) {
if (!lib3ds_tcb_write(&k->tcb,f)) {
if (!lib3ds_tcb_write(&k->tcb,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -500,23 +500,23 @@ lib3ds_lin1_track_eval(Lib3dsLin1Track *track, Lib3dsFloat *p, Lib3dsFloat t)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_lin1_track_read(Lib3dsLin1Track *track, FILE *f)
lib3ds_lin1_track_read(Lib3dsLin1Track *track, iostream *strm)
{
int keys;
int i;
Lib3dsLin1Key *k;
track->flags=lib3ds_word_read(f);
lib3ds_dword_read(f);
lib3ds_dword_read(f);
keys=lib3ds_intd_read(f);
track->flags=lib3ds_word_read(strm);
lib3ds_dword_read(strm);
lib3ds_dword_read(strm);
keys=lib3ds_intd_read(strm);
for (i=0; i<keys; ++i) {
k=lib3ds_lin1_key_new();
if (!lib3ds_tcb_read(&k->tcb, f)) {
if (!lib3ds_tcb_read(&k->tcb, strm)) {
return(LIB3DS_FALSE);
}
k->value=lib3ds_float_read(f);
k->value=lib3ds_float_read(strm);
lib3ds_lin1_track_insert(track, k);
}
lib3ds_lin1_track_setup(track);
@@ -528,23 +528,23 @@ lib3ds_lin1_track_read(Lib3dsLin1Track *track, FILE *f)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_lin1_track_write(Lib3dsLin1Track *track, FILE *f)
lib3ds_lin1_track_write(Lib3dsLin1Track *track, iostream *strm)
{
Lib3dsLin1Key *k;
Lib3dsDword num=0;
for (k=track->keyL; k; k=k->next) {
++num;
}
lib3ds_word_write((Lib3dsWord)track->flags,f);
lib3ds_dword_write(0,f);
lib3ds_dword_write(0,f);
lib3ds_dword_write(num,f);
lib3ds_word_write((Lib3dsWord)track->flags,strm);
lib3ds_dword_write(0,strm);
lib3ds_dword_write(0,strm);
lib3ds_dword_write(num,strm);
for (k=track->keyL; k; k=k->next) {
if (!lib3ds_tcb_write(&k->tcb,f)) {
if (!lib3ds_tcb_write(&k->tcb,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_float_write(k->value,f);
lib3ds_float_write(k->value,strm);
}
return(LIB3DS_TRUE);
}
@@ -809,24 +809,24 @@ lib3ds_lin3_track_eval(Lib3dsLin3Track *track, Lib3dsVector p, Lib3dsFloat t)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_lin3_track_read(Lib3dsLin3Track *track, FILE *f)
lib3ds_lin3_track_read(Lib3dsLin3Track *track, iostream *strm)
{
int keys;
int i,j;
Lib3dsLin3Key *k;
track->flags=lib3ds_word_read(f);
lib3ds_dword_read(f);
lib3ds_dword_read(f);
keys=lib3ds_intd_read(f);
track->flags=lib3ds_word_read(strm);
lib3ds_dword_read(strm);
lib3ds_dword_read(strm);
keys=lib3ds_intd_read(strm);
for (i=0; i<keys; ++i) {
k=lib3ds_lin3_key_new();
if (!lib3ds_tcb_read(&k->tcb, f)) {
if (!lib3ds_tcb_read(&k->tcb, strm)) {
return(LIB3DS_FALSE);
}
for (j=0; j<3; ++j) {
k->value[j]=lib3ds_float_read(f);
k->value[j]=lib3ds_float_read(strm);
}
lib3ds_lin3_track_insert(track, k);
}
@@ -839,23 +839,23 @@ lib3ds_lin3_track_read(Lib3dsLin3Track *track, FILE *f)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_lin3_track_write(Lib3dsLin3Track *track, FILE *f)
lib3ds_lin3_track_write(Lib3dsLin3Track *track, iostream *strm)
{
Lib3dsLin3Key *k;
Lib3dsDword num=0;
for (k=track->keyL; k; k=k->next) {
++num;
}
lib3ds_word_write((Lib3dsWord)track->flags,f);
lib3ds_dword_write(0,f);
lib3ds_dword_write(0,f);
lib3ds_dword_write(num,f);
lib3ds_word_write((Lib3dsWord)track->flags,strm);
lib3ds_dword_write(0,strm);
lib3ds_dword_write(0,strm);
lib3ds_dword_write(num,strm);
for (k=track->keyL; k; k=k->next) {
if (!lib3ds_tcb_write(&k->tcb,f)) {
if (!lib3ds_tcb_write(&k->tcb,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_vector_write(k->value,f);
lib3ds_vector_write(k->value,strm);
}
return(LIB3DS_TRUE);
}
@@ -1156,25 +1156,25 @@ lib3ds_quat_track_eval(Lib3dsQuatTrack *track, Lib3dsQuat q, Lib3dsFloat t)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_quat_track_read(Lib3dsQuatTrack *track, FILE *f)
lib3ds_quat_track_read(Lib3dsQuatTrack *track, iostream *strm)
{
int keys;
int i,j;
Lib3dsQuatKey *k;
track->flags=lib3ds_word_read(f);
lib3ds_dword_read(f);
lib3ds_dword_read(f);
keys=lib3ds_intd_read(f);
track->flags=lib3ds_word_read(strm);
lib3ds_dword_read(strm);
lib3ds_dword_read(strm);
keys=lib3ds_intd_read(strm);
for (i=0; i<keys; ++i) {
k=lib3ds_quat_key_new();
if (!lib3ds_tcb_read(&k->tcb, f)) {
if (!lib3ds_tcb_read(&k->tcb, strm)) {
return(LIB3DS_FALSE);
}
k->angle=lib3ds_float_read(f);
k->angle=lib3ds_float_read(strm);
for (j=0; j<3; ++j) {
k->axis[j]=lib3ds_float_read(f);
k->axis[j]=lib3ds_float_read(strm);
}
lib3ds_quat_track_insert(track, k);
}
@@ -1187,24 +1187,24 @@ lib3ds_quat_track_read(Lib3dsQuatTrack *track, FILE *f)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_quat_track_write(Lib3dsQuatTrack *track, FILE *f)
lib3ds_quat_track_write(Lib3dsQuatTrack *track, iostream *strm)
{
Lib3dsQuatKey *k;
Lib3dsDword num=0;
for (k=track->keyL; k; k=k->next) {
++num;
}
lib3ds_word_write((Lib3dsWord)track->flags,f);
lib3ds_dword_write(0,f);
lib3ds_dword_write(0,f);
lib3ds_dword_write(num,f);
lib3ds_word_write((Lib3dsWord)track->flags,strm);
lib3ds_dword_write(0,strm);
lib3ds_dword_write(0,strm);
lib3ds_dword_write(num,strm);
for (k=track->keyL; k; k=k->next) {
if (!lib3ds_tcb_write(&k->tcb,f)) {
if (!lib3ds_tcb_write(&k->tcb,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_float_write(k->angle,f);
lib3ds_vector_write(k->axis,f);
lib3ds_float_write(k->angle,strm);
lib3ds_vector_write(k->axis,strm);
}
return(LIB3DS_TRUE);
}
@@ -1364,7 +1364,7 @@ lib3ds_morph_track_eval(Lib3dsMorphTrack *track, char *p, Lib3dsFloat t)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_morph_track_read(Lib3dsMorphTrack *, FILE *)
lib3ds_morph_track_read(Lib3dsMorphTrack *, iostream *strm)
{
/* FIXME: */
return(LIB3DS_TRUE);
@@ -1375,7 +1375,7 @@ lib3ds_morph_track_read(Lib3dsMorphTrack *, FILE *)
* \ingroup tracks
*/
Lib3dsBool
lib3ds_morph_track_write(Lib3dsMorphTrack *, FILE *)
lib3ds_morph_track_write(Lib3dsMorphTrack *, iostream *strm)
{
/* FIXME: */
ASSERT(0);

20
src/osgPlugins/3ds/tracks.h
View File

@@ -154,8 +154,8 @@ extern LIB3DSAPI void lib3ds_bool_track_free_keys(Lib3dsBoolTrack *track);
extern LIB3DSAPI void lib3ds_bool_track_insert(Lib3dsBoolTrack *track, Lib3dsBoolKey* key);
extern LIB3DSAPI void lib3ds_bool_track_remove(Lib3dsBoolTrack *track, Lib3dsIntd frame);
extern LIB3DSAPI void lib3ds_bool_track_eval(Lib3dsBoolTrack *track, Lib3dsBool *p, Lib3dsFloat t);
extern LIB3DSAPI Lib3dsBool lib3ds_bool_track_read(Lib3dsBoolTrack *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_bool_track_write(Lib3dsBoolTrack *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_bool_track_read(Lib3dsBoolTrack *track, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_bool_track_write(Lib3dsBoolTrack *track, iostream *strm);
extern LIB3DSAPI Lib3dsLin1Key* lib3ds_lin1_key_new();
extern LIB3DSAPI void lib3ds_lin1_key_free(Lib3dsLin1Key* key);
@@ -166,8 +166,8 @@ extern LIB3DSAPI void lib3ds_lin1_track_setup(Lib3dsLin1Track *track);
extern LIB3DSAPI void lib3ds_lin1_track_insert(Lib3dsLin1Track *track, Lib3dsLin1Key *key);
extern LIB3DSAPI void lib3ds_lin1_track_remove(Lib3dsLin1Track *track, Lib3dsIntd frame);
extern LIB3DSAPI void lib3ds_lin1_track_eval(Lib3dsLin1Track *track, Lib3dsFloat *p, Lib3dsFloat t);
extern LIB3DSAPI Lib3dsBool lib3ds_lin1_track_read(Lib3dsLin1Track *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_lin1_track_write(Lib3dsLin1Track *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_lin1_track_read(Lib3dsLin1Track *track, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_lin1_track_write(Lib3dsLin1Track *track, iostream *strm);
extern LIB3DSAPI Lib3dsLin3Key* lib3ds_lin3_key_new();
extern LIB3DSAPI void lib3ds_lin3_key_free(Lib3dsLin3Key* key);
@@ -178,8 +178,8 @@ extern LIB3DSAPI void lib3ds_lin3_track_setup(Lib3dsLin3Track *track);
extern LIB3DSAPI void lib3ds_lin3_track_insert(Lib3dsLin3Track *track, Lib3dsLin3Key *key);
extern LIB3DSAPI void lib3ds_lin3_track_remove(Lib3dsLin3Track *track, Lib3dsIntd frame);
extern LIB3DSAPI void lib3ds_lin3_track_eval(Lib3dsLin3Track *track, Lib3dsVector p, Lib3dsFloat t);
extern LIB3DSAPI Lib3dsBool lib3ds_lin3_track_read(Lib3dsLin3Track *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_lin3_track_write(Lib3dsLin3Track *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_lin3_track_read(Lib3dsLin3Track *track, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_lin3_track_write(Lib3dsLin3Track *track, iostream *strm);
extern LIB3DSAPI Lib3dsQuatKey* lib3ds_quat_key_new();
extern LIB3DSAPI void lib3ds_quat_key_free(Lib3dsQuatKey* key);
@@ -190,8 +190,8 @@ extern LIB3DSAPI void lib3ds_quat_track_setup(Lib3dsQuatTrack *track);
extern LIB3DSAPI void lib3ds_quat_track_insert(Lib3dsQuatTrack *track, Lib3dsQuatKey *key);
extern LIB3DSAPI void lib3ds_quat_track_remove(Lib3dsQuatTrack *track, Lib3dsIntd frame);
extern LIB3DSAPI void lib3ds_quat_track_eval(Lib3dsQuatTrack *track, Lib3dsQuat p, Lib3dsFloat t);
extern LIB3DSAPI Lib3dsBool lib3ds_quat_track_read(Lib3dsQuatTrack *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_quat_track_write(Lib3dsQuatTrack *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_quat_track_read(Lib3dsQuatTrack *track, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_quat_track_write(Lib3dsQuatTrack *track, iostream *strm);
extern LIB3DSAPI Lib3dsMorphKey* lib3ds_morph_key_new();
extern LIB3DSAPI void lib3ds_morph_key_free(Lib3dsMorphKey* key);
@@ -199,8 +199,8 @@ extern LIB3DSAPI void lib3ds_morph_track_free_keys(Lib3dsMorphTrack *track);
extern LIB3DSAPI void lib3ds_morph_track_insert(Lib3dsMorphTrack *track, Lib3dsMorphKey *key);
extern LIB3DSAPI void lib3ds_morph_track_remove(Lib3dsMorphTrack *track, Lib3dsIntd frame);
extern LIB3DSAPI void lib3ds_morph_track_eval(Lib3dsMorphTrack *track, char *p, Lib3dsFloat t);
extern LIB3DSAPI Lib3dsBool lib3ds_morph_track_read(Lib3dsMorphTrack *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_morph_track_write(Lib3dsMorphTrack *track, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_morph_track_read(Lib3dsMorphTrack *track, iostream *strm);
extern LIB3DSAPI Lib3dsBool lib3ds_morph_track_write(Lib3dsMorphTrack *track, iostream *strm);
#ifdef __cplusplus
}

212
src/osgPlugins/3ds/viewport.cpp
View File

@@ -38,12 +38,12 @@
* \ingroup viewport
*/
Lib3dsBool
lib3ds_viewport_read(Lib3dsViewport *viewport, FILE *f)
lib3ds_viewport_read(Lib3dsViewport *viewport, iostream *strm)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, 0, f)) {
if (!lib3ds_chunk_read_start(&c, 0, strm)) {
return(LIB3DS_FALSE);
}
@@ -51,42 +51,39 @@ lib3ds_viewport_read(Lib3dsViewport *viewport, FILE *f)
case LIB3DS_VIEWPORT_LAYOUT:
{
int cur=0;
viewport->layout.style=lib3ds_word_read(f);
viewport->layout.active=lib3ds_intw_read(f);
lib3ds_intw_read(f);
viewport->layout.swap=lib3ds_intw_read(f);
lib3ds_intw_read(f);
viewport->layout.swap_prior=lib3ds_intw_read(f);
viewport->layout.swap_view=lib3ds_intw_read(f);
lib3ds_chunk_read_tell(&c, f);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
viewport->layout.style=lib3ds_word_read(strm);
viewport->layout.active=lib3ds_intw_read(strm);
lib3ds_intw_read(strm);
viewport->layout.swap=lib3ds_intw_read(strm);
lib3ds_intw_read(strm);
viewport->layout.swap_prior=lib3ds_intw_read(strm);
viewport->layout.swap_view=lib3ds_intw_read(strm);
lib3ds_chunk_read_tell(&c, strm);
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_VIEWPORT_SIZE:
{
viewport->layout.position[0]=lib3ds_word_read(f);
viewport->layout.position[1]=lib3ds_word_read(f);
viewport->layout.size[0]=lib3ds_word_read(f);
viewport->layout.size[1]=lib3ds_word_read(f);
viewport->layout.position[0]=lib3ds_word_read(strm);
viewport->layout.position[1]=lib3ds_word_read(strm);
viewport->layout.size[0]=lib3ds_word_read(strm);
viewport->layout.size[1]=lib3ds_word_read(strm);
}
break;
case LIB3DS_VIEWPORT_DATA_3:
{
lib3ds_viewport_set_views(viewport,cur+1);
lib3ds_intw_read(f);
viewport->layout.viewL[cur].axis_lock=lib3ds_word_read(f);
viewport->layout.viewL[cur].position[0]=lib3ds_intw_read(f);
viewport->layout.viewL[cur].position[1]=lib3ds_intw_read(f);
viewport->layout.viewL[cur].size[0]=lib3ds_intw_read(f);
viewport->layout.viewL[cur].size[1]=lib3ds_intw_read(f);
viewport->layout.viewL[cur].type=lib3ds_word_read(f);
viewport->layout.viewL[cur].zoom=lib3ds_float_read(f);
lib3ds_vector_read(viewport->layout.viewL[cur].center,f);
viewport->layout.viewL[cur].horiz_angle=lib3ds_float_read(f);
viewport->layout.viewL[cur].vert_angle=lib3ds_float_read(f);
int result = fread(viewport->layout.viewL[cur].camera,11,1,f);
if (result==0) return (LIB3DS_FALSE);
lib3ds_intw_read(strm);
viewport->layout.viewL[cur].axis_lock=lib3ds_word_read(strm);
viewport->layout.viewL[cur].position[0]=lib3ds_intw_read(strm);
viewport->layout.viewL[cur].position[1]=lib3ds_intw_read(strm);
viewport->layout.viewL[cur].size[0]=lib3ds_intw_read(strm);
viewport->layout.viewL[cur].size[1]=lib3ds_intw_read(strm);
viewport->layout.viewL[cur].type=lib3ds_word_read(strm);
viewport->layout.viewL[cur].zoom=lib3ds_float_read(strm);
lib3ds_vector_read(viewport->layout.viewL[cur].center,strm);
viewport->layout.viewL[cur].horiz_angle=lib3ds_float_read(strm);
viewport->layout.viewL[cur].vert_angle=lib3ds_float_read(strm);
strm->read(viewport->layout.viewL[cur].camera,11);
++cur;
}
break;
@@ -103,65 +100,64 @@ lib3ds_viewport_read(Lib3dsViewport *viewport, FILE *f)
case LIB3DS_DEFAULT_VIEW:
{
memset(&viewport->default_view,0,sizeof(Lib3dsDefaultView));
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
switch (chunk) {
case LIB3DS_VIEW_TOP:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_TOP;
lib3ds_vector_read(viewport->default_view.position,f);
viewport->default_view.width=lib3ds_float_read(f);
lib3ds_vector_read(viewport->default_view.position,strm);
viewport->default_view.width=lib3ds_float_read(strm);
}
break;
case LIB3DS_VIEW_BOTTOM:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_BOTTOM;
lib3ds_vector_read(viewport->default_view.position,f);
viewport->default_view.width=lib3ds_float_read(f);
lib3ds_vector_read(viewport->default_view.position,strm);
viewport->default_view.width=lib3ds_float_read(strm);
}
break;
case LIB3DS_VIEW_LEFT:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_LEFT;
lib3ds_vector_read(viewport->default_view.position,f);
viewport->default_view.width=lib3ds_float_read(f);
lib3ds_vector_read(viewport->default_view.position,strm);
viewport->default_view.width=lib3ds_float_read(strm);
}
break;
case LIB3DS_VIEW_RIGHT:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_RIGHT;
lib3ds_vector_read(viewport->default_view.position,f);
viewport->default_view.width=lib3ds_float_read(f);
lib3ds_vector_read(viewport->default_view.position,strm);
viewport->default_view.width=lib3ds_float_read(strm);
}
break;
case LIB3DS_VIEW_FRONT:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_FRONT;
lib3ds_vector_read(viewport->default_view.position,f);
viewport->default_view.width=lib3ds_float_read(f);
lib3ds_vector_read(viewport->default_view.position,strm);
viewport->default_view.width=lib3ds_float_read(strm);
}
break;
case LIB3DS_VIEW_BACK:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_BACK;
lib3ds_vector_read(viewport->default_view.position,f);
viewport->default_view.width=lib3ds_float_read(f);
lib3ds_vector_read(viewport->default_view.position,strm);
viewport->default_view.width=lib3ds_float_read(strm);
}
break;
case LIB3DS_VIEW_USER:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_USER;
lib3ds_vector_read(viewport->default_view.position,f);
viewport->default_view.width=lib3ds_float_read(f);
viewport->default_view.horiz_angle=lib3ds_float_read(f);
viewport->default_view.vert_angle=lib3ds_float_read(f);
viewport->default_view.roll_angle=lib3ds_float_read(f);
lib3ds_vector_read(viewport->default_view.position,strm);
viewport->default_view.width=lib3ds_float_read(strm);
viewport->default_view.horiz_angle=lib3ds_float_read(strm);
viewport->default_view.vert_angle=lib3ds_float_read(strm);
viewport->default_view.roll_angle=lib3ds_float_read(strm);
}
break;
case LIB3DS_VIEW_CAMERA:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_CAMERA;
int result = fread(viewport->default_view.camera,11,1,f);
if (result==0) return (LIB3DS_FALSE);
strm->read(viewport->default_view.camera,11);
}
break;
default:
@@ -172,7 +168,7 @@ lib3ds_viewport_read(Lib3dsViewport *viewport, FILE *f)
break;
}
lib3ds_chunk_read_end(&c, f);
lib3ds_chunk_read_end(&c, strm);
return(LIB3DS_TRUE);
}
@@ -206,58 +202,57 @@ lib3ds_viewport_set_views(Lib3dsViewport *viewport, Lib3dsDword views)
* \ingroup viewport
*/
Lib3dsBool
lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
lib3ds_viewport_write(Lib3dsViewport *viewport, iostream *strm)
{
if (viewport->layout.views) {
Lib3dsChunk c;
unsigned i;
c.chunk=LIB3DS_VIEWPORT_LAYOUT;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
lib3ds_word_write(viewport->layout.style,f);
lib3ds_intw_write(viewport->layout.active,f);
lib3ds_intw_write(0,f);
lib3ds_intw_write(viewport->layout.swap,f);
lib3ds_intw_write(0,f);
lib3ds_intw_write(viewport->layout.swap_prior,f);
lib3ds_intw_write(viewport->layout.swap_view,f);
lib3ds_word_write(viewport->layout.style,strm);
lib3ds_intw_write(viewport->layout.active,strm);
lib3ds_intw_write(0,strm);
lib3ds_intw_write(viewport->layout.swap,strm);
lib3ds_intw_write(0,strm);
lib3ds_intw_write(viewport->layout.swap_prior,strm);
lib3ds_intw_write(viewport->layout.swap_view,strm);
{
Lib3dsChunk c;
c.chunk=LIB3DS_VIEWPORT_SIZE;
c.size=14;
lib3ds_chunk_write(&c,f);
lib3ds_intw_write(viewport->layout.position[0],f);
lib3ds_intw_write(viewport->layout.position[1],f);
lib3ds_intw_write(viewport->layout.size[0],f);
lib3ds_intw_write(viewport->layout.size[1],f);
lib3ds_chunk_write(&c,strm);
lib3ds_intw_write(viewport->layout.position[0],strm);
lib3ds_intw_write(viewport->layout.position[1],strm);
lib3ds_intw_write(viewport->layout.size[0],strm);
lib3ds_intw_write(viewport->layout.size[1],strm);
}
for (i=0; i<viewport->layout.views; ++i) {
Lib3dsChunk c;
c.chunk=LIB3DS_VIEWPORT_DATA_3;
c.size=55;
lib3ds_chunk_write(&c,f);
lib3ds_chunk_write(&c,strm);
lib3ds_intw_write(0,f);
lib3ds_word_write(viewport->layout.viewL[i].axis_lock,f);
lib3ds_intw_write(viewport->layout.viewL[i].position[0],f);
lib3ds_intw_write(viewport->layout.viewL[i].position[1],f);
lib3ds_intw_write(viewport->layout.viewL[i].size[0],f);
lib3ds_intw_write(viewport->layout.viewL[i].size[1],f);
lib3ds_word_write(viewport->layout.viewL[i].type,f);
lib3ds_float_write(viewport->layout.viewL[i].zoom,f);
lib3ds_vector_write(viewport->layout.viewL[i].center,f);
lib3ds_float_write(viewport->layout.viewL[i].horiz_angle,f);
lib3ds_float_write(viewport->layout.viewL[i].vert_angle,f);
int result = fwrite(viewport->layout.viewL[i].camera,11,1,f);
if (result==0) return (LIB3DS_FALSE);
lib3ds_intw_write(0,strm);
lib3ds_word_write(viewport->layout.viewL[i].axis_lock,strm);
lib3ds_intw_write(viewport->layout.viewL[i].position[0],strm);
lib3ds_intw_write(viewport->layout.viewL[i].position[1],strm);
lib3ds_intw_write(viewport->layout.viewL[i].size[0],strm);
lib3ds_intw_write(viewport->layout.viewL[i].size[1],strm);
lib3ds_word_write(viewport->layout.viewL[i].type,strm);
lib3ds_float_write(viewport->layout.viewL[i].zoom,strm);
lib3ds_vector_write(viewport->layout.viewL[i].center,strm);
lib3ds_float_write(viewport->layout.viewL[i].horiz_angle,strm);
lib3ds_float_write(viewport->layout.viewL[i].vert_angle,strm);
strm->write(viewport->layout.viewL[i].camera,11);
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}
@@ -266,7 +261,7 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_DEFAULT_VIEW;
if (!lib3ds_chunk_write_start(&c,f)) {
if (!lib3ds_chunk_write_start(&c,strm)) {
return(LIB3DS_FALSE);
}
@@ -276,9 +271,9 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_VIEW_TOP;
c.size=22;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(viewport->default_view.position,f);
lib3ds_float_write(viewport->default_view.width,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(viewport->default_view.position,strm);
lib3ds_float_write(viewport->default_view.width,strm);
}
break;
case LIB3DS_VIEW_TYPE_BOTTOM:
@@ -286,9 +281,9 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_VIEW_BOTTOM;
c.size=22;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(viewport->default_view.position,f);
lib3ds_float_write(viewport->default_view.width,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(viewport->default_view.position,strm);
lib3ds_float_write(viewport->default_view.width,strm);
}
break;
case LIB3DS_VIEW_TYPE_LEFT:
@@ -296,9 +291,9 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_VIEW_LEFT;
c.size=22;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(viewport->default_view.position,f);
lib3ds_float_write(viewport->default_view.width,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(viewport->default_view.position,strm);
lib3ds_float_write(viewport->default_view.width,strm);
}
break;
case LIB3DS_VIEW_TYPE_RIGHT:
@@ -306,9 +301,9 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_VIEW_RIGHT;
c.size=22;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(viewport->default_view.position,f);
lib3ds_float_write(viewport->default_view.width,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(viewport->default_view.position,strm);
lib3ds_float_write(viewport->default_view.width,strm);
}
break;
case LIB3DS_VIEW_TYPE_FRONT:
@@ -316,9 +311,9 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_VIEW_FRONT;
c.size=22;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(viewport->default_view.position,f);
lib3ds_float_write(viewport->default_view.width,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(viewport->default_view.position,strm);
lib3ds_float_write(viewport->default_view.width,strm);
}
break;
case LIB3DS_VIEW_TYPE_BACK:
@@ -326,9 +321,9 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_VIEW_BACK;
c.size=22;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(viewport->default_view.position,f);
lib3ds_float_write(viewport->default_view.width,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(viewport->default_view.position,strm);
lib3ds_float_write(viewport->default_view.width,strm);
}
break;
case LIB3DS_VIEW_TYPE_USER:
@@ -336,12 +331,12 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_VIEW_USER;
c.size=34;
lib3ds_chunk_write(&c,f);
lib3ds_vector_write(viewport->default_view.position,f);
lib3ds_float_write(viewport->default_view.width,f);
lib3ds_float_write(viewport->default_view.horiz_angle,f);
lib3ds_float_write(viewport->default_view.vert_angle,f);
lib3ds_float_write(viewport->default_view.roll_angle,f);
lib3ds_chunk_write(&c,strm);
lib3ds_vector_write(viewport->default_view.position,strm);
lib3ds_float_write(viewport->default_view.width,strm);
lib3ds_float_write(viewport->default_view.horiz_angle,strm);
lib3ds_float_write(viewport->default_view.vert_angle,strm);
lib3ds_float_write(viewport->default_view.roll_angle,strm);
}
break;
case LIB3DS_VIEW_TYPE_CAMERA:
@@ -349,14 +344,13 @@ lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f)
Lib3dsChunk c;
c.chunk=LIB3DS_VIEW_CAMERA;
c.size=17;
lib3ds_chunk_write(&c,f);
int result = fwrite(viewport->default_view.camera,1,11,f);
if (result==0) return (LIB3DS_FALSE);
lib3ds_chunk_write(&c,strm);
strm->write(viewport->default_view.camera,11); // NAH Potential issue here
}
break;
}
if (!lib3ds_chunk_write_end(&c,f)) {
if (!lib3ds_chunk_write_end(&c,strm)) {
return(LIB3DS_FALSE);
}
}

7
src/osgPlugins/3ds/viewport.h
View File

@@ -27,6 +27,9 @@
#include "types.h"
#endif
#include <iostream>
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
@@ -122,9 +125,9 @@ struct _Lib3dsViewport {
Lib3dsDefaultView default_view;
};
extern LIB3DSAPI Lib3dsBool lib3ds_viewport_read(Lib3dsViewport *viewport, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_viewport_read(Lib3dsViewport *viewport, iostream *strm);
extern LIB3DSAPI void lib3ds_viewport_set_views(Lib3dsViewport *viewport, Lib3dsDword views);
extern LIB3DSAPI Lib3dsBool lib3ds_viewport_write(Lib3dsViewport *viewport, FILE *f);
extern LIB3DSAPI Lib3dsBool lib3ds_viewport_write(Lib3dsViewport *viewport, iostream *strm);
#ifdef __cplusplus
}