/*
 *
 * OSG to VRML2 converter for OpenSceneGraph.
 *
 * authors :
 *           Johan Nouvel (johan_nouvel@yahoo.com) 
 *
 *
 */

#include "ConvertToVRML.h"
#include <iostream>
#include <string.h>
#include <limits>
#include <osg/Quat>
#include <osg/Geometry>
#include <osg/Material>
#include <osg/StateSet>
#include <osg/TexGen>
#include <osg/TexEnv>
#include <osg/BoundingSphere>
#include <osgDB/WriteFile>
#include <osgDB/ReadFile>
#include <osgDB/FileNameUtils>
#include <osgDB/FileUtils>

#include <osg/Image>

using namespace std;

/////////////////////////////////////////////////////////////////////////
//
// transformNode
//
/////////////////////////////////////////////////////////////////////////
osg::Node* transformNode(const osg::Node& root) {

  // create a zup to yup OSG Matrix
  osg::MatrixTransform* ret = new osg::MatrixTransform();
  osg::Matrix osgToVRMLMat(osg::Matrix(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0));

  ret->setDataVariance(osg::Object::STATIC);
  ret->setMatrix(osgToVRMLMat);

  if (strcmp(root.className(), "MatrixTransform") == 0) {
    const osg::MatrixTransform& aMat = static_cast<const osg::MatrixTransform&> (root);
    osg::MatrixTransform* node = new osg::MatrixTransform(aMat);
    ret->addChild(node);
  } else if (strcmp(root.className(), "Group") == 0) {
    const osg::Group& aGroup = static_cast<const osg::Group&> (root);
    osg::Group* node = new osg::Group(aGroup);
    ret->addChild(node);
  } else if (strcmp(root.className(), "PositionAttitudeTransform") == 0) {
    const osg::PositionAttitudeTransform& aPAT = static_cast<const osg::PositionAttitudeTransform&> (root);
    osg::PositionAttitudeTransform* node = new osg::PositionAttitudeTransform(aPAT);
    ret->addChild(node);
  } else if (strcmp(root.className(), "Geode") == 0) {
    const osg::Geode& aGeode = static_cast<const osg::Geode&> (root);
    osg::Geode* node = new osg::Geode(aGeode);
    ret->addChild(node);
  } else {
    osg::notify(osg::ALWAYS) << root.className() << " unsupported" << endl;
  }
  if (ret->getNumChildren() > 0) {
    return ret;
  }
  return (NULL);
}

/////////////////////////////////////////////////////////////////////////
//
// convertToVRML
//
/////////////////////////////////////////////////////////////////////////
osgDB::ReaderWriter::WriteResult convertToVRML(const osg::Node& root, const std::string& filename, const osgDB::ReaderWriter::Options* options) {

  ToVRML toVrml(filename, options);

  //cout << root.className() << endl;
  osg::Node* aRoot = transformNode(root);

  if (aRoot == NULL) {
    return (osgDB::ReaderWriter::WriteResult(osgDB::ReaderWriter::WriteResult::FILE_NOT_HANDLED));
  }
  aRoot->accept(toVrml);

  return (toVrml.result());
}

/////////////////////////////////////////////////////////////////////////
//
// ToVRML
//
/////////////////////////////////////////////////////////////////////////
ToVRML::ToVRML(const std::string& fileName, const osgDB::ReaderWriter::Options* options) :
  osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) {

  _fout.open(fileName.c_str(), ios::out);

  if (!_fout) {
    _res = osgDB::ReaderWriter::WriteResult::FILE_NOT_HANDLED;
    return;
  }
  _res = osgDB::ReaderWriter::WriteResult::FILE_SAVED;

  _pathToOutput = osgDB::getFilePath(fileName.c_str());
  if (_pathToOutput == "") {
    _pathToOutput = ".";
  }
  //std::cout<<" path -"<<_pathToOutput<<"-"<<std::endl;

  _fout.precision(6);
  _fout.setf(ios::fixed, ios::floatfield);

  _strIndent = (char*) malloc(33);
  for (int i = 0; i < 33; i++) {
    _strIndent[i] = ' ';
  }
  _indent = 0;
  _strIndent[0] = '\0';

  //initialize
  _fout << "#VRML V2.0 utf8\n\n";

  _textureMode = CONVERT_TEXTURE;
  _txtUnit = 0;

  //_convertTextures = true;
  _pathRelativeToOutput = ".";
  if (options != NULL) {
    std::string opt = options->getOptionString();
    if (opt.find("convertTextures=0") != std::string::npos) {
      //std::cout << "Read XML stream" << std::endl;
      _textureMode = COPY_TEXTURE;

    } else if (opt.find("convertTextures=-1") != std::string::npos) {
      _textureMode = KEEP_ORIGINAL_TEXTURE;

    } else if (opt.find("convertTextures=-2") != std::string::npos) {
      _textureMode = NO_TEXTURE;

    } else if (opt.find("convertTextures=-3") != std::string::npos) {
      _textureMode = CONVERT_TEXTURE;
    }

    if (opt.find("directoryTextures=") != std::string::npos) {
      std::string dirOpt = opt;
      dirOpt.erase(0, dirOpt.find("directoryTextures=") + 18);
      _pathRelativeToOutput = dirOpt.substr(0, dirOpt.find(' '));
    }

    if (opt.find("textureUnit=") != std::string::npos) {
      std::string dirOpt = opt;
      dirOpt.erase(0, dirOpt.find("textureUnit=") + 12);
      _txtUnit = atoi(dirOpt.substr(0, dirOpt.find(' ')).c_str());
    }
  }

  if (_textureMode != NO_TEXTURE) {
    _defaultImage = new osg::Image();
    _defaultImage->setFileName(_pathToOutput + "/" + _pathRelativeToOutput + "/default_texture.png");
    int s = 1;
    int t = 1;
    unsigned char *data = new unsigned char[s * t * 3];
    data[0] = 255;
    data[1] = 255;
    data[2] = 255;
    _defaultImage->setImage(s, t, 0, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, data, osg::Image::USE_NEW_DELETE);
    osgDB::writeImageFile(*(_defaultImage.get()), _defaultImage->getFileName());
  }
}

