FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
bc14e4ecdc
OpenSceneGraph/examples/osgconv/IO_GeoSet.cpp

1098 lines
35 KiB
C++
Raw Normal View History

Added GeoSet to osgconv.
2003-05-21 22:34:12 +08:00
#if defined(_MSC_VER)
#pragma warning( disable : 4786 )
#endif
#include "GeoSet.h"
#include "osg/Notify"
#include "osgDB/Registry"
#include "osgDB/Input"
#include "osgDB/ParameterOutput"
using namespace osg;
using namespace osgDB;
// forward declare functions to use later.
bool GeoSet_readLocalData(Object& obj, Input& fr);
bool GeoSet_writeLocalData(const Object& obj, Output& fw);
bool GeoSet_readIndexData(Input& fr, const char* IndexName, GeoSet::IndexPointer& ip, bool& useCIndex);
bool GeoSet_writeIndexData(Output& fw, const char* IndexName,const GeoSet::IndexPointer& ip);
bool GeoSet_matchBindingTypeStr(const char* str,GeoSet::BindingType& mode);
const char* GeoSet_getBindingTypeStr(GeoSet::BindingType mode);
const char* GeoSet_getInterleavedRowComposition(GeoSet::InterleaveArrayType at);
int GeoSet_getInterleavedRowLength(GeoSet::InterleaveArrayType at);
// register the read and write functions with the osgDB::Registry.
RegisterDotOsgWrapperProxy g_GeoSetFuncProxy
(
new osg::GeoSet,
"GeoSet",
"Object Drawable GeoSet",
&GeoSet_readLocalData,
&GeoSet_writeLocalData,
DotOsgWrapper::READ_AND_WRITE
);
// register the old style 'Geoset' keyword read and write functions with the osgDB::Registry.
RegisterDotOsgWrapperProxy g_GeosetFuncProxy
(
new osg::GeoSet,
"Geoset",
"Object Drawable Geoset",
&GeoSet_readLocalData,
NULL,
DotOsgWrapper::READ_ONLY
);
bool GeoSet_readLocalData(Object& obj, Input& fr)
{
bool iteratorAdvanced = false;
GeoSet& geoset = static_cast<GeoSet&>(obj);
Vec3* coordList = NULL;
bool coordIndexUseCIndex = false;
GeoSet::IndexPointer coordIndex;
Vec3* normalList = NULL;
bool normIndexUseCIndex = false;
GeoSet::IndexPointer normIndex;
Vec4* colorList = NULL;
bool colIndexUseCIndex = false;
GeoSet::IndexPointer colIndex;
Vec2* textureList = NULL;
bool tIndexUseCIndex = false;
GeoSet::IndexPointer tIndex;
float* interleavedArray = NULL;
bool iaIndexUseCIndex = false;
GeoSet::IndexPointer iaIndex;
GeoSet::BindingType bind=GeoSet::BIND_OFF;
GeoSet::BindingType normal_bind=GeoSet::BIND_OFF;
GeoSet::BindingType color_bind=GeoSet::BIND_OFF;
GeoSet::BindingType texture_bind=GeoSet::BIND_OFF;
GeoSet::InterleaveArrayType iaType = GeoSet::IA_OFF;
int start_indent = fr[0].getNoNestedBrackets();
while (!fr.eof() && fr[0].getNoNestedBrackets()>=start_indent)
{
bool fieldAdvanced = false;
bool readPrimitiveLengths = false;
if (fr.matchSequence("tstrips %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::TRIANGLE_STRIP);
}
else if (fr.matchSequence("flat_tstrips %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::FLAT_TRIANGLE_STRIP);
}
else if (fr.matchSequence("polys %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::POLYGON);
}
else if (fr.matchSequence("quadstrip %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::QUAD_STRIP);
}
else if (fr.matchSequence("lineloops %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::LINE_LOOP);
}
else if (fr.matchSequence("linestrip %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::LINE_STRIP);
}
else if (fr.matchSequence("flat_linestrip %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::FLAT_LINE_STRIP);
}
else if (fr.matchSequence("tfans %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::TRIANGLE_FAN);
}
else if (fr.matchSequence("flat_tfans %i {"))
{
readPrimitiveLengths = true;
geoset.setPrimType(GeoSet::FLAT_TRIANGLE_FAN);
}
if (readPrimitiveLengths)
{
int entry = fr[1].getNoNestedBrackets();
fr += 3;
int capacity;
if (!fr[1].getInt(capacity)) capacity=100;
int size = 0;
int* list = new int [capacity];
memset(list,0,capacity*sizeof(int));
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int primLength;
if (fr[0].getInt(primLength))
{
if (size>=capacity)
{
int oldCapacity = capacity;
while(capacity<=size) capacity *= 2;
int* oldList = list;
list = new int[capacity];
memset(list,0,capacity*sizeof(int));
for(int i=0;i<oldCapacity;++i)
{
list[i] = oldList[i];
}
delete [] oldList;
}
list[size] = primLength;
++size;
}
++fr;
}
fieldAdvanced = true;
++fr;
geoset.setNumPrims(size);
geoset.setPrimLengths(list);
}
if (fr.matchSequence("lines %i"))
{
geoset.setPrimType(GeoSet::LINES);
int noLines;
if (fr[1].getInt(noLines)) geoset.setNumPrims(noLines);
fieldAdvanced = true;
fr+=2;
}
if (fr.matchSequence("triangles %i"))
{
geoset.setPrimType(GeoSet::TRIANGLES);
int noTriangles;
if (fr[1].getInt(noTriangles)) geoset.setNumPrims(noTriangles);
fieldAdvanced = true;
fr+=2;
}
if (fr.matchSequence("quads %i"))
{
geoset.setPrimType(GeoSet::QUADS);
int noQuads;
if (fr[1].getInt(noQuads)) geoset.setNumPrims(noQuads);
fieldAdvanced = true;
fr+=2;
}
if (fr.matchSequence("points %i"))
{
geoset.setPrimType(GeoSet::POINTS);
int noPoints;
if (fr[1].getInt(noPoints)) geoset.setNumPrims(noPoints);
fieldAdvanced = true;
fr+=2;
}
bool matchFirst = false;
if ((matchFirst=fr.matchSequence("Coords {")) || fr.matchSequence("Coords %i {"))
{
// set up coordinates.
int entry = fr[0].getNoNestedBrackets();
int capacity = 100;
if (matchFirst)
{
fr += 2;
}
else
{
fr[1].getInt(capacity);
fr += 3;
}
int size = 0;
coordList = new Vec3[capacity];
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
float x,y,z;
if (fr[0].getFloat(x) && fr[1].getFloat(y) && fr[2].getFloat(z))
{
fr += 3;
if (size>=capacity)
{
int oldCapacity = capacity;
while(capacity<=size) capacity *= 2;
Vec3* oldList = coordList;
coordList = new Vec3[capacity];
for(int i=0;i<oldCapacity;++i)
{
coordList[i][0] = oldList[i][0];
coordList[i][1] = oldList[i][1];
coordList[i][2] = oldList[i][2];
}
delete [] oldList;
}
coordList[size][0] = x;
coordList[size][1] = y;
coordList[size][2] = z;
++size;
}
else
{
++fr;
}
}
fieldAdvanced = true;
++fr;
}
if (GeoSet_readIndexData(fr, "CoordIndex" ,coordIndex, coordIndexUseCIndex))
{
fieldAdvanced = true;
}
if (fr[0].matchWord("Normal_Binding") && GeoSet_matchBindingTypeStr(fr[1].getStr(),bind))
{
normal_bind = bind;
fr+=2;
iteratorAdvanced = true;
}
if ((matchFirst=fr.matchSequence("Normals {")) || fr.matchSequence("Normals %i {"))
{
// set up normalinates.
int entry = fr[0].getNoNestedBrackets();
int capacity = 100;
if (matchFirst)
{
fr += 2;
}
else
{
fr[1].getInt(capacity);
fr += 3;
}
int size = 0;
normalList = new Vec3[capacity];
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
float x,y,z;
if (fr[0].getFloat(x) && fr[1].getFloat(y) && fr[2].getFloat(z))
{
fr += 3;
if (size>=capacity)
{
int oldCapacity = capacity;
while(capacity<=size) capacity *= 2;
Vec3* oldList = normalList;
normalList = new Vec3[capacity];
for(int i=0;i<oldCapacity;++i)
{
normalList[i][0] = oldList[i][0];
normalList[i][1] = oldList[i][1];
normalList[i][2] = oldList[i][2];
}
delete [] oldList;
}
normalList[size][0] = x;
normalList[size][1] = y;
normalList[size][2] = z;
++size;
}
else
{
++fr;
}
}
fieldAdvanced = true;
++fr;
}
if (GeoSet_readIndexData(fr, "NIndex" ,normIndex, normIndexUseCIndex))
{
fieldAdvanced = true;
}
if (fr[0].matchWord("Color_Binding") && GeoSet_matchBindingTypeStr(fr[1].getStr(),bind))
{
color_bind = bind;
fr+=2;
iteratorAdvanced = true;
}
if ((matchFirst=fr.matchSequence("Colors {")) || fr.matchSequence("Colors %i {"))
{
// set up coordinates.
int entry = fr[0].getNoNestedBrackets();
int capacity = 100;
if (matchFirst)
{
fr += 2;
}
else
{
fr[1].getInt(capacity);
fr += 3;
}
int size = 0;
colorList = new Vec4[capacity];
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
float r,g,b,a;
if (fr[0].getFloat(r) && fr[1].getFloat(g) && fr[2].getFloat(b) && fr[3].getFloat(a))
{
fr += 4;
if (size>=capacity)
{
int oldCapacity = capacity;
while(capacity<=size) capacity *= 2;
Vec4* oldList = colorList;
colorList = new Vec4[capacity];
for(int i=0;i<oldCapacity;++i)
{
colorList[i][0] = oldList[i][0];
colorList[i][1] = oldList[i][1];
colorList[i][2] = oldList[i][2];
colorList[i][3] = oldList[i][3];
}
delete [] oldList;
}
colorList[size][0] = r;
colorList[size][1] = g;
colorList[size][2] = b;
colorList[size][3] = a;
++size;
}
else
{
++fr;
}
}
fieldAdvanced = true;
++fr;
}
if (GeoSet_readIndexData(fr, "ColIndex" ,colIndex, colIndexUseCIndex))
{
fieldAdvanced = true;
}
if (fr[0].matchWord("Texture_Binding") && GeoSet_matchBindingTypeStr(fr[1].getStr(),bind))
{
texture_bind = bind;
fr+=2;
iteratorAdvanced = true;
}
if ((matchFirst=fr.matchSequence("TCoords {")) || fr.matchSequence("TCoords %i {"))
{
// set up coordinates.
int entry = fr[0].getNoNestedBrackets();
int capacity = 100;
if (matchFirst)
{
fr += 2;
}
else
{
fr[1].getInt(capacity);
fr += 3;
}
int size = 0;
textureList = new Vec2[capacity];
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
float r,s;
if (fr[0].getFloat(r) && fr[1].getFloat(s))
{
fr += 2;
if (size>=capacity)
{
int oldCapacity = capacity;
while(capacity<=size) capacity *= 2;
Vec2* oldList = textureList;
textureList = new Vec2[capacity];
for(int i=0;i<oldCapacity;++i)
{
textureList[i][0] = oldList[i][0];
textureList[i][1] = oldList[i][1];
}
delete [] oldList;
}
textureList[size][0] = r;
textureList[size][1] = s;
++size;
}
else
{
++fr;
}
}
fieldAdvanced = true;
++fr;
}
if (GeoSet_readIndexData(fr, "TIndex" ,tIndex, tIndexUseCIndex))
{
fieldAdvanced = true;
}
if ((matchFirst=fr.matchSequence("InterleavedArray %w {")) ||
fr.matchSequence("InterleavedArray %w %i {"))
{
// set up coordinates.
int entry = fr[0].getNoNestedBrackets();
const char* type = fr[1].getStr();
if (strcmp(type,"IA_OFF")==0) iaType = GeoSet::IA_OFF;
else if (strcmp(type,"IA_V2F")==0) iaType =GeoSet::IA_V2F;
else if (strcmp(type,"IA_V3F")==0) iaType =GeoSet::IA_V3F;
else if (strcmp(type,"IA_C4UB_V2F")==0) iaType =GeoSet::IA_C4UB_V2F;
else if (strcmp(type,"IA_C4UB_V3F")==0) iaType =GeoSet::IA_C4UB_V3F;
else if (strcmp(type,"IA_C3F_V3F")==0) iaType =GeoSet::IA_C3F_V3F;
else if (strcmp(type,"IA_N3F_V3F")==0) iaType =GeoSet::IA_N3F_V3F;
else if (strcmp(type,"IA_C4F_N3F_V3F")==0) iaType =GeoSet::IA_C4F_N3F_V3F;
else if (strcmp(type,"IA_T2F_V3F")==0) iaType =GeoSet::IA_T2F_V3F;
else if (strcmp(type,"IA_T4F_V4F")==0) iaType =GeoSet::IA_T4F_V4F;
else if (strcmp(type,"IA_T2F_C4UB_V3F")==0) iaType =GeoSet::IA_T2F_C4UB_V3F;
else if (strcmp(type,"IA_T2F_C3F_V3F")==0) iaType =GeoSet::IA_T2F_C3F_V3F;
else if (strcmp(type,"IA_T2F_N3F_V3F")==0) iaType =GeoSet::IA_T2F_N3F_V3F;
else if (strcmp(type,"IA_T2F_C4F_N3F_V3F")==0) iaType =GeoSet::IA_T2F_C4F_N3F_V3F;
else if (strcmp(type,"IA_T4F_C4F_N3F_V4F")==0) iaType =GeoSet::IA_T4F_C4F_N3F_V4F;
else
{
iaType = GeoSet::IA_OFF;
}
int capacity = 100;
if (matchFirst)
{
fr += 3;
}
else
{
fr[2].getInt(capacity);
fr += 4;
}
if (iaType == GeoSet::IA_OFF)
{
// no data should be read - read over {}.
interleavedArray = NULL;
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) ++fr;
}
else
{
// now read the data rows between the {}.
const char* rowComp = GeoSet_getInterleavedRowComposition(iaType);
int rowLength = GeoSet_getInterleavedRowLength(iaType);
int size = 0;
unsigned char* dataList = new unsigned char[capacity*rowLength];
unsigned char* rowData = new unsigned char [rowLength];
float floatData;
int intData;
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned char* itrRowData = rowData;
const char* itrRowComp = rowComp;
int rn = 0;
while (*itrRowComp!=0 && !fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
if (*itrRowComp=='f')
{
if (!fr[rn].getFloat(floatData)) break;
*(float*)itrRowData = floatData;
itrRowData += 4;
}
else
{
if (!fr[rn].getInt(intData)) break;
*itrRowData = (unsigned char)intData;
itrRowData += 1;
}
++itrRowComp;
++rn;
}
if (*itrRowComp==0)
{
fr += rn;
if (size>=capacity)
{
int oldCapacity = capacity;
while(capacity<=size) capacity *= 2;
unsigned char* oldList = dataList;
dataList = new unsigned char[capacity*rowLength];
memcpy(dataList,oldList,oldCapacity*rowLength);
delete [] oldList;
}
memcpy(dataList+size*rowLength,rowData,rowLength);
++size;
}
else
{
if (!fr.eof() && fr[0].getNoNestedBrackets()>entry) ++fr;
}
}
delete [] rowData;
interleavedArray = (float*)dataList;
}
fieldAdvanced = true;
++fr;
}
if (GeoSet_readIndexData(fr, "InterleavedArrayIndex" ,iaIndex, iaIndexUseCIndex))
{
fieldAdvanced = true;
}
if (!fieldAdvanced)
{
if (fr[0].getNoNestedBrackets()>start_indent) fr.advanceToEndOfBlock(start_indent+1);
else ++fr;
}
iteratorAdvanced = true;
}
// set up the coord lists.
if (coordList)
{
geoset.setCoords(coordList,coordIndex);
}
// set up the normal lists.
if (normalList)
{
geoset.setNormalBinding(normal_bind);
if (normIndexUseCIndex) geoset.setNormals(normalList,coordIndex);
else geoset.setNormals(normalList,normIndex);
} else geoset.setNormalBinding(GeoSet::BIND_OFF);
// set up the color lists.
if (colorList)
{
geoset.setColorBinding(color_bind);
if (colIndexUseCIndex) geoset.setColors(colorList,coordIndex);
else geoset.setColors(colorList,colIndex);
} else geoset.setColorBinding(GeoSet::BIND_OFF);
if (textureList)
{
geoset.setTextureBinding(texture_bind);
if (tIndexUseCIndex) geoset.setTextureCoords(textureList,coordIndex);
else geoset.setTextureCoords(textureList,tIndex);
} else geoset.setTextureBinding(GeoSet::BIND_OFF);
if (interleavedArray)
{
if (iaIndexUseCIndex) geoset.setInterleavedArray(iaType,interleavedArray,coordIndex);
else geoset.setInterleavedArray(iaType,interleavedArray,iaIndex);
};
return iteratorAdvanced;
}
bool GeoSet_writeLocalData(const Object& obj, Output& fw)
{
int i;
const GeoSet& geoset = static_cast<const GeoSet&>(obj);
// write out primitives.
bool writeOutPrimitiveLengths = false;
switch(geoset.getPrimType())
{
case (GeoSet::TRIANGLE_STRIP):
fw.indent()<<"tstrips "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
break;
case (GeoSet::FLAT_TRIANGLE_STRIP):
fw.indent()<<"flat_tstrips "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
break;
case (GeoSet::POLYGON):
fw.indent()<<"polys "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
break;
case (GeoSet::QUAD_STRIP):
fw.indent()<<"quadstrip "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
break;
case (GeoSet::LINE_LOOP):
fw.indent()<<"lineloops "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
break;
case (GeoSet::LINE_STRIP):
fw.indent()<<"linestrip "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
break;
case (GeoSet::FLAT_LINE_STRIP):
fw.indent()<<"flat_linestrip "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
break;
case (GeoSet::TRIANGLE_FAN):
fw.indent()<<"tfans "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
case (GeoSet::FLAT_TRIANGLE_FAN):
fw.indent()<<"flat_tfans "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = true;
break;
case (GeoSet::LINES):
fw.indent()<<"lines "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = false;
break;
case (GeoSet::TRIANGLES):
fw.indent()<<"triangles "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = false;
break;
case (GeoSet::QUADS):
fw.indent()<<"quads "<< geoset.getNumPrims() << std::endl;
writeOutPrimitiveLengths = false;
break;
case (GeoSet::POINTS) :
fw.indent()<<"points "<< geoset.getNumPrims() << std::endl;
break;
default:
notify(WARN) << "GeoSet::writeLocalData() - unhandled primitive type = "<<(int)geoset.getPrimType()<< std::endl;
}
if (writeOutPrimitiveLengths)
{
writeArray(fw,geoset.getPrimLengths(),geoset.getPrimLengths()+geoset.getNumPrims());
}
GeoSet& non_const_geoset = const_cast<GeoSet&>(geoset);
non_const_geoset.computeNumVerts();
if (geoset.getCoords())
{
// write out _coords.
fw.indent() << "Coords " << geoset.getNumCoords()<< std::endl;
fw.indent() << "{"<< std::endl;
fw.moveIn();
const Vec3* coords = geoset.getCoords();
for(i=0;i<geoset.getNumCoords();++i)
{
fw.indent() << coords[i][0] << ' ' << coords[i][1] << ' ' << coords[i][2] << std::endl;
}
fw.moveOut();
fw.indent()<<"}"<< std::endl;
}
if (geoset.getCoordIndices()._size)
{
GeoSet_writeIndexData(fw,"CoordIndex",geoset.getCoordIndices());
}
if (geoset.getNormals())
{
// write out _normals.
fw.indent() << "Normal_Binding "<<GeoSet_getBindingTypeStr(geoset.getNormalBinding())<< std::endl;
fw.indent() << "Normals " << geoset.getNumNormals()<< std::endl;
fw.indent() << "{"<< std::endl;
fw.moveIn();
const Vec3* norms = geoset.getNormals();
for(i=0;i<geoset.getNumNormals();++i)
{
fw.indent() << norms[i][0] << ' ' << norms[i][1] << ' ' << norms[i][2] << std::endl;
}
fw.moveOut();
fw.indent()<<"}"<< std::endl;
}
if (geoset.getNormalIndices()._size)
{
if (geoset.getNormalIndices()==geoset.getCoordIndices())
{
fw.indent() << "NIndex Use_CIndex"<< std::endl;
}
else
{
GeoSet_writeIndexData(fw,"NIndex",geoset.getNormalIndices());
}
}
if (geoset.getColors())
{
// write out _colors.
fw.indent() << "Color_Binding "<<GeoSet_getBindingTypeStr(geoset.getColorBinding())<< std::endl;
fw.indent() << "Colors " << geoset.getNumColors()<< std::endl;
fw.indent() << "{"<< std::endl;
fw.moveIn();
const Vec4* colors = geoset.getColors();
for(i=0;i<geoset.getNumColors();++i)
{
fw.indent() << colors[i][0] << ' ' << colors[i][1] << ' ' << colors[i][2] << ' ' << colors[i][3] << std::endl;
}
fw.moveOut();
fw.indent()<<"}"<< std::endl;
}
if (geoset.getColorIndices()._size)
{
if (geoset.getColorIndices()==geoset.getCoordIndices())
{
fw.indent() << "ColIndex Use_CIndex"<< std::endl;
}
else
{
GeoSet_writeIndexData(fw,"ColIndex",geoset.getColorIndices());
}
}
if (geoset.getTextureCoords())
{
// write out _tcoords.
fw.indent() << "Texture_Binding "<<GeoSet_getBindingTypeStr(geoset.getTextureBinding())<< std::endl;
fw.indent() << "TCoords " << geoset.getNumTextureCoords()<< std::endl;
fw.indent() << "{"<< std::endl;
fw.moveIn();
const Vec2* tcoords = geoset.getTextureCoords();
for(i=0;i<geoset.getNumTextureCoords();++i)
{
fw.indent() << tcoords[i][0] << ' ' << tcoords[i][1] << std::endl;
}
fw.moveOut();
fw.indent()<<"}"<< std::endl;
}
if (geoset.getTextureIndices()._size)
{
if (geoset.getTextureIndices()==geoset.getCoordIndices())
{
fw.indent() << "TIndex Use_CIndex"<< std::endl;
}
else
{
GeoSet_writeIndexData(fw,"TIndex",geoset.getTextureIndices());
}
}
if (geoset.getInterleavedArray())
{
// write out the interleaved arrays.
const char* rowComp = GeoSet_getInterleavedRowComposition(geoset.getInterleavedFormat());
fw.indent() << "InterleavedArray ";
switch(geoset.getInterleavedFormat())
{
case(GeoSet::IA_OFF): fw << "IA_OFF"; break;
case(GeoSet::IA_V2F): fw << "IA_V2F"; break;
case(GeoSet::IA_V3F): fw << "IA_V3F"; break;
case(GeoSet::IA_C4UB_V2F): fw << "IA_C4UB_V2F"; break;
case(GeoSet::IA_C4UB_V3F): fw << "IA_C4UB_V3F"; break;
case(GeoSet::IA_C3F_V3F): fw << "IA_C3F_V3F"; break;
case(GeoSet::IA_N3F_V3F): fw << "IA_N3F_V3F"; break;
case(GeoSet::IA_C4F_N3F_V3F): fw << "IA_C4F_N3F_V3F"; break;
case(GeoSet::IA_T2F_V3F): fw << "IA_T2F_V3F"; break;
case(GeoSet::IA_T4F_V4F): fw << "IA_T4F_V4F"; break;
case(GeoSet::IA_T2F_C4UB_V3F): fw << "IA_T2F_C4UB_V3F"; break;
case(GeoSet::IA_T2F_C3F_V3F): fw << "IA_T2F_C3F_V3F"; break;
case(GeoSet::IA_T2F_N3F_V3F): fw << "IA_T2F_N3F_V3F"; break;
case(GeoSet::IA_T2F_C4F_N3F_V3F): fw << "IA_T2F_C4F_N3F_V3F"; break;
case(GeoSet::IA_T4F_C4F_N3F_V4F): fw << "IA_T4F_C4F_N3F_V4F"; break;
default: fw << "IA_OFF"; break;
}
fw << " " << geoset.getNumInterleavedCoords()<< std::endl;
fw.indent() << "{"<< std::endl;
fw.moveIn();
const unsigned char* itrRowData = (const unsigned char*)geoset.getInterleavedArray();
for(i=0;i<geoset.getNumInterleavedCoords();++i)
{
fw.indent();
const char* itrRowComp = rowComp;
while (*itrRowComp!=0)
{
if (*itrRowComp=='f')
{
fw << *(float*)itrRowData<<" ";
itrRowData += 4;
}
else
{
fw << (int)*itrRowData<<" ";
itrRowData += 1;
}
itrRowComp++;
}
fw << std::endl ;
}
fw.moveOut();
fw.indent()<<"}"<< std::endl;
}
return true;
}
bool GeoSet_readIndexData(Input& fr, const char* IndexName, GeoSet::IndexPointer& ip, bool& useCIndex)
{
if (!fr[0].matchWord(IndexName)) return false;
bool fieldAdvanced = true;
if (fr[1].matchWord("Use_CIndex"))
{
fr += 2;
useCIndex = true;
fieldAdvanced = true;
}
else
{
useCIndex = false;
int entry = fr[0].getNoNestedBrackets();
bool is_ushort = true;
int capacity = 100;
int i=1;
if (fr[i].matchWord("ushort")) { is_ushort = true; ++i; }
else if (fr[i].matchWord("uint")) { is_ushort = false; ++i; }
if (fr[i].isInt()) { fr[i].getInt(capacity); ++i; }
if (fr[i].isOpenBracket())
{
++i;
fr += i;
int size = 0;
if (is_ushort)
{
// read ushorts...
GLushort* coordIndexList = new GLushort[capacity];
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int index;
if (fr[0].getInt(index))
{
if (size>=capacity)
{
int oldCapacity = capacity;
while(capacity<=size) capacity *= 2;
GLushort* oldList = coordIndexList;
coordIndexList = new GLushort[capacity];
for(int i=0;i<oldCapacity;++i)
{
coordIndexList[i] = oldList[i];
}
delete [] oldList;
}
coordIndexList[size] = index;
++size;
}
++fr;
}
fieldAdvanced = true;
++fr;
ip.set(size,coordIndexList);
}
else
{
// read uints...
GLuint* coordIndexList = new GLuint[capacity];
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int index;
if (fr[0].getInt(index))
{
if (size>=capacity)
{
int oldCapacity = capacity;
while(capacity<=size) capacity *= 2;
GLuint* oldList = coordIndexList;
coordIndexList = new GLuint[capacity];
for(int i=0;i<oldCapacity;++i)
{
coordIndexList[i] = oldList[i];
}
delete [] oldList;
}
coordIndexList[size] = index;
++size;
}
++fr;
}
fieldAdvanced = true;
++fr;
ip.set(size,coordIndexList);
}
}
}
return fieldAdvanced;
}
bool GeoSet_writeIndexData(Output& fw, const char* IndexName,const GeoSet::IndexPointer& ip)
{
if (ip._size)
{
if (ip._is_ushort)
{
// write our CoordIndex
fw.indent() << IndexName << " ushort " << ip._size<< std::endl;
writeArray(fw,ip._ptr._ushort,ip._ptr._ushort+ip._size);
}
else
{
// write our CoordIndex
fw.indent() << IndexName << " uint " << ip._size<< std::endl;
writeArray(fw,ip._ptr._uint,ip._ptr._uint+ip._size);
}
return true;
}
else
{
return false;
}
}
bool GeoSet_matchBindingTypeStr(const char* str,GeoSet::BindingType& mode)
{
if (strcmp(str,"OFF")==0) mode = GeoSet::BIND_OFF;
else if (strcmp(str,"OVERALL")==0) mode = GeoSet::BIND_OVERALL;
else if (strcmp(str,"PER_PRIMITIVE")==0) mode = GeoSet::BIND_PERPRIM;
else if (strcmp(str,"PER_VERTEX")==0) mode = GeoSet::BIND_PERVERTEX;
else if (strcmp(str,"DEFAULT")==0) mode = GeoSet::BIND_DEFAULT;
else return false;
return true;
}
const char* GeoSet_getBindingTypeStr(GeoSet::BindingType mode)
{
switch(mode)
{
case (GeoSet::BIND_OFF) : return "OFF";
case (GeoSet::BIND_OVERALL) : return "OVERALL";
case (GeoSet::BIND_PERPRIM) : return "PER_PRIMITIVE";
case (GeoSet::BIND_PERVERTEX) : return "PER_VERTEX";
case (GeoSet::BIND_DEFAULT):
default : return "DEFAULT";
}
}
const char* GeoSet_getInterleavedRowComposition(GeoSet::InterleaveArrayType at)
{
switch(at)
{
case(GeoSet::IA_OFF): return "";
case(GeoSet::IA_V2F): return "ff";
case(GeoSet::IA_V3F): return "fff";
case(GeoSet::IA_C4UB_V2F): return "bbbbff";
case(GeoSet::IA_C4UB_V3F): return "bbbbfff";
case(GeoSet::IA_C3F_V3F): return "ffffff";
case(GeoSet::IA_N3F_V3F): return "ffffff";
case(GeoSet::IA_C4F_N3F_V3F): return "ffffffffff";
case(GeoSet::IA_T2F_V3F): return "fffff";
case(GeoSet::IA_T4F_V4F): return "ffffffff";
case(GeoSet::IA_T2F_C4UB_V3F): return "ffbbbbfff";
case(GeoSet::IA_T2F_C3F_V3F): return "ffffffff";
case(GeoSet::IA_T2F_N3F_V3F): return "ffffffff";
case(GeoSet::IA_T2F_C4F_N3F_V3F): return "ffffffffffff";
case(GeoSet::IA_T4F_C4F_N3F_V4F): return "fffffffffffffff";
}
return "";
}
int GeoSet_getInterleavedRowLength(GeoSet::InterleaveArrayType at)
{
switch(at)
{
case(GeoSet::IA_OFF): return 0;
case(GeoSet::IA_V2F): return 8;
case(GeoSet::IA_V3F): return 6;
case(GeoSet::IA_C4UB_V2F): return 12;
case(GeoSet::IA_C4UB_V3F): return 16;
case(GeoSet::IA_C3F_V3F): return 24;
case(GeoSet::IA_N3F_V3F): return 24;
case(GeoSet::IA_C4F_N3F_V3F): return 40;
case(GeoSet::IA_T2F_V3F): return 20;
case(GeoSet::IA_T4F_V4F): return 32;
case(GeoSet::IA_T2F_C4UB_V3F): return 24;
case(GeoSet::IA_T2F_C3F_V3F): return 32;
case(GeoSet::IA_T2F_N3F_V3F): return 32;
case(GeoSet::IA_T2F_C4F_N3F_V3F): return 48;
case(GeoSet::IA_T4F_C4F_N3F_V4F): return 60;
}
return 0;
}
Reference in New Issue Copy Permalink