//----------------------------
// Function name: read
//----------------------------
//
//Parameters:
//p: Scene &image, const char *fileName
//GlobalVars:
//g:
//Returns:
//r:bool
// Caution
//c:
//Assumations:
//a:
//Describtions:
//d: read the image from the given file
//SeeAlso:
//s:
//
//------------------------------
NodeTransitPtr OBJSceneFileType::read( std::istream &is,
const Char8 *,
Resolver ) const
{
NodeUnrecPtr rootPtr, nodePtr;
std::string elem;
std::map<std::string, DataElem>::const_iterator elemI;
Vec3f vec3r;
Pnt3f pnt3r;
Vec2f vec2r;
Real32 x,y,z;
GeoPnt3fPropertyUnrecPtr coordPtr = GeoPnt3fProperty::create();
GeoVec2fPropertyUnrecPtr texCoordPtr = GeoVec2fProperty::create();
GeoVec3fPropertyUnrecPtr normalPtr = GeoVec3fProperty::create();
GeometryUnrecPtr geoPtr;
GeoIntegralPropertyUnrecPtr posIndexPtr, texIndexPtr, normalIndexPtr;
GeoIntegralPropertyUnrecPtr lensPtr;
GeoIntegralPropertyUnrecPtr typePtr;
DataElem dataElem;
DataElem lastDataElem;
Char8 strBuf[8192], *token, *nextToken;
Int32 strBufSize = sizeof(strBuf)/sizeof(Char8);
Int32 index, posIndex = 0, indexType;
Int32 i,j,n,primCount[3];
std::list<Mesh> meshList;
std::map<std::string, SimpleTexturedMaterialUnrecPtr> mtlMap;
std::map<std::string, SimpleTexturedMaterialUnrecPtr>::iterator mtlI;
Mesh emptyMesh;
Face emptyFace;
TiePoint emptyTie;
Int32 indexMask, meshIndexMask;
std::list<Face>::iterator faceI;
std::list<Mesh>::iterator meshI;
bool isSingleIndex;
// create the first mesh entry
meshList.push_back(emptyMesh);
meshI = meshList.begin();
if(is)
{
primCount[0] = 0;
primCount[1] = 0;
primCount[2] = 0;
for(is >> elem; is.eof() == false; is >> elem)
{
if(elem[0] == '#' || elem[0] == '$')
{
is.ignore(INT_MAX, '\n');
}
else
{
SceneFileHandler::the()->updateReadProgress();
elemI = _dataElemMap.find(elem);
dataElem = ((elemI == _dataElemMap.end()) ?
UNKNOWN_DE : elemI->second );
switch (dataElem)
{
case OBJECT_DE:
case GROUP_DE:
case SMOOTHING_GROUP_DE:
is.ignore(INT_MAX, '\n');
break;
case VERTEX_DE:
primCount[0]++;
is >> x >> y >> z;
pnt3r.setValues(x,y,z);
coordPtr->addValue(pnt3r);
break;
case VERTEX_TEXTURECOORD_DE:
primCount[1]++;
is >> x >> y;
vec2r.setValues(x,y);
texCoordPtr->addValue(vec2r);
break;
case VERTEX_NORMAL_DE:
primCount[2]++;
is >> x >> y >> z;
vec3r.setValues(x,y,z);
normalPtr->addValue(vec3r);
break;
case LIB_MTL_DE:
is >> elem;
readMTL ( elem.c_str(), mtlMap );
is.ignore(INT_MAX, '\n');
break;
case USE_MTL_DE:
is >> elem;
if (meshI->faceList.empty() == false)
{
meshList.push_front(emptyMesh);
meshI = meshList.begin();
}
mtlI = mtlMap.find(elem);
if (mtlI == mtlMap.end())
{
FFATAL (("Unkown mtl %s\n", elem.c_str()));
}
else
{
meshI->mtlPtr = mtlI->second;
}
break;
case FACE_DE:
meshI->faceList.push_front(emptyFace);
faceI = meshI->faceList.begin();
is.get(strBuf,strBufSize);
token = strBuf;
indexType = 0;
while(token && *token)
{
// some tools use line continuation for long
// face definitions - these use a \ at the line
// end
if(*token == '\\')
{
is.ignore(1, '\n');
is.get(strBuf,strBufSize);
token = strBuf;
indexType = 0;
continue;
}
for (; *token == '/'; token++)
indexType++;
for (; isspace(*token); token++)
indexType = 0;
index = strtol(token, &nextToken, 10);
if (token == nextToken)
break;
if (indexType == 0)
faceI->tieVec.push_back(emptyTie);
if (index >= 0)
index--;
else
index = primCount[indexType] + index;
faceI->tieVec.back().index[indexType] = index;
token = nextToken;
}
break;
case UNKNOWN_DE:
default:
// don't warn about 3rd tex coord
if(lastDataElem != VERTEX_TEXTURECOORD_DE)
{
FWARNING (( "Unkown obj data elem: %s\n",
elem.c_str()));
}
is.ignore(INT_MAX, '\n');
break;
}
lastDataElem = dataElem;
}
}
#if 0
std::cerr << "------------------------------------------------" << std::endl;
i = 0;
for (meshI = meshList.begin(); meshI != meshList.end(); meshI++)
{
std::cerr << "Mesh " << i << " faceCount :"
<< meshI->faceList.size() << std::endl;
j = 0 ;
for ( faceI = meshI->faceList.begin(); faceI != meshI->faceList.end();
faceI++)
std::cerr << "MESH " << i << "face: " << j++ << "tie num: "
<< faceI->tieVec.size() << std::endl;
i++;
}
std::cerr << "------------------------------------------------" << std::endl;
#endif
// create Geometry objects
for (meshI = meshList.begin(); meshI != meshList.end(); meshI++)
{
geoPtr = Geometry::create();
posIndexPtr = NULL;
texIndexPtr = NULL;
normalIndexPtr = NULL;
lensPtr = GeoUInt32Property::create();
typePtr = GeoUInt8Property ::create();
// create and check mesh index mask
meshIndexMask = 0;
isSingleIndex = true;
if ( meshI->faceList.empty() == false)
{
for ( faceI = meshI->faceList.begin();
faceI != meshI->faceList.end(); faceI++)
{
indexMask = 0;
n = UInt32(faceI->tieVec.size());
for (i = 0; i < n; i++)
{
for (j = 0; j < 3; j++)
{
if ((index = (faceI->tieVec[i].index[j])) >= 0)
{
indexMask |= (1 << j);
if (j)
isSingleIndex &= (posIndex == index);
else
posIndex = index;
}
}
}
if (meshIndexMask == 0)
{
meshIndexMask = indexMask;
}
else if (meshIndexMask != indexMask)
{
// consider this real-world example:
// [...]
// f 1603//1747 1679//1744 1678//1743
// s 1
// f 9/1/10 5/2/9 1680/3/1748 1681/4/174
// [...]
// Some faces contain texture coords and others do not.
// The old version did just skip this geometry.
// This version should continue if there's at least
// the vertex index
// I've seen the change in the maskIndex only after a smooth group,
// so it's perhaps smarter to not ignore the smooth group further up in this code
if( !(indexMask & 1) )
{
// if there are vertex indices there's no reason to get in here
FFATAL (( "IndexMask unmatch, can not create geo\n"));
meshIndexMask = 0;
break;
}
else
{
// consider the minimum similarities of mesh masks
meshIndexMask &= indexMask;
}
}
}
}
else
{
FWARNING (("Mesh with empty faceList\n"));
}
// fill the geo properties
if (meshIndexMask)
{
geoPtr->setPositions ( coordPtr );
posIndexPtr = GeoUInt32Property::create();
if(!isSingleIndex)
geoPtr->setIndex(posIndexPtr, Geometry::PositionsIndex);
geoPtr->setLengths ( lensPtr );
geoPtr->setTypes ( typePtr );
if ( (meshIndexMask & 2) && texCoordPtr->size() > 0 )
{
geoPtr->setTexCoords ( texCoordPtr );
texIndexPtr = GeoUInt32Property::create();
if(!isSingleIndex)
geoPtr->setIndex(texIndexPtr, Geometry::TexCoordsIndex);
}
else
{
geoPtr->setTexCoords ( NULL );
}
if ( (meshIndexMask & 4) && normalPtr->size() > 0 )
{
geoPtr->setNormals ( normalPtr );
normalIndexPtr = GeoUInt32Property::create();
if(!isSingleIndex)
geoPtr->setIndex(normalIndexPtr, Geometry::NormalsIndex);
}
else
{
geoPtr->setNormals ( NULL );
}
if (meshI->mtlPtr == NULL)
{
meshI->mtlPtr = SimpleTexturedMaterial::create();
meshI->mtlPtr->setDiffuse( Color3f( .8f, .8f, .8f ) );
meshI->mtlPtr->setSpecular( Color3f( 1.f, 1.f, 1.f ) );
meshI->mtlPtr->setShininess( 20.f );
}
geoPtr->setMaterial ( meshI->mtlPtr );
for ( faceI = meshI->faceList.begin();
faceI != meshI->faceList.end(); faceI++)
{
n = UInt32(faceI->tieVec.size());
// add the lens entry
lensPtr->push_back(n);
// add the type entry
typePtr->push_back(GL_POLYGON);
// create the index values
for (i = 0; i < n; i++)
{
if (isSingleIndex)
{
posIndexPtr->push_back(faceI->tieVec[i].index[0]);
}
else
{
posIndexPtr->push_back(faceI->tieVec[i].index[0]);
if(texIndexPtr != NULL)
texIndexPtr->push_back(faceI->tieVec[i].index[1]);
if(normalIndexPtr != NULL)
normalIndexPtr->push_back(faceI->tieVec[i].index[2]);
}
}
}
if(isSingleIndex)
{
geoPtr->setIndex(posIndexPtr, Geometry::PositionsIndex);
geoPtr->setIndex(posIndexPtr, Geometry::NormalsIndex );
geoPtr->setIndex(posIndexPtr, Geometry::TexCoordsIndex);
}
// need to port the geometry functions ...
createSharedIndex( geoPtr );
// check if we have normals
// need to port the geometry functions ...
if(geoPtr->getNormals() == NULL)
calcVertexNormals(geoPtr);
// create and link the node
nodePtr = Node::create();
nodePtr->setCore( geoPtr );
if (meshList.size() > 1)
{
if (rootPtr == NULL)
{
rootPtr = Node::create();
GroupUnrecPtr tmpPtr = Group::create();
rootPtr->setCore ( tmpPtr );
rootPtr->addChild(nodePtr);
}
else
{
rootPtr->addChild(nodePtr);
}
}
else
{
rootPtr = nodePtr;
}
}
}
}
SceneFileHandler::the()->updateReadProgress(100);
commitChanges();
return NodeTransitPtr(rootPtr);
}
//----------------------------------------------------------------------
// Fills a geometry with a new text
// Author: afischle, pdaehne
//----------------------------------------------------------------------
void TextVectorFace::fillGeo(Geometry *geoPtr, const TextLayoutResult &layoutResult,
Real32 scale, Real32 depth, UInt32 level,
Real32 creaseAngle)
{
// cast the field containers down to the needed type and create them
// when they have the wrong type
GeoPnt3fPropertyUnrecPtr posPtr =
dynamic_cast<GeoPnt3fProperty *>(geoPtr->getPositions());
if (posPtr == NULL)
{
posPtr = GeoPnt3fProperty::create();
geoPtr->setPositions(posPtr);
}
else
posPtr->clear();
GeoVec3fPropertyUnrecPtr normalsPtr =
dynamic_cast<GeoVec3fProperty *>(geoPtr->getNormals());
if (normalsPtr == NULL)
{
normalsPtr = GeoVec3fProperty::create();
geoPtr->setNormals(normalsPtr);
}
else
normalsPtr->clear();
GeoVec2fPropertyUnrecPtr texPtr =
dynamic_cast<GeoVec2fProperty *>(geoPtr->getTexCoords());
if (texPtr == NULL)
{
texPtr = GeoVec2fProperty::create();
geoPtr->setTexCoords(texPtr);
}
else
texPtr->clear();
GeoUInt32PropertyUnrecPtr lensPtr =
dynamic_cast<GeoUInt32Property *>(geoPtr->getLengths());
if (lensPtr == NULL)
{
lensPtr = GeoUInt32Property::create();
geoPtr->setLengths(lensPtr);
}
else
lensPtr->clear();
GeoUInt32PropertyUnrecPtr posIndicesPtr =
dynamic_cast<GeoUInt32Property *>(
geoPtr->getIndex(Geometry::PositionsIndex));
if (posIndicesPtr == NULL)
{
posIndicesPtr = GeoUInt32Property::create();
geoPtr->setIndex(posIndicesPtr, Geometry::PositionsIndex);
}
else
posIndicesPtr->clear();
GeoUInt32PropertyUnrecPtr normalIndicesPtr =
dynamic_cast<GeoUInt32Property *>(
geoPtr->getIndex(Geometry::NormalsIndex));
if (normalIndicesPtr == NULL)
{
normalIndicesPtr = GeoUInt32Property::create();
geoPtr->setIndex(normalIndicesPtr, Geometry::NormalsIndex);
}
else
normalIndicesPtr->clear();
GeoUInt32PropertyUnrecPtr texCoordIndicesPtr =
dynamic_cast<GeoUInt32Property *>(
geoPtr->getIndex(Geometry::TexCoordsIndex));
if (texCoordIndicesPtr == NULL)
{
texCoordIndicesPtr = GeoUInt32Property::create();
geoPtr->setIndex(texCoordIndicesPtr, Geometry::TexCoordsIndex);
}
else
texCoordIndicesPtr->clear();
GeoUInt8PropertyUnrecPtr typesPtr =
dynamic_cast<GeoUInt8Property *>(geoPtr->getTypes());
if (typesPtr == NULL)
{
typesPtr = GeoUInt8Property::create();
geoPtr->setTypes(typesPtr);
}
else
typesPtr->clear();
geoPtr->setColors(NULL);
geoPtr->setSecondaryColors(NULL);
geoPtr->setTexCoords1(NULL);
geoPtr->setTexCoords2(NULL);
geoPtr->setTexCoords3(NULL);
UInt32 numGlyphs = layoutResult.getNumGlyphs();
if (numGlyphs == 0)
{
return;
}
// the interleaved multi-index blocks have the layout
// Position | Normal | TexCoord
/*
geoPtr->getIndexMapping().push_back(Geometry::MapPosition);
geoPtr->getIndexMapping().push_back(Geometry::MapNormal);
geoPtr->getIndexMapping().push_back(Geometry::MapTexCoords);
*/
// store the normal for the front face
normalsPtr->push_back(Vec3f(0.f, 0.f, 1.f));
if (depth > 0.f)
// store the normal for the back face
normalsPtr->push_back(Vec3f(0.f, 0.f, -1.f));
UInt32 i;
for (i = 0; i < numGlyphs; ++i)
{
const TextVectorGlyph &glyph = getVectorGlyph(layoutResult.indices[i]);
const TextVectorGlyph::PolygonOutline &outline = glyph.getLines(level);
const Vec2f &pos = layoutResult.positions[i];
// add the front face to the geometry
// store positions and texture coordinates
UInt32 coordOffset = posPtr->size();
UInt32 texCoordOffset = texPtr->size();
Real32 coordZ = 0.5f * depth;
vector<Vec2f>::const_iterator cIt;
for (cIt = outline.coords.begin(); cIt != outline.coords.end(); ++cIt)
{
Vec2f coord = *cIt + pos;
Vec2f texCoord = coord;
coord *= scale;
posPtr->push_back(Vec3f(coord.x(), coord.y(), coordZ));
texCoord -= layoutResult.positions.front();
texPtr->push_back(texCoord);
}
// Store types, lengths and indices
vector<TextVectorGlyph::PolygonOutline::TypeIndex>::const_iterator tIt;
UInt32 indexBegin = 0, indexEnd;
for (tIt = outline.types.begin(); tIt != outline.types.end(); ++tIt)
{
typesPtr->push_back(tIt->first);
indexEnd = tIt->second;
OSG_ASSERT(indexEnd >= indexBegin);
lensPtr->push_back(indexEnd - indexBegin);
UInt32 i;
for (i = indexBegin; i < indexEnd; ++i)
{
// the interleaved multi-index blocks have the layout
// Position | Normal | TexCoord
OSG_ASSERT(i < outline.indices.size());
UInt32 index = outline.indices[i];
OSG_ASSERT(coordOffset + index < posPtr->size());
posIndicesPtr->push_back(coordOffset + index);
normalIndicesPtr->push_back(0);
OSG_ASSERT(texCoordOffset + index < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + index);
}
indexBegin = indexEnd;
}
// add the back and side faces only if depth > 0
if (depth > 0.f)
{
// add the back face to the geometry
// store positions
// No need to store texture coordinates - we reuse the
// texture coordinates from the front side
UInt32 backCoordOffset = posPtr->size();
coordZ = -0.5f * depth;
for (cIt = outline.coords.begin(); cIt != outline.coords.end(); ++cIt)
{
Vec2f coord = *cIt + pos;
coord *= scale;
posPtr->push_back(Vec3f(coord.x(), coord.y(), coordZ));
}
// Store types, lengths and indices
// We have to flip all triangles to enable correct backface culling.
// For GL_TRIANGLES, we simply flip the vertices.
// For GL_TRIANGLE_FANs, we leave the first vertex at its place and flip the
// remaining vertices.
// For GL_TRIANGLE_STRIPs, things are more complicated. When the number of
// vertices is uneven, we simply flip the vertices. When the number of
// vertices is even, we have to add an additional vertex before we flip the
// vertices.
vector<TextVectorGlyph::PolygonOutline::TypeIndex>::const_iterator tIt;
UInt32 indexBegin = 0, indexEnd;
for (tIt = outline.types.begin(); tIt != outline.types.end(); ++tIt)
{
typesPtr->push_back(tIt->first);
indexEnd = tIt->second;
OSG_ASSERT(indexEnd >= indexBegin);
UInt32 len = indexEnd - indexBegin;
UInt32 i = indexEnd;
if (tIt->first == GL_TRIANGLE_FAN)
{
i = indexBegin;
++indexBegin;
}
if ((tIt->first == GL_TRIANGLE_STRIP) && ((len & 1) == 0))
{
OSG_ASSERT((indexEnd >= 2) && (indexEnd - 2 >= indexBegin));
i = indexEnd - 2;
++len;
}
if (i != indexEnd)
{
// the interleaved multi-index blocks have the layout
// Position | Normal | TexCoord
OSG_ASSERT(i < outline.indices.size());
UInt32 index = outline.indices[i];
OSG_ASSERT(backCoordOffset + index < posPtr->size());
posIndicesPtr->push_back(backCoordOffset + index);
normalIndicesPtr->push_back(1);
OSG_ASSERT(texCoordOffset + index < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + index);
i = indexEnd;
}
lensPtr->push_back(len);
while (true)
{
if (i <= indexBegin)
break;
--i;
// the interleaved multi-index blocks have the layout
// Position | Normal | TexCoord
OSG_ASSERT(i < outline.indices.size());
UInt32 index = outline.indices[i];
OSG_ASSERT(backCoordOffset + index < posPtr->size());
posIndicesPtr->push_back(backCoordOffset + index);
normalIndicesPtr->push_back(1);
OSG_ASSERT(texCoordOffset + index < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + index);
}
indexBegin = indexEnd;
}
// Add the side faces to the geometry
const TextVectorGlyph::Normals &normals = glyph.getNormals(level);
// construct the multi index
UInt32 start = 0, end, index = 0;
vector<UInt32>::const_iterator iIt;
vector<TextVectorGlyph::Orientation>::const_iterator oriIt = glyph.getContourOrientations().begin();
for (iIt = outline.contours.begin(); iIt != outline.contours.end(); ++iIt, ++oriIt)
{
OSG_ASSERT(oriIt != glyph.getContourOrientations().end());
UInt32 contourCoordOffset, contourBackCoordOffset;
if (*oriIt == TextVectorGlyph::CCW)
{
contourCoordOffset = coordOffset;
contourBackCoordOffset = backCoordOffset;
}
else
{
contourCoordOffset = backCoordOffset;
contourBackCoordOffset = coordOffset;
}
end = *iIt;
// the side faces are stored as quads
GLenum mode = GL_QUAD_STRIP;
UInt32 len = 0;
UInt32 coordIndex, backCoordIndex;
UInt32 normalOffset, startNormalOffset = normalsPtr->size();
for (index = start; index < end; ++index)
{
normalOffset = normalsPtr->size() - 1;
OSG_ASSERT(index < normals.size());
if (normals[index].edgeAngle > creaseAngle)
{
// We have an edge with two normals, so we need to
// add the vertices twice, but with different normals
// - but only when this is not the start index
if (index > start)
{
if ((mode == GL_QUAD_STRIP) && (len > 2))
{
typesPtr->push_back(GL_QUAD_STRIP);
OSG_ASSERT(((len + 2) & 1) == 0);
lensPtr->push_back(len + 2);
len = 0;
coordIndex = contourCoordOffset + index;
backCoordIndex = contourBackCoordOffset + index;
}
else
{
mode = GL_QUADS;
len += 2;
coordIndex = contourBackCoordOffset + index;
backCoordIndex = contourCoordOffset + index;
}
// back
OSG_ASSERT(backCoordIndex < posPtr->size());
posIndicesPtr->push_back(backCoordIndex);
OSG_ASSERT(normalOffset < normalsPtr->size());
normalIndicesPtr->push_back(normalOffset);
OSG_ASSERT(texCoordOffset + index < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + index);
// front
OSG_ASSERT(coordIndex < posPtr->size());
posIndicesPtr->push_back(coordIndex);
OSG_ASSERT(normalOffset < normalsPtr->size());
normalIndicesPtr->push_back(normalOffset);
OSG_ASSERT(texCoordOffset + index < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + index);
}
const Vec2f &normal = normals[index].nextEdgeNormal;
normalsPtr->push_back(Vec3f(normal.x(), normal.y(), 0.f));
}
else
{
if (mode == GL_QUADS)
{
typesPtr->push_back(GL_QUADS);
mode = GL_QUAD_STRIP;
OSG_ASSERT(len >= 6);
OSG_ASSERT(((len - 2) & 3) == 0);
lensPtr->push_back(len - 2);
len = 2;
}
const Vec2f &normal = normals[index].meanEdgeNormal;
normalsPtr->push_back(Vec3f(normal.x(), normal.y(), 0.f));
}
++normalOffset;
// back
OSG_ASSERT(contourBackCoordOffset + index < posPtr->size());
posIndicesPtr->push_back(contourBackCoordOffset + index);
OSG_ASSERT(normalOffset < normalsPtr->size());
normalIndicesPtr->push_back(normalOffset);
OSG_ASSERT(texCoordOffset + index < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + index);
// front
OSG_ASSERT(contourCoordOffset + index < posPtr->size());
posIndicesPtr->push_back(contourCoordOffset + index);
OSG_ASSERT(normalOffset < normalsPtr->size());
normalIndicesPtr->push_back(normalOffset);
OSG_ASSERT(texCoordOffset + index < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + index);
len += 2;
}
// We have to close the strip, so add the start vertices again
if (normals[start].edgeAngle <= creaseAngle)
normalOffset = startNormalOffset;
if (mode == GL_QUAD_STRIP)
{
coordIndex = contourCoordOffset + start;
backCoordIndex = contourBackCoordOffset + start;
}
else
{
coordIndex = contourBackCoordOffset + start;
backCoordIndex = contourCoordOffset + start;
}
// back
OSG_ASSERT(backCoordIndex < posPtr->size());
posIndicesPtr->push_back(backCoordIndex);
OSG_ASSERT(normalOffset < normalsPtr->size());
normalIndicesPtr->push_back(normalOffset);
OSG_ASSERT(texCoordOffset + start < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + start);
// front
OSG_ASSERT(coordIndex < posPtr->size());
posIndicesPtr->push_back(coordIndex);
OSG_ASSERT(normalOffset < normalsPtr->size());
normalIndicesPtr->push_back(normalOffset);
OSG_ASSERT(texCoordOffset + start < texPtr->size());
texCoordIndicesPtr->push_back(texCoordOffset + start);
len += 2;
// store the number of multi index blocks
typesPtr->push_back(mode);
OSG_ASSERT((mode != GL_QUADS) || ((len & 3) == 0));
OSG_ASSERT((mode != GL_QUAD_STRIP) || ((len & 1) == 0));
lensPtr->push_back(len);
start = end;
}
}
}
}