/////////////////////////////////////////////////////////////////////////
//
// ~ToVRML
//
/////////////////////////////////////////////////////////////////////////
ToVRML::~ToVRML() {
  if (_fout) {
    _fout.close();
  }
  free( _strIndent);

}

/////////////////////////////////////////////////////////////////////////
//
// indent
//
/////////////////////////////////////////////////////////////////////////
char* ToVRML::indent() {
  return (_strIndent);
}

/////////////////////////////////////////////////////////////////////////
//
// indentM
//
/////////////////////////////////////////////////////////////////////////
char* ToVRML::indentM() {
  _strIndent[_indent] = ' ';
  _indent += 2;

  if (_indent > 32) {
    _indent = 32;
  }
  _strIndent[_indent] = '\0';

  return (_strIndent);
}

/////////////////////////////////////////////////////////////////////////
//
// indentL
//
/////////////////////////////////////////////////////////////////////////
char* ToVRML::indentL() {
  _strIndent[_indent] = ' ';
  _indent -= 2;

  if (_indent < 0) {
    _indent = 0;
  }
  _strIndent[_indent] = '\0';

  return (_strIndent);
}

/////////////////////////////////////////////////////////////////////////
//
// apply(osg::Geode)
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::Geode& node) {
  //cout << "Geode" << endl;

  pushStateSetStack(node.getStateSet());

  for (unsigned int i = 0; i < node.getNumDrawables(); i++) {
    apply(node.getDrawable(i));
  }
  popStateSetStack();
}

/////////////////////////////////////////////////////////////////////////
//
// apply
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::Drawable* drawable) {
  // get the drawable type
  //cout<<"ICI "<<drawable->className()<<endl;
  pushStateSetStack(drawable->getStateSet());

  if (strcmp(drawable->className(), "Geometry") == 0) {
    apply(drawable->asGeometry());
  } else {
    osg::notify(osg::ALWAYS) << "Drawable " << drawable->className() << " unsupported" << endl;
  }

  popStateSetStack();
}

/////////////////////////////////////////////////////////////////////////
//
// apply
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::Geometry* geom) {

  // are all primitives faces or line ?
  GLenum mode;
  osg::PrimitiveSet::Type type;

  _fout << indent() << "Shape {\n";
  indentM();
  writeAppearance( getCurrentStateSet());
  indentL();

  int modePoints = 0;
  int modeLines = 0;
  int modeFaces = 0;

  for (unsigned int p = 0; p < geom->getNumPrimitiveSets(); p++) {
    mode = geom->getPrimitiveSet(p)->getMode();
    if (mode == osg::PrimitiveSet::POINTS) {
      modePoints++;

    } else if ((mode == osg::PrimitiveSet::LINES) || (mode == osg::PrimitiveSet::LINE_STRIP) || (mode == osg::PrimitiveSet::LINE_LOOP)) {
      modeLines++;

    } else if ((mode == osg::PrimitiveSet::TRIANGLES) || (mode == osg::PrimitiveSet::TRIANGLE_STRIP) || (mode == osg::PrimitiveSet::TRIANGLE_FAN) || (mode
    == osg::PrimitiveSet::QUADS) || (mode == osg::PrimitiveSet::QUAD_STRIP) || (mode == osg::PrimitiveSet::POLYGON)) {
      modeFaces++;
    }
  }

  //std::cout << "primitives type : Points " << modePoints << " Line " << modeLines << " Face " << modeFaces << std::endl;

  if (modePoints > 0) {
    _fout << indentM() << "geometry PointSet {\n";
    for (unsigned int p = 0; p < geom->getNumPrimitiveSets(); p++) {
      mode = geom->getPrimitiveSet(p)->getMode();
      type = geom->getPrimitiveSet(p)->getType();
      if (mode == osg::PrimitiveSet::POINTS) {
        osg::notify(osg::WARN) << " osg::PrimitiveSetMode = POINTS not supported by VRML Writer" << std::endl;
      }
    }
  }

  if (modeLines > 0) {
    _fout << indentM() << "geometry IndexedLineSet {\n";
    for (unsigned int p = 0; p < geom->getNumPrimitiveSets(); p++) {
      mode = geom->getPrimitiveSet(p)->getMode();
      type = geom->getPrimitiveSet(p)->getType();
      if ((mode == osg::PrimitiveSet::LINES) || (mode == osg::PrimitiveSet::LINE_STRIP) || (mode == osg::PrimitiveSet::LINE_LOOP)) {
        osg::notify(osg::WARN) << " osg::PrimitiveSetMode = LINES, LINE_STRIP or LINE_LOOP not supported by VRML Writer" << std::endl;
      }
    }
  }

  if (modeFaces > 0) {
    _fout << indentM() << "geometry IndexedFaceSet {\n";
    _fout << indentM() << "solid FALSE\n";
    indentL();
    _fout << indentM() << "coordIndex [\n";
    indentM();

    std::vector<int> primitiveSetFaces;
    int primitiveFaces = 0;

    for (unsigned int p = 0; p < geom->getNumPrimitiveSets(); p++) {
      mode = geom->getPrimitiveSet(p)->getMode();
      type = geom->getPrimitiveSet(p)->getType();
      if ((mode == osg::PrimitiveSet::TRIANGLES) || (mode == osg::PrimitiveSet::TRIANGLE_STRIP) || (mode == osg::PrimitiveSet::TRIANGLE_FAN) || (mode == osg::PrimitiveSet::QUADS)
      || (mode == osg::PrimitiveSet::QUAD_STRIP) || (mode == osg::PrimitiveSet::POLYGON)) {
        if (type == osg::PrimitiveSet::PrimitiveType) {
          osg::notify(osg::WARN) << "osg::PrimitiveSet::PrimitiveType not supported by VRML Writer" << std::endl;

        } else if (type == osg::PrimitiveSet::DrawArraysPrimitiveType) {
          //std::cout << "osg::PrimitiveSet::DrawArraysPrimitiveType" << std::endl;
          osg::ref_ptr < osg::DrawArrays > dra = dynamic_cast<osg::DrawArrays*> (geom->getPrimitiveSet(p));

          unsigned int* indices = new unsigned int[dra->getCount()];
          for (int j = 0; j < dra->getCount(); j++) {
            indices[j] = dra->getFirst() + j;
          }
          writeCoordIndex(mode, indices, dra->getCount(), primitiveSetFaces, primitiveFaces);
          delete[] indices;

        } else if (type == osg::PrimitiveSet::DrawArrayLengthsPrimitiveType) {
          //osg::notify(osg::WARN) << " osg::PrimitiveSet::DrawArrayLengthsPrimitiveType not supported by VRML Writer" << std::endl;
          osg::ref_ptr < osg::DrawArrayLengths > dal = dynamic_cast<osg::DrawArrayLengths*> (geom->getPrimitiveSet(p));

          //std::cout<<dal->getFirst()<<" "<<dal->getNumPrimitives()<<" "<<   dal->getNumIndices ()<<" "<< dal->getNumInstances()<<std::endl;
          int first = 0;
          for (unsigned int prim = dal->getFirst(); prim < dal->getNumPrimitives(); prim++) {
            //std::cout<<(*dal)[prim]<<std::endl;
            unsigned int numIndices = (*dal)[prim];
            unsigned int * indices = new unsigned int[numIndices];
            for (unsigned int i = 0; i < numIndices; i++) {
              indices[i] = first + i;
            }

            first += (*dal)[prim];
            // write coorIndex as if wa have an indexed geometry
            writeCoordIndex(mode, indices, numIndices, primitiveSetFaces, primitiveFaces);
            delete[] indices;
          }

        } else if (type == osg::PrimitiveSet::DrawElementsUBytePrimitiveType) {
          //std::cout << "osg::PrimitiveSet::DrawElementsUBytePrimitiveType" << std::endl;

          osg::ref_ptr < osg::DrawElementsUByte > drui = dynamic_cast<osg::DrawElementsUByte*> (geom->getPrimitiveSet(p));
          const unsigned char * indices = (const unsigned char*) (drui->getDataPointer());
          writeCoordIndex(mode, indices, drui->getNumIndices(), primitiveSetFaces, primitiveFaces);

        } else if (type == osg::PrimitiveSet::DrawElementsUShortPrimitiveType) {
          //std::cout << "osg::PrimitiveSet::DrawElementsUShortPrimitiveType" << std::endl;

          osg::ref_ptr < osg::DrawElementsUShort > drui = dynamic_cast<osg::DrawElementsUShort*> (geom->getPrimitiveSet(p));
          const unsigned short * indices = (const unsigned short*) (drui->getDataPointer());
          writeCoordIndex(mode, indices, drui->getNumIndices(), primitiveSetFaces, primitiveFaces);

        } else if (type == osg::PrimitiveSet::DrawElementsUIntPrimitiveType) {
          //std::cout << "osg::PrimitiveSet::DrawElementsUIntPrimitiveType" << std::endl;

          osg::ref_ptr < osg::DrawElementsUInt > drui = dynamic_cast<osg::DrawElementsUInt*> (geom->getPrimitiveSet(p));
          const unsigned int * indices = (const unsigned int*) (drui->getDataPointer());
          writeCoordIndex(mode, indices, drui->getNumIndices(), primitiveSetFaces, primitiveFaces);
        }

      }

    }
    _fout << indentL() << "]\n";
    indentL();

    //write vertex
    writeCoord((osg::Vec3Array*) (geom->getVertexArray()));
    //write texture coordinate
    if (_textureMode != NO_TEXTURE) {
      writeTexCoord((osg::Vec2Array*) (geom->getTexCoordArray(_txtUnit)), (osg::Vec3Array*) (geom->getVertexArray()));
    }
    //write normals
    writeNormal(geom, primitiveSetFaces, primitiveFaces);
    //write colors
    writeColor(geom, primitiveSetFaces, primitiveFaces);
  }

  _fout << indent() << "}\n";
  _fout << indentL() << "}\n";

}

/////////////////////////////////////////////////////////////////////////
//
// writeAppearance
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::writeAppearance(osg::StateSet* stateset) {

  if (stateset == NULL) {
    return;
  }

  osg::ref_ptr < osg::StateSet > ss = stateset;

  _fout << indent() << "appearance Appearance {\n";
  osg::Material* mat = (osg::Material*) (ss->getAttribute(osg::StateAttribute::MATERIAL));
  osg::Texture2D* tex;
  if (_textureMode == NO_TEXTURE) {
    tex = NULL;
  } else {
    tex = (osg::Texture2D*) (ss->getTextureAttribute(_txtUnit, osg::StateAttribute::TEXTURE));
  }

  if (mat) {

    bool alreadyLoaded;
    std::string name;
    osg::Vec4 ambient, diffuse, specular, emission;
    float shininess;

    ambient = mat->getAmbient(osg::Material::FRONT);
    diffuse = mat->getDiffuse(osg::Material::FRONT);
    specular = mat->getSpecular(osg::Material::FRONT);
    shininess = mat->getShininess(osg::Material::FRONT);
    emission = mat->getEmission(osg::Material::FRONT);

    float transp = 1 - (ambient[3] + diffuse[3] + specular[3] + emission[3]) / 4.0;
    if (transp < 0)
      transp = 0;

    //if (transp == 0 && tex) {
    //  if (tex->getImage()->isImageTranslucent()) {
    //    transp = 0.01;
    //    mat->setTransparency(osg::Material::FRONT,transp);
    //  }
    //}

    findMaterialName(mat, name, alreadyLoaded);
    if (alreadyLoaded) {
      _fout << indentM() << "material USE " << name << "\n";
      indentL();
    } else {

      _fout << indentM() << "material DEF " << name << " Material {\n";
      //_fout << indentM() << "material Material {\n";
      _fout << indentM() << "diffuseColor " << diffuse[0] << " " << diffuse[1] << " " << diffuse[2] << "\n";
      _fout << indent() << "emissiveColor " << emission[0] << " " << emission[1] << " " << emission[2] << "\n";

      _fout << indent() << "specularColor " << specular[0] << " " << specular[1] << " " << specular[2] << "\n";
      _fout << indent() << "shininess " << shininess << "\n";
      float ambientI = (ambient[0] + ambient[1] + ambient[2]) / 3.0;
      if (ambientI > 1)
        ambientI = 1;
      _fout << indent() << "ambientIntensity " << ambientI << "\n";

      _fout << indent() << "transparency " << transp << "\n";
      _fout << indentL() << "}\n";
      indentL();
    }
  }

  if (tex) {
    bool alreadyLoaded;
    std::string name;
    findTextureName(tex, name, alreadyLoaded);
    if (alreadyLoaded) {
      _fout << indentM() << "texture USE " << name << "\n";
      indentL();
    } else {
      _fout << indentM() << "texture DEF " << name << " ImageTexture {\n";
      std::string texName = tex->getImage()->getFileName();
      if (_textureMode == COPY_TEXTURE || _textureMode == CONVERT_TEXTURE) {
        texName = _pathRelativeToOutput + "/" + osgDB::getSimpleFileName(texName);

      } else if (_textureMode == KEEP_ORIGINAL_TEXTURE) {
        texName = _pathRelativeToOutput + "/" + texName;
      }
      _fout << indentM() << "url [ \"" << texName << "\" ]\n";
      //std::cout<<"WRAP "<<tex->getWrap(osg::Texture::WRAP_S)<<std::endl;
      if (tex->getWrap(osg::Texture::WRAP_S) == osg::Texture::REPEAT) {
        _fout << indent() << "repeatS TRUE\n";
      } else {
        _fout << indent() << "repeatS FALSE\n";
      }
      if (tex->getWrap(osg::Texture::WRAP_T) == osg::Texture::REPEAT) {
        _fout << indent() << "repeatT TRUE\n";
      } else {
        _fout << indent() << "repeatT FALSE\n";
      }
      _fout << indentL() << "}\n";
      indentL();
    }
  }

  _fout << indent() << "}\n";

}

/////////////////////////////////////////////////////////////////////////
//
// apply(osg::Group)
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::Group& node) {
  //cout << "Group" << endl;
  _fout << indent() << "Group {\n";
  _fout << indentM() << "children [\n";

  pushStateSetStack(node.getStateSet());

  indentM();
  traverse(node);
  indentL();

  popStateSetStack();

  _fout << indent() << "]\n";
  _fout << indentL() << "}\n";
}

/////////////////////////////////////////////////////////////////////////
//
// apply(osg::MatrixTransform)
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::MatrixTransform& node) {
  //cout << "MatrixTransform" << endl;
  osg::Matrixf mat = node.getMatrix();
  //   for(int i=0;i<16;i++){
  //     cout <<mat.ptr()[i]<<" ";
  //   }
  //   cout<<endl;


  osg::Vec3 trans = mat.getTrans();
  osg::Vec3 scale = mat.getScale();
  osg::Quat quat;
  mat.get(quat);
  double angle;
  osg::Vec3 axe;
  quat.getRotate(angle, axe);

  _fout << indent() << "Transform {\n";
  _fout << indentM() << "scale " << scale[0] << " " << scale[1] << " " << scale[2] << "\n";
  //_fout << indentM() << "scale 1 1 1\n";
  _fout << indent() << "translation " << trans[0] << " " << trans[1] << " " << trans[2] << "\n";
  _fout << indent() << "rotation " << axe[0] << " " << axe[1] << " " << axe[2] << " " << angle << "\n";
  _fout << indent() << "children [\n";

  pushStateSetStack(node.getStateSet());

  indentM();
  traverse(node);
  indentL();

  popStateSetStack();

  _fout << indent() << "]\n";

  _fout << indentL() << "}\n";

}

/////////////////////////////////////////////////////////////////////////
//
// apply(osg::PositionAttitudeTransform)
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::PositionAttitudeTransform& node) {

  osg::Vec3 trans = node.getPosition();
  osg::Vec3 scale = node.getScale();
  osg::Quat quat = node.getAttitude();
  double angle;
  osg::Vec3 axe;
  quat.getRotate(angle, axe);

  _fout << indent() << "Transform {\n";
  _fout << indentM() << "scale " << scale[0] << " " << scale[1] << " " << scale[2] << "\n";
  //_fout << indentM() << "scale 1 1 1\n";
  _fout << indent() << "translation " << trans[0] << " " << trans[1] << " " << trans[2] << "\n";
  _fout << indent() << "rotation " << axe[0] << " " << axe[1] << " " << axe[2] << " " << angle << "\n";
  _fout << indent() << "children [\n";

  pushStateSetStack(node.getStateSet());

  indentM();
  traverse(node);
  indentL();

  popStateSetStack();

  _fout << indent() << "]\n";

  _fout << indentL() << "}\n";

}

////////////////////////////////////////////////////////////////////////
//
// apply(osg::Billboard)
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::Billboard& node) {
  osg::notify(osg::ALWAYS) << "WARNING : Billboard is changed to Group" << endl;
  _fout << indent() << "Group {\n";
  indentM();

  //osg::Billboard::Mode mode = node.getMode();
  //const osg::Vec3 axe = node.getAxis();
  //const osg::Vec3 normal = node.getNormal();

  //if (mode == osg::Billboard::AXIAL_ROT) {
  //  _fout << indent() << "axisOfRotation " << axe[0] << " " << axe[1] << " " << axe[2] << "\n";
  //}
  //osg::BoundingSphere sph=node.getBound();
  //_fout << indent() << "bboxCenter "<<sph.center()[0]<<" "<<sph.center()[1]<<" "<<sph.center()[2]<<"\n";
  //_fout << indent() << "bboxSize "<<sph.radius()<<" "<<sph.radius()<<" "<<sph.radius()<<"\n";

  _fout << indent() << "children [\n";

  pushStateSetStack(node.getStateSet());

  indentM();
  for (unsigned int i = 0; i < node.getNumDrawables(); i++) {
    osg::Vec3 trans = node.getPosition(i);
    _fout << indent() << "Transform {\n";
    _fout << indentM() << "translation " << trans[0] << " " << trans[1] << " " << trans[2] << "\n";
    _fout << indent() << "children [\n";
    indentM();
    apply(node.getDrawable(i));
    _fout << indentL() << "]\n";
    _fout << indentL() << "}\n";
  }

  popStateSetStack();

  _fout << indentL() << "]\n";
  _fout << indentL() << "}\n";
}

////////////////////////////////////////////////////////////////////////
//
// apply(osg::LOD)
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::LOD& node) {
  //std::cout << "LOD" << endl;
  _fout << indent() << "LOD {\n";

  bool fakeFirst = false;
  bool fakeLast = false;
  if (node.getMinRange(0) > 0) {
    fakeFirst = true;
  }
  if (node.getMaxRange(node.getNumRanges() - 1) < std::numeric_limits<float>::max()) {
    fakeLast = true;
  }

  _fout << indentM() << "level [\n";
  if (fakeFirst) {
    _fout << indentM() << "Shape {\n";
    _fout << indent() << "}\n";
    indentL();
  }
  pushStateSetStack(node.getStateSet());
  indentM();
  traverse(node);
  indentL();
  popStateSetStack();

  if (fakeLast) {
    _fout << indentM() << "Shape {\n";
    _fout << indent() << "}\n";
    indentL();
  }

  _fout << indent() << "]\n";

  osg::Vec3 center;
  if (node.getCenterMode() == osg::LOD::USER_DEFINED_CENTER) {
    center = node.getCenter();
  } else {
    center = node.getBound().center();
  }
  _fout << indent() << "center " << center[0] << " " << center[1] << " " << center[2] << "\n";

  _fout << indentM() << "range [";
  if (fakeFirst) {
    _fout << indentM() << node.getMinRange(0) << ",";
  }
  for (unsigned int i = 0; i < node.getNumRanges(); i++) {

    _fout << indentM() << node.getMaxRange(i);
    if (i < node.getNumRanges() - 1) {
      _fout << ",";
    }
  }
  _fout << "]\n";

  _fout << indentL() << "}\n";
}

/////////////////////////////////////////////////////////////////////////
//
// apply(osg::Node)
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::apply(osg::Node& node) {
  osg::notify(osg::ALWAYS) << node.className() << " not supported" << endl;
  pushStateSetStack(node.getStateSet());
  traverse(node);
  popStateSetStack();
}

/////////////////////////////////////////////////////////////////////////
//
// pushStateSetStack
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::pushStateSetStack(osg::StateSet* ss) {
  _stack.push_back(osg::ref_ptr<osg::StateSet>(ss));
}

/////////////////////////////////////////////////////////////////////////
//
// popStateSetStack
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::popStateSetStack() {
  if (!_stack.empty()) {
    _stack.pop_back();
  }
}

/////////////////////////////////////////////////////////////////////////
//
// getCurrentStateSet
//
/////////////////////////////////////////////////////////////////////////
osg::StateSet* ToVRML::getCurrentStateSet() {
  // return current StateSet by flatten StateSet stack.
  // until flatten is done, just return top StateSet
  if (!_stack.empty()) {
    osg::StateSet* ssFinal = new osg::StateSet();
    ssFinal->setGlobalDefaults();
    //std::cout << "StateSet Stack Size " << _stack.size() << std::endl;
    for (unsigned int i = 0; i < _stack.size(); i++) {
      osg::StateSet* ssCur = _stack[i].get();
      if (ssCur != NULL) {
        ssFinal->merge(*ssCur);
      }
    }
    return (ssFinal);
  } else
    return (NULL);
}

/////////////////////////////////////////////////////////////////////////
//
// findMaterialName
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::findMaterialName(osg::Material* mat, std::string& name, bool& alreadyLoaded) {

  osg::Vec4 ambient, diffuse, specular, emission;
  //float shininess;
  std::map<osg::ref_ptr<osg::Material>, std::string>::iterator it;// = _matMap.find(obj);

  for (it = _matMap.begin(); it != _matMap.end(); it++) {
    osg::ref_ptr < osg::Material > matLoaded = it->first;
    ambient = mat->getAmbient(osg::Material::FRONT);
    //diffuse = mat->getDiffuse(osg::Material::FRONT);
    //specular = mat->getSpecular(osg::Material::FRONT);
    //shininess = mat->getShininess(osg::Material::FRONT);
    //emission = mat->getEmission(osg::Material::FRONT);
    //std::cout << "MATERIAL " << ambient[3] << " " << matLoaded->getAmbient(osg::Material::FRONT)[3] << std::endl;

    if ((matLoaded->getAmbient(osg::Material::FRONT) == mat->getAmbient(osg::Material::FRONT)) && (matLoaded->getDiffuse(osg::Material::FRONT)
    == mat->getDiffuse(osg::Material::FRONT)) && (matLoaded->getSpecular(osg::Material::FRONT) == mat->getSpecular(osg::Material::FRONT))
    && (matLoaded->getShininess(osg::Material::FRONT) == mat->getShininess(osg::Material::FRONT)) && (matLoaded->getEmission(osg::Material::FRONT)
    == mat->getEmission(osg::Material::FRONT))) {

      name = it->second;
      alreadyLoaded = true;
      return;
    }
  }
  std::stringstream ss;
  ss << "material_" << _matMap.size();
  name = ss.str();
  _matMap[mat] = name;
  alreadyLoaded = false;

}

/////////////////////////////////////////////////////////////////////////
//
// findTextureName
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::findTextureName(osg::Texture2D* tex, std::string& name, bool& alreadyLoaded) {

  //std::cout << "ORI -" << tex->getImage() << "- " << std::endl;
  if (tex->getImage() == NULL) {
    tex->setImage(_defaultImage.get());
  }

  std::string nameOri = osgDB::convertFileNameToNativeStyle(tex->getImage()->getFileName());
  std::string nameInput = osgDB::findDataFile(nameOri, NULL);
  if (nameInput == "") {
    osg::notify(osg::ALWAYS) << "WARNING: couldn't find texture named: -" << nameOri << "- use default one instead -" << _defaultImage->getFileName() << "-" << std::endl;
    tex->setImage(_defaultImage.get());
    nameOri = osgDB::convertFileNameToNativeStyle(tex->getImage()->getFileName());
    nameInput = osgDB::findDataFile(nameOri, NULL);
  }

  std::string nameOutput;
  std::string::size_type pos = nameInput.find_last_of(".");
  std::string ext = nameInput.substr(pos, nameInput.length() - pos);

  osg::ref_ptr < osg::Image > imgIn = osgDB::readImageFile(nameInput);
  if (!imgIn.valid()) {
    osg::notify(osg::ALWAYS) << "WARNING: couldn't read texture named: -" << nameOri << "- use default one instead -" << _defaultImage->getFileName() << "-" << std::endl;
    tex->setImage(_defaultImage.get());
    nameOri = osgDB::convertFileNameToNativeStyle(tex->getImage()->getFileName());
    nameInput = osgDB::findDataFile(nameOri, NULL);
    pos = nameInput.find_last_of(".");
    nameInput.substr(pos, nameInput.length() - pos);
    imgIn = _defaultImage.get();
  }

  //int nbBand = poSrcDS->GetRasterCount();
  if (_textureMode == KEEP_ORIGINAL_TEXTURE) {
    nameOutput = nameInput;

  } else if (_textureMode == COPY_TEXTURE) {
    nameOutput = _pathToOutput + "/" + _pathRelativeToOutput + "/" + osgDB::getSimpleFileName(nameInput);

  } else if (_textureMode == CONVERT_TEXTURE) {
    nameOutput = _pathToOutput + "/" + _pathRelativeToOutput + "/" + osgDB::getSimpleFileName(nameInput);
    if (ext != ".png" && ext != ".jpg") {
      if (imgIn->isImageTranslucent()) {//(nbBand != 1 && nbBand != 3) {
        nameOutput = _pathToOutput + "/" + _pathRelativeToOutput + "/" + osgDB::getSimpleFileName(nameInput.substr(0, pos) + ".png");
      } else {
        nameOutput = _pathToOutput + "/" + _pathRelativeToOutput + "/" + osgDB::getSimpleFileName(nameInput.substr(0, pos) + ".jpg");
      }
    }
  }

  std::map<osg::ref_ptr<osg::Texture2D>, std::string>::iterator it;
  for (it = _texMap.begin(); it != _texMap.end(); it++) {
    osg::ref_ptr < osg::Texture2D > texLoaded = it->first;

    if ((nameOutput == texLoaded->getImage()->getFileName()) && (tex->getWrap(osg::Texture::WRAP_S) == texLoaded->getWrap(osg::Texture::WRAP_S))
    && (tex->getWrap(osg::Texture::WRAP_T) == texLoaded->getWrap(osg::Texture::WRAP_T))) {
      name = it->second;
      alreadyLoaded = true;
      return;
    }
  }

  // first time we see these texture
  // add it to textureMap
  std::stringstream ss;
  ss << "texture2D_" << _texMap.size();
  name = ss.str();
  _texMap[tex] = name;
  alreadyLoaded = false;

  tex->getImage()->setFileName(nameOutput);

  if (nameInput == nameOutput) {
    return;
  }
  // else write image file

  if (_textureMode == CONVERT_TEXTURE) {
    // convert format (from dds to rgb or rgba, or from rgba to rgb)
    std::string newName;
    GLenum type = GL_UNSIGNED_BYTE;
    GLenum pixelFormat;
    GLint internalFormat;
    int nbC;
    if (imgIn->isImageTranslucent()) {
      // convert to png if transparency
      pixelFormat = GL_RGBA;
      internalFormat = GL_RGBA;
      nbC = 4;
    } else {
      // convert to jpeg if no transparency
      pixelFormat = GL_RGB;
      internalFormat = GL_RGB;
      nbC = 3;
    }
    osg::ref_ptr < osg::Image > curImg = tex->getImage();
    osg::ref_ptr < osg::Image > mmImg = new osg::Image();
    unsigned char* data = new unsigned char[curImg->s() * curImg->t() * nbC];
    for (int j = 0; j < curImg->t(); j++) {
      for (int i = 0; i < curImg->s(); i++) {
        osg::Vec4 c = curImg->getColor(i, j);
        data[(i + j * curImg->s()) * nbC] = c[0] * 255;
        data[(i + j * curImg->s()) * nbC + 1] = c[1] * 255;
        data[(i + j * curImg->s()) * nbC + 2] = c[2] * 255;
        if (nbC == 4) {
          data[(i + j * curImg->s()) * nbC + 3] = c[3] * 255;
        }
      }
    }
    mmImg->setImage(curImg->s(), curImg->t(), 1, internalFormat, pixelFormat, type, data, osg::Image::USE_NEW_DELETE, 1);
    osgDB::writeImageFile(*(mmImg.get()), nameOutput);

  } else {
    // no conversion needed, input and output have the same format, but path to image has changed
    osgDB::writeImageFile(*(tex->getImage()), nameOutput);
  }

}

/////////////////////////////////////////////////////////////////////////
//
// writeCoordIndex
//
/////////////////////////////////////////////////////////////////////////
template<typename T> void ToVRML::writeCoordIndex(GLenum mode, T* indices, unsigned int number, std::vector<int>& primitiveSetFaces, int& primitiveFaces) {

  int currentFaces = 0;
  if (mode == osg::PrimitiveSet::TRIANGLES) {
    //std::cout << "TRIANGLES" << std::endl;
    for (unsigned int j = 0; j < number; j += 3) {
      _fout << indent() << indices[j] << "," << indices[j + 1] << "," << indices[j + 2] << ",-1,\n";
      currentFaces++;
    }
    primitiveSetFaces.push_back(currentFaces);
    primitiveFaces += currentFaces;

  } else if (mode == osg::PrimitiveSet::TRIANGLE_FAN) {
    //std::cout << "TRIANGLE FAN" << std::endl;
    int firstPoint = indices[0];
    int secondPoint = indices[1];
    for (unsigned int j = 2; j < number; j++) {
      _fout << indent() << firstPoint << "," << secondPoint << "," << indices[j] << ",-1,\n";
      secondPoint = indices[j];
      currentFaces++;
    }
    primitiveSetFaces.push_back(currentFaces);
    primitiveFaces += currentFaces;

  } else if (mode == osg::PrimitiveSet::TRIANGLE_STRIP) {
    //std::cout << "TRIANGLE STRIP" << std::endl;
    int firstPoint = indices[0];
    int secondPoint = indices[1];
    bool changeSecond = false;
    for (unsigned int j = 2; j < number; j++) {
      _fout << indent() << firstPoint << "," << secondPoint << "," << indices[j] << ",-1,\n";
      if (!changeSecond) {
        firstPoint = indices[j];
        changeSecond = true;
      } else {
        secondPoint = indices[j];
        changeSecond = false;
      }
      currentFaces++;
    }
    primitiveSetFaces.push_back(currentFaces);
    primitiveFaces += currentFaces;

  } else if (mode == osg::PrimitiveSet::QUADS) {
    //std::cout << "QUADS" << std::endl;
    for (unsigned int j = 0; j < number; j += 4) {
      _fout << indent() << indices[j] << "," << indices[j + 1] << "," << indices[j + 2] << "," << indices[j + 3] << ",-1,\n";
      currentFaces++;
    }
    primitiveSetFaces.push_back(currentFaces);
    primitiveFaces += currentFaces;

  } else if (mode == osg::PrimitiveSet::QUAD_STRIP) {
    //std::cout << "QUADS STRIP" << std::endl;
    int firstPoint = indices[0];
    int secondPoint = indices[1];
    for (unsigned int j = 2; j < number; j += 2) {
      _fout << indent() << firstPoint << "," << secondPoint << "," << indices[j + 1] << " " << indices[j] << ",-1,\n";
      firstPoint = indices[j];
      secondPoint = indices[j + 1];
      currentFaces++;
    }
    primitiveSetFaces.push_back(currentFaces);
    primitiveFaces += currentFaces;

  } else if (mode == osg::PrimitiveSet::POLYGON) {
    //std::cout << "POLYGON" << std::endl;
    _fout << indent();
    for (unsigned int j = 0; j < number; j++) {
      _fout << indices[j] << ",";
    }
    currentFaces++;
    _fout << "-1,\n";
    primitiveSetFaces.push_back(currentFaces);
    primitiveFaces += currentFaces;

  } else {
    osg::notify(osg::ALWAYS) << "Unknown Primitive Set Type : " << mode << std::endl;
  }

}

/////////////////////////////////////////////////////////////////////////
//
// writeCoord
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::writeCoord(osg::Vec3Array* array) {

  if (array == NULL) {
    std::cerr << "Vec3Array is NULL" << std::endl;
    return;
  }
  osg::ref_ptr < osg::Vec3Array > vArray = array;

  _fout << indentM() << "coord Coordinate {\n";
  _fout << indentM() << "point [\n";
  indentM();
  osg::Vec3 xyz;
  for (unsigned int j = 0; j < vArray->size(); j++) {
    xyz = (*vArray)[j];
    _fout << indent() << xyz[0] << " " << xyz[1] << " " << xyz[2] << ",\n";
  }
  _fout << indentL() << "]\n";
  _fout << indentL() << "}\n";
  indentL();
}

/////////////////////////////////////////////////////////////////////////
//
// writeTexCoord
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::writeTexCoord(osg::Vec2Array* array, osg::Vec3Array* array2) {

  osg::ref_ptr < osg::StateSet > ss = getCurrentStateSet();
  osg::Texture2D* tex = (osg::Texture2D*) (ss->getTextureAttribute(_txtUnit, osg::StateAttribute::TEXTURE));
  if (tex == NULL) {
    return;
  }

  osg::ref_ptr < osg::TexGen > texGen = dynamic_cast<osg::TexGen*> (ss->getTextureAttribute(_txtUnit, osg::StateAttribute::TEXGEN));
  osg::ref_ptr < osg::TexEnv > texEnv = dynamic_cast<osg::TexEnv*> (ss->getTextureAttribute(_txtUnit, osg::StateAttribute::TEXENV));

  osg::Texture::WrapMode wrap_s = tex->getWrap(osg::Texture::WRAP_S);//osg::Texture::REPEAT;
  osg::Texture::WrapMode wrap_t = tex->getWrap(osg::Texture::WRAP_T);//osg::Texture::REPEAT;

  if (array != NULL) {
    writeUVArray(array, wrap_s, wrap_t);

  } else if (texGen.valid()) {
    //std::cout << "TEXGEN" << std::endl;
    osg::ref_ptr < osg::Vec2Array > uvArray = buildUVArray(texGen.get(), array2);
    if (uvArray.valid()) {
      writeUVArray(uvArray.get(), wrap_s, wrap_t);
    }

  } else if (texEnv.valid()) {
    //std::cout << "TEXENV" << std::endl;
    osg::ref_ptr < osg::Vec2Array > uvArray = buildUVArray(texEnv.get(), array2);
    if (uvArray.valid()) {
      writeUVArray(uvArray.get(), wrap_s, wrap_t);
    }
  }
}

/////////////////////////////////////////////////////////////////////////
//
// writeNormal
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::writeNormal(osg::Geometry* geom, std::vector<int>& primitiveSetFaces, int nbFaces) {

  osg::ref_ptr < osg::Vec3Array > nArray = (osg::Vec3Array*) (geom->getNormalArray());
  if (!nArray.valid()) {
    return;
  }

  if (geom->getNormalBinding() == osg::Geometry::BIND_PER_VERTEX || geom->getNormalBinding() == osg::Geometry::BIND_OVERALL) {
    _fout << indentM() << "normalPerVertex TRUE \n";
  } else {
    _fout << indentM() << "normalPerVertex FALSE \n";
  }

  _fout << indent() << "normal Normal {\n";
  _fout << indentM() << "vector [\n";
  indentM();
  osg::Vec3 n;

  if (geom->getNormalBinding() == osg::Geometry::BIND_PER_VERTEX) {
    for (unsigned int j = 0; j < (*nArray).size(); j++) {
      n = (*nArray)[j];
      _fout << indent() << n[0] << " " << n[1] << " " << n[2] << ",\n";
    }

  } else if (geom->getNormalBinding() == osg::Geometry::BIND_OVERALL) {
    n = (*nArray)[0];
    int size = ((osg::Vec3Array*) (geom->getVertexArray()))->size();
    for (int j = 0; j < size; j++) {
      _fout << indent() << n[0] << " " << n[1] << " " << n[2] << ",\n";
    }

  } else if (geom->getNormalBinding() == osg::Geometry::BIND_PER_PRIMITIVE) {
    for (unsigned int j = 0; j < (*nArray).size(); j++) {
      n = (*nArray)[j];
      _fout << indent() << n[0] << " " << n[1] << " " << n[2] << ",\n";
    }

  } else if (geom->getNormalBinding() == osg::Geometry::BIND_PER_PRIMITIVE_SET) {
    for (unsigned int j = 0; j < (*nArray).size(); j++) {
      n = (*nArray)[j];
      for (int k = 0; k < primitiveSetFaces[j]; k++) {
        _fout << indent() << n[0] << " " << n[1] << " " << n[2] << ",\n";
      }
    }
  }

  _fout << indentL() << "]\n";
  _fout << indentL() << "}\n";
  indentL();
}

/////////////////////////////////////////////////////////////////////////
//
// writeUVArray
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::writeUVArray(osg::Vec2Array* uvArray, osg::Texture::WrapMode wrap_s, osg::Texture::WrapMode wrap_t) {

  _fout << indentM() << "texCoord TextureCoordinate {\n";
  _fout << indentM() << "point [\n";
  indentM();
  osg::Vec2 uv;

  for (unsigned int j = 0; j < (*uvArray).size(); j++) {
    uv = (*uvArray)[j];
    if (wrap_s != osg::Texture::REPEAT) {
      // clamp to 0-1
      if (uv[0] < 0) {
        uv[0] = 0;
      } else if (uv[0] > 1) {
        uv[0] = 1;
      }
    }
    if (wrap_t != osg::Texture::REPEAT) {
      // clamp to 0-1
      if (uv[1] < 0) {
        uv[1] = 0;
      } else if (uv[1] > 1) {
        uv[1] = 1;
      }
    }
    _fout << indent() << uv[0] << " " << uv[1] << ",\n";
  }
  _fout << indentL() << "]\n";
  _fout << indentL() << "}\n";
  indentL();
}

/////////////////////////////////////////////////////////////////////////
//
// buildUVArray
//
/////////////////////////////////////////////////////////////////////////
osg::Vec2Array* ToVRML::buildUVArray(osg::TexGen* tGen, osg::Vec3Array* array) {
  osg::ref_ptr < osg::TexGen > texGen = tGen;
  osg::ref_ptr < osg::Vec3Array > vArray = array;
  osg::Vec2Array* uvRet = NULL;

  osg::TexGen::Mode mode = texGen->getMode();
  if (mode == osg::TexGen::OBJECT_LINEAR) {
    //std::cout << "I know" << std::endl;

    uvRet = new osg::Vec2Array();
    osg::Plane planS = texGen->getPlane(osg::TexGen::S);//, osg::Vec4(1 / rangeS, 0, 0, -(adfGeoTransform[0] / rangeS)));
    osg::Plane planT = texGen->getPlane(osg::TexGen::T);//, osg::Vec4(0, 1 / rangeT, 0, -(adfGeoTransform[3] + sy * adfGeoTransform[5]) / rangeT));
    osg::Vec4 pS = planS.asVec4();
    osg::Vec4 pT = planT.asVec4();
    double width, height, xmin, ymin;
    width = 1.0 / pS[0];
    height = 1.0 / pT[1];
    xmin = -width * pS[3];
    ymin = -height * pT[3];

    for (unsigned int j = 0; j < vArray->size(); j++) {
      osg::Vec3d p = (*vArray)[j];
      double x, y;
      osg::Vec2 uv;
      x = p[0];
      y = p[1];
      uv[0] = (x - xmin) / width;
      uv[1] = (y - ymin) / height;
      (*uvRet).push_back(uv);

    }
  } else {
    osg::notify(osg::ALWAYS) << "Unknown TexGen mode" << std::endl;
  }

  return (uvRet);
}

/////////////////////////////////////////////////////////////////////////
//
// buildUVArray
//
/////////////////////////////////////////////////////////////////////////
osg::Vec2Array* ToVRML::buildUVArray(osg::TexEnv* tEnv, osg::Vec3Array* array) {
  osg::ref_ptr < osg::TexEnv > texEnv = tEnv;
  osg::Vec2Array* uvRet = NULL;

 // osg::TexEnv::Mode mode = texEnv->getMode();
  //if (mode == osg::TexEnv::MODULATE) {
  //  std::cout << "I know" << std::endl;
  //} else {
  osg::notify(osg::ALWAYS) << "Unknown TexEnv mode" << std::endl;
  //}
  return (uvRet);
}

/////////////////////////////////////////////////////////////////////////
//
// writeColor
//
/////////////////////////////////////////////////////////////////////////
void ToVRML::writeColor(osg::Geometry* geom, std::vector<int>& primitiveSetFaces, int nbFaces) {

  osg::ref_ptr < osg::Vec4Array > cArray = (osg::Vec4Array*) (geom->getColorArray());
  if (!cArray.valid()) {
    return;
  }

  if (geom->getColorBinding() == osg::Geometry::BIND_PER_VERTEX || geom->getColorBinding() == osg::Geometry::BIND_OVERALL) {
    _fout << indentM() << "colorPerVertex TRUE \n";
  } else {
    _fout << indentM() << "colorPerVertex FALSE \n";
  }

  _fout << indent() << "color Color {\n";
  _fout << indentM() << "color [\n";
  indentM();
  osg::Vec4 c;

  if (geom->getColorBinding() == osg::Geometry::BIND_PER_VERTEX) {
    for (unsigned int j = 0; j < (*cArray).size(); j++) {
      c = (*cArray)[j];
      _fout << indent() << c[0] << " " << c[1] << " " << c[2] << ",\n";
    }

  } else if (geom->getColorBinding() == osg::Geometry::BIND_OVERALL) {
    c = (*cArray)[0];
    int size = ((osg::Vec3Array*) (geom->getVertexArray()))->size();
    for (int j = 0; j < size; j++) {
      _fout << indent() << c[0] << " " << c[1] << " " << c[2] << ",\n";
    }

  } else if (geom->getColorBinding() == osg::Geometry::BIND_PER_PRIMITIVE) {
    for (unsigned int j = 0; j < (*cArray).size(); j++) {
      c = (*cArray)[j];
      _fout << indent() << c[0] << " " << c[1] << " " << c[2] << ",\n";
    }

  } else if (geom->getColorBinding() == osg::Geometry::BIND_PER_PRIMITIVE_SET) {
    for (unsigned int j = 0; j < (*cArray).size(); j++) {
      c = (*cArray)[j];
      for (int k = 0; k < primitiveSetFaces[j]; k++) {
        _fout << indent() << c[0] << " " << c[1] << " " << c[2] << ",\n";
      }
    }
  }

  _fout << indentL() << "]\n";
  _fout << indentL() << "}\n";
  indentL();
}
