From 587fd6a022b0b4c606e14f0097f548517081ff7b Mon Sep 17 00:00:00 2001 From: Robert Osfield Date: Thu, 18 Jul 2019 11:14:10 +0100 Subject: [PATCH] Removed vrml plugin from build as OpenVRML plugin relies on no longer supported functionality --- src/osgPlugins/vrml/CMakeLists.txt | 49 - src/osgPlugins/vrml/ConvertToVRML.cpp | 1295 --------------------- src/osgPlugins/vrml/ConvertToVRML.h | 115 -- src/osgPlugins/vrml/IndexedFaceSet.cpp | 328 ------ src/osgPlugins/vrml/LICENSE.txt | 504 -------- src/osgPlugins/vrml/Primitives.cpp | 539 --------- src/osgPlugins/vrml/README.txt | 14 - src/osgPlugins/vrml/ReaderWriterVRML2.cpp | 651 ----------- src/osgPlugins/vrml/ReaderWriterVRML2.h | 118 -- 9 files changed, 3613 deletions(-) delete mode 100644 src/osgPlugins/vrml/CMakeLists.txt delete mode 100644 src/osgPlugins/vrml/ConvertToVRML.cpp delete mode 100644 src/osgPlugins/vrml/ConvertToVRML.h delete mode 100644 src/osgPlugins/vrml/IndexedFaceSet.cpp delete mode 100644 src/osgPlugins/vrml/LICENSE.txt delete mode 100644 src/osgPlugins/vrml/Primitives.cpp delete mode 100644 src/osgPlugins/vrml/README.txt delete mode 100644 src/osgPlugins/vrml/ReaderWriterVRML2.cpp delete mode 100644 src/osgPlugins/vrml/ReaderWriterVRML2.h diff --git a/src/osgPlugins/vrml/CMakeLists.txt b/src/osgPlugins/vrml/CMakeLists.txt deleted file mode 100644 index 194bb9a19..000000000 --- a/src/osgPlugins/vrml/CMakeLists.txt +++ /dev/null @@ -1,49 +0,0 @@ -INCLUDE_DIRECTORIES(${OPENVRML_INCLUDE_DIR}) -INCLUDE_DIRECTORIES(${OPENVRML_INCLUDE_DIR}/openvrml) - -IF (WIN32) - INCLUDE_DIRECTORIES(${JPEG_INCLUDE_DIR}) - INCLUDE_DIRECTORIES(${PNG_INCLUDE_DIR}) - INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR}) - - FIND_LIBRARY(OPENVRML_ANTLR_LIBRARY - NAMES antlr.lib - PATHS $ENV{OPENVRML_DIR}/lib) - FIND_LIBRARY(OPENVRML_ANTLR_LIBRARY_DEBUG - NAMES antlrd.lib - PATHS $ENV{OPENVRML_DIR}/lib) - FIND_LIBRARY(OPENVRML_REGEX_LIBRARY - NAMES regex.lib - PATHS $ENV{OPENVRML_DIR}/lib) - FIND_LIBRARY(OPENVRML_REGEX_LIBRARY_DEBUG - NAMES regexd.lib - PATHS $ENV{OPENVRML_DIR}/lib) - - SET(TARGET_LIBRARIES_VARS - OPENVRML_ANTLR_LIBRARY - OPENVRML_REGEX_LIBRARY - OPENVRML_LIBRARY - JPEG_LIBRARY - PNG_LIBRARY - ZLIB_LIBRARIES) - SET(TARGET_EXTERNAL_LIBRARIES - ws2_32.lib) -ELSE() - SET(TARGET_LIBRARIES_VARS - OPENVRML_LIBRARY) -ENDIF() - -SET(TARGET_SRC - IndexedFaceSet.cpp - Primitives.cpp - ReaderWriterVRML2.cpp - ConvertToVRML.cpp -) - -SET(TARGET_H - ReaderWriterVRML2.h - ConvertToVRML.h -) - -#### end var setup ### -SETUP_PLUGIN(vrml vrml) diff --git a/src/osgPlugins/vrml/ConvertToVRML.cpp b/src/osgPlugins/vrml/ConvertToVRML.cpp deleted file mode 100644 index f4c10faa0..000000000 --- a/src/osgPlugins/vrml/ConvertToVRML.cpp +++ /dev/null @@ -1,1295 +0,0 @@ -/* - * - * OSG to VRML2 converter for OpenSceneGraph. - * - * authors : - * Johan Nouvel (johan_nouvel@yahoo.com) - * - * - */ - -#include "ConvertToVRML.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -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 (root); - osg::MatrixTransform* node = new osg::MatrixTransform(aMat); - ret->addChild(node); - } else if (strcmp(root.className(), "Group") == 0) { - const osg::Group& aGroup = static_cast (root); - osg::Group* node = new osg::Group(aGroup); - ret->addChild(node); - } else if (strcmp(root.className(), "PositionAttitudeTransform") == 0) { - const osg::PositionAttitudeTransform& aPAT = static_cast (root); - osg::PositionAttitudeTransform* node = new osg::PositionAttitudeTransform(aPAT); - ret->addChild(node); - } else if (strcmp(root.className(), "Geode") == 0) { - const osg::Geode& aGeode = static_cast (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<<"-"<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 "<className()<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) { - - if (geom->containsDeprecatedData()) geom->fixDeprecatedData(); - - // 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 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 (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 (geom->getPrimitiveSet(p)); - - //std::cout<getFirst()<<" "<getNumPrimitives()<<" "<< dal->getNumIndices ()<<" "<< dal->getNumInstances()<getFirst(); prim < dal->getNumPrimitives(); prim++) { - //std::cout<<(*dal)[prim]< drui = dynamic_cast (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 (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 (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 "<getWrap(osg::Texture::WRAP_S)<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 < 0) { - fakeFirst = true; - } - if (node.getMaxRange(node.getNumRanges() - 1) < std::numeric_limits::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(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, 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::readRefImageFile(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, 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 void ToVRML::writeCoordIndex(GLenum mode, T* indices, unsigned int number, std::vector& 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 (ss->getTextureAttribute(_txtUnit, osg::StateAttribute::TEXGEN)); - osg::ref_ptr < osg::TexEnv > texEnv = dynamic_cast (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& primitiveSetFaces, int nbFaces) { - - osg::ref_ptr < osg::Vec3Array > nArray = (osg::Vec3Array*) (geom->getNormalArray()); - if (!nArray.valid()) { - return; - } - - osg::Array::Binding normalBinding = osg::getBinding(geom->getNormalArray()); - if (normalBinding == osg::Array::BIND_PER_VERTEX || normalBinding == osg::Array::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 (normalBinding == osg::Array::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 (normalBinding == osg::Array::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 (normalBinding == osg::Array::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& primitiveSetFaces, int nbFaces) { - - osg::ref_ptr < osg::Vec4Array > cArray = (osg::Vec4Array*) (geom->getColorArray()); - if (!cArray.valid()) { - return; - } - - osg::Array::Binding colorBinding = osg::getBinding(geom->getColorArray()); - if (colorBinding == osg::Array::BIND_PER_VERTEX || colorBinding == osg::Array::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 (colorBinding == osg::Array::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 (colorBinding == osg::Array::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 (colorBinding == osg::Array::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(); -} diff --git a/src/osgPlugins/vrml/ConvertToVRML.h b/src/osgPlugins/vrml/ConvertToVRML.h deleted file mode 100644 index 21b9f9620..000000000 --- a/src/osgPlugins/vrml/ConvertToVRML.h +++ /dev/null @@ -1,115 +0,0 @@ -/* - * - * OSG to VRML2 converter for OpenSceneGraph. - * - * authors : - * Johan Nouvel (johan_nouvel@yahoo.com) - * - * - */ - - -#ifndef __convert_to_vrml_to_osg_ -#define __convert_to_vrml_to_osg_ 1 - -#include -#include - -// OSG headers -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -using namespace std; - -/** - * This function is called to write an osg graph into a VRML file - * - */ -osgDB::ReaderWriter::WriteResult convertToVRML(const osg::Node& root, const std::string& filename, const osgDB::ReaderWriter::Options* options=NULL) ; - -class ToVRML: public osg::NodeVisitor { - public: - - typedef enum { - NO_TEXTURE = 0, KEEP_ORIGINAL_TEXTURE = 1, COPY_TEXTURE = 2, CONVERT_TEXTURE = 3 - } TextureMode; - ToVRML(const std::string& fileName, const osgDB::ReaderWriter::Options* options); - virtual ~ToVRML(); - osgDB::ReaderWriter::WriteResult result() { - return (_res); - } - ; - - virtual void apply(osg::Geode& node); - virtual void apply(osg::Group& node); - virtual void apply(osg::Billboard& node); - virtual void apply(osg::MatrixTransform& node); - virtual void apply(osg::PositionAttitudeTransform& node); - virtual void apply(osg::Node& node); - virtual void apply(osg::LOD& node); - - char *indent(); - char *indentM(); - char *indentL(); - void pushStateSetStack(osg::StateSet* ss); - void popStateSetStack(); - osg::StateSet* getCurrentStateSet(); - - //void findObjectName(osg::Object* obj,std::string& name, bool& alreadyLoaded); - void findMaterialName(osg::Material* mat, std::string& name, bool& alreadyLoaded); - void findTextureName(osg::Texture2D* tex, std::string& name, bool& alreadyLoaded); - - void apply(osg::Geometry* geom); - void apply(osg::Drawable* drawable); - void writeAppearance(osg::StateSet* stateset); - void writeCoord(osg::Vec3Array* array); - template void writeCoordIndex(GLenum mode, T* indices, unsigned int number, std::vector& primitiveSetFaces, int& primitiveFaces); - void writeTexCoord(osg::Vec2Array* array, osg::Vec3Array* array2); - osg::Vec2Array* buildUVArray(osg::TexGen* tGen, osg::Vec3Array* array); - osg::Vec2Array* buildUVArray(osg::TexEnv* tEnv, osg::Vec3Array* array); - void writeUVArray(osg::Vec2Array* uvArray, osg::Texture::WrapMode wrap_s, osg::Texture::WrapMode wrap_t); - void writeNormal(osg::Geometry* geom, std::vector& primitiveSetFaces, int nbFaces); - void writeColor(osg::Geometry* geom, std::vector& primitiveSetFaces, int nbFaces); - - osgDB::ReaderWriter::WriteResult _res; - ofstream _fout; - int _indent; - char* _strIndent; - - map, std::string> _texMap; - map, std::string> _matMap; - vector > _stack; - osg::ref_ptr _defaultImage; - std::string _pathToOutput; - std::string _pathRelativeToOutput; - TextureMode _textureMode; - int _txtUnit; - -}; - -#endif diff --git a/src/osgPlugins/vrml/IndexedFaceSet.cpp b/src/osgPlugins/vrml/IndexedFaceSet.cpp deleted file mode 100644 index bf4ee402c..000000000 --- a/src/osgPlugins/vrml/IndexedFaceSet.cpp +++ /dev/null @@ -1,328 +0,0 @@ -// -*-c++-*- - -#include "ReaderWriterVRML2.h" - - -#if defined(_MSC_VER) -# pragma warning(disable: 4250) -# pragma warning(disable: 4290) -# pragma warning(disable: 4800) -#endif - -#include - -#include - -osg::ref_ptr ReaderWriterVRML2::convertVRML97IndexedFaceSet(openvrml::node *vrml_ifs) const -{ - osg::ref_ptr osg_geom = new deprecated_osg::Geometry(); - - osg_geom->addPrimitiveSet(new osg::DrawArrayLengths(osg::PrimitiveSet::POLYGON)); - - // get array of vertex coordinate_nodes - if(vrml_ifs->type().id() == "IndexedFaceSet") - { - std::auto_ptr fv = vrml_ifs->field("coord"); - const openvrml::sfnode *sfn = dynamic_cast(fv.get()); - - openvrml::coordinate_node *vrml_coord_node = dynamic_cast((sfn->value()).get()); - const std::vector &vrml_coord = vrml_coord_node->point(); - - osg::ref_ptr osg_vertices = new osg::Vec3Array(); - - unsigned i; - for (i = 0; i < vrml_coord.size(); i++) - { - openvrml::vec3f vec = vrml_coord[i]; - osg_vertices->push_back(osg::Vec3(vec[0], vec[1], vec[2])); - } - - osg_geom->setVertexArray(osg_vertices.get()); - - // get array of vertex indices - std::auto_ptr fv2 = vrml_ifs->field("coordIndex"); - const openvrml::mfint32 *vrml_coord_index = dynamic_cast(fv2.get()); - - osg::ref_ptr osg_vert_index = new osg::IntArray(); - - int num_vert = 0; - for (i = 0; i < vrml_coord_index->value().size(); i++) - { - int index = vrml_coord_index->value()[i]; - if (index == -1) - { - static_cast(osg_geom->getPrimitiveSet(0))->push_back(num_vert); - num_vert = 0; - } - else - { - osg_vert_index->push_back(index); - ++num_vert; - } - } - - if (num_vert) - { - //GvdB: Last coordIndex wasn't -1 - static_cast(osg_geom->getPrimitiveSet(0))->push_back(num_vert); - } - - osg_geom->setVertexIndices(osg_vert_index.get()); - } - - { - // get texture coordinate_nodes - std::auto_ptr fv = vrml_ifs->field("texCoord"); - const openvrml::sfnode *sfn = dynamic_cast(fv.get()); - openvrml::texture_coordinate_node *vrml_tex_coord_node = dynamic_cast(sfn->value().get()); - - if (vrml_tex_coord_node != 0) // if no texture, node is NULL pointer - { - const std::vector &vrml_tex_coord = vrml_tex_coord_node->point(); - osg::ref_ptr osg_texcoords = new osg::Vec2Array(); - - unsigned i; - for (i = 0; i < vrml_tex_coord.size(); i++) - { - openvrml::vec2f vec = vrml_tex_coord[i]; - osg_texcoords->push_back(osg::Vec2(vec[0], vec[1])); - } - - osg_geom->setTexCoordArray(0, osg_texcoords.get()); - - // get array of texture indices - std::auto_ptr fv2 = vrml_ifs->field("texCoordIndex"); - const openvrml::mfint32 *vrml_tex_coord_index = dynamic_cast(fv2.get()); - - osg::ref_ptr osg_tex_coord_index = new osg::IntArray(); - - if(vrml_tex_coord_index->value().size() > 0) - { - for (i = 0; i < vrml_tex_coord_index->value().size(); i++) - { - int index = vrml_tex_coord_index->value()[i]; - if (index != -1) { - osg_tex_coord_index->push_back(index); - } - } - osg_geom->setTexCoordIndices(0, osg_tex_coord_index.get()); - } else - // no indices defined, use coordIndex - osg_geom->setTexCoordIndices(0, const_cast(osg_geom->getVertexIndices())); - } - } - - // get array of normals per vertex (if specified) - { - std::auto_ptr fv = vrml_ifs->field("normal"); - const openvrml::sfnode *sfn = dynamic_cast(fv.get()); - openvrml::normal_node *vrml_normal_node = dynamic_cast(sfn->value().get()); - - if (vrml_normal_node != 0) // if no normals, node is NULL pointer - { - const std::vector& vrml_normal_coord = vrml_normal_node->vector(); - - osg::ref_ptr osg_normalcoords = new osg::Vec3Array(); - - unsigned i; - for (i = 0; i < vrml_normal_coord.size(); i++) - { - const openvrml::vec3f vec = vrml_normal_coord[i]; - osg_normalcoords->push_back(osg::Vec3(vec[0], vec[1], vec[2])); - } - osg_geom->setNormalArray(osg_normalcoords.get()); - - // get array of normal indices - std::auto_ptr fv2 = vrml_ifs->field("normalIndex"); - const openvrml::mfint32 *vrml_normal_index = dynamic_cast(fv2.get()); - - osg::ref_ptr osg_normal_index = new osg::IntArray(); - - if (vrml_normal_index->value().size() > 0) - { - for (i = 0; i < vrml_normal_index->value().size(); i++) - { - int index = vrml_normal_index->value()[i]; - if (index != -1) - { - osg_normal_index->push_back(index); - } - } - osg_geom->setNormalIndices(osg_normal_index.get()); - } - else - // unspecified, use the coordIndex field - osg_geom->setNormalIndices(const_cast(osg_geom->getVertexIndices())); - - // get normal binding - std::auto_ptr fv3 = vrml_ifs->field("normalPerVertex"); - const openvrml::sfbool *vrml_norm_per_vertex = dynamic_cast(fv3.get()); - - if (vrml_norm_per_vertex->value()) - { - osg_geom->setNormalBinding(deprecated_osg::Geometry::BIND_PER_VERTEX); - } else - { - osg_geom->setNormalBinding(deprecated_osg::Geometry::BIND_PER_PRIMITIVE); - } - } - } - - // get array of colours per vertex (if specified) - { - std::auto_ptr fv = vrml_ifs->field("color"); - const openvrml::sfnode *sfn = dynamic_cast(fv.get()); - openvrml::color_node *vrml_color_node = dynamic_cast(sfn->value().get()); - - if (vrml_color_node != 0) // if no colors, node is NULL pointer - { - const std::vector &vrml_colors = vrml_color_node->color(); - - osg::ref_ptr osg_colors = new osg::Vec3Array(); - - unsigned i; - for (i = 0; i < vrml_colors.size(); i++) - { - const openvrml::color color = vrml_colors[i]; - osg_colors->push_back(osg::Vec3(color.r(), color.g(), color.b())); - } - osg_geom->setColorArray(osg_colors.get()); - - // get array of color indices - std::auto_ptr fv2 = vrml_ifs->field("colorIndex"); - const openvrml::mfint32 *vrml_color_index = dynamic_cast(fv2.get()); - - osg::ref_ptr osg_color_index = new osg::IntArray(); - - if(vrml_color_index->value().size() > 0) - { - for (i = 0; i < vrml_color_index->value().size(); i++) - { - int index = vrml_color_index->value()[i]; - if (index != -1) { - osg_color_index->push_back(index); - } - } - osg_geom->setColorIndices(osg_color_index.get()); - } else - // unspecified, use coordIndices field - osg_geom->setColorIndices(const_cast(osg_geom->getVertexIndices())); - - // get color binding - std::auto_ptr fv3 = vrml_ifs->field("colorPerVertex"); - const openvrml::sfbool *vrml_color_per_vertex = dynamic_cast(fv3.get()); - - if (vrml_color_per_vertex->value()) - { - osg_geom->setColorBinding(deprecated_osg::Geometry::BIND_PER_VERTEX); - } else - { - osg_geom->setColorBinding(deprecated_osg::Geometry::BIND_PER_PRIMITIVE); - } - } - } - - - // normal smoothing - std::auto_ptr fv_solid = vrml_ifs->field("solid"); - const openvrml::sfbool *solid = dynamic_cast(fv_solid.get()); - if (solid->value()) - { - osg_geom->getOrCreateStateSet()->setAttributeAndModes(new osg::CullFace(osg::CullFace::BACK)); - } - - if (!osg_geom->getNormalArray()) - { -#if 0 - // GvdB: This is what I wanted to do, but got zero normals since the triangles were considered temporaries (?) - osgUtil::SmoothingVisitor().smooth(*osg_geom); -#else - // GvdB: So I ended up computing the smoothing normals myself. Also, I might add support for "creaseAngle" if a big need for it rises. - // However, for now I can perfectly live with the fact that all edges are smoothed despite the use of a crease angle. - osg::Vec3Array& coords = *static_cast(osg_geom->getVertexArray()); - assert(coords.size()); - - osg::Vec3Array* normals = new osg::Vec3Array(coords.size()); - - for (osg::Vec3Array::iterator it = normals->begin(); it != normals->end(); ++it) - { - (*it).set(0.0f, 0.0f, 0.0f); - } - - - const osg::IntArray& indices = *static_cast(osg_geom->getVertexIndices()); - osg::DrawArrayLengths& lengths = *static_cast(osg_geom->getPrimitiveSet(0)); - unsigned index = 0; - - for (osg::DrawArrayLengths::iterator it = lengths.begin(); it != lengths.end(); ++it) - { - assert(*it >= 3); - const osg::Vec3& v0 = coords[indices[index]]; - const osg::Vec3& v1 = coords[indices[index + 1]]; - const osg::Vec3& v2 = coords[indices[index + 2]]; - - osg::Vec3 normal = (v1 - v0) ^ (v2 - v0); - normal.normalize(); - - for (int i = 0; i != *it; ++i) - { - (*normals)[indices[index + i]] += normal; - } - - index += *it; - } - - assert(index == indices.size()); - - for(osg::Vec3Array::iterator it = normals->begin(); it != normals->end(); ++it) - { - (*it).normalize(); - } - - osg_geom->setNormalArray(normals); - osg_geom->setNormalIndices(const_cast(osg_geom->getVertexIndices())); - osg_geom->setNormalBinding(deprecated_osg::Geometry::BIND_PER_VERTEX); - -#endif - } - - osg::DrawArrayLengths& lengths = *static_cast(osg_geom->getPrimitiveSet(0)); - - osg::DrawArrayLengths::iterator it = lengths.begin(); - if (it != lengths.end()) - { - switch (*it) - { - case 3: - while (++it != lengths.end() && *it == 3) - ; - - if (it == lengths.end()) - { - // All polys are triangles - osg::ref_ptr mesh = new osg::DrawArrays(osg::PrimitiveSet::TRIANGLES); - mesh->setCount(lengths.size() * 3); - osg_geom->removePrimitiveSet(0); - osg_geom->addPrimitiveSet(mesh.get()); - } - break; - - case 4: - while (++it != lengths.end() && *it == 4) - ; - - if (it == lengths.end()) - { - // All polys are quads - osg::ref_ptr mesh = new osg::DrawArrays(osg::PrimitiveSet::QUADS); - mesh->setCount(lengths.size() * 4); - osg_geom->removePrimitiveSet(0); - osg_geom->addPrimitiveSet(mesh.get()); - } - - break; - } - } - - return osg_geom.get(); -} diff --git a/src/osgPlugins/vrml/LICENSE.txt b/src/osgPlugins/vrml/LICENSE.txt deleted file mode 100644 index b1e3f5a26..000000000 --- a/src/osgPlugins/vrml/LICENSE.txt +++ /dev/null @@ -1,504 +0,0 @@ - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 - - Copyright (C) 1991, 1999 Free Software Foundation, Inc. - 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - -[This is the first released version of the Lesser GPL. It also counts - as the successor of the GNU Library Public License, version 2, hence - the version number 2.1.] - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -Licenses are intended to guarantee your freedom to share and change -free software--to make sure the software is free for all its users. - - This license, the Lesser General Public License, applies to some -specially designated software packages--typically libraries--of the -Free Software Foundation and other authors who decide to use it. You -can use it too, but we suggest you first think carefully about whether -this license or the ordinary General Public License is the better -strategy to use in any particular case, based on the explanations below. - - When we speak of free software, we are referring to freedom of use, -not price. Our General Public Licenses are designed to make sure that -you have the freedom to distribute copies of free software (and charge -for this service if you wish); that you receive source code or can get -it if you want it; that you can change the software and use pieces of -it in new free programs; and that you are informed that you can do -these things. - - To protect your rights, we need to make restrictions that forbid -distributors to deny you these rights or to ask you to surrender these -rights. These restrictions translate to certain responsibilities for -you if you distribute copies of the library or if you modify it. - - For example, if you distribute copies of the library, whether gratis -or for a fee, you must give the recipients all the rights that we gave -you. You must make sure that they, too, receive or can get the source -code. If you link other code with the library, you must provide -complete object files to the recipients, so that they can relink them -with the library after making changes to the library and recompiling -it. And you must show them these terms so they know their rights. - - We protect your rights with a two-step method: (1) we copyright the -library, and (2) we offer you this license, which gives you legal -permission to copy, distribute and/or modify the library. - - To protect each distributor, we want to make it very clear that -there is no warranty for the free library. Also, if the library is -modified by someone else and passed on, the recipients should know -that what they have is not the original version, so that the original -author's reputation will not be affected by problems that might be -introduced by others. - - Finally, software patents pose a constant threat to the existence of -any free program. We wish to make sure that a company cannot -effectively restrict the users of a free program by obtaining a -restrictive license from a patent holder. Therefore, we insist that -any patent license obtained for a version of the library must be -consistent with the full freedom of use specified in this license. - - Most GNU software, including some libraries, is covered by the -ordinary GNU General Public License. This license, the GNU Lesser -General Public License, applies to certain designated libraries, and -is quite different from the ordinary General Public License. We use -this license for certain libraries in order to permit linking those -libraries into non-free programs. - - When a program is linked with a library, whether statically or using -a shared library, the combination of the two is legally speaking a -combined work, a derivative of the original library. The ordinary -General Public License therefore permits such linking only if the -entire combination fits its criteria of freedom. The Lesser General -Public License permits more lax criteria for linking other code with -the library. - - We call this license the "Lesser" General Public License because it -does Less to protect the user's freedom than the ordinary General -Public License. It also provides other free software developers Less -of an advantage over competing non-free programs. These disadvantages -are the reason we use the ordinary General Public License for many -libraries. However, the Lesser license provides advantages in certain -special circumstances. - - For example, on rare occasions, there may be a special need to -encourage the widest possible use of a certain library, so that it becomes -a de-facto standard. To achieve this, non-free programs must be -allowed to use the library. A more frequent case is that a free -library does the same job as widely used non-free libraries. In this -case, there is little to gain by limiting the free library to free -software only, so we use the Lesser General Public License. - - In other cases, permission to use a particular library in non-free -programs enables a greater number of people to use a large body of -free software. For example, permission to use the GNU C Library in -non-free programs enables many more people to use the whole GNU -operating system, as well as its variant, the GNU/Linux operating -system. - - Although the Lesser General Public License is Less protective of the -users' freedom, it does ensure that the user of a program that is -linked with the Library has the freedom and the wherewithal to run -that program using a modified version of the Library. - - The precise terms and conditions for copying, distribution and -modification follow. Pay close attention to the difference between a -"work based on the library" and a "work that uses the library". The -former contains code derived from the library, whereas the latter must -be combined with the library in order to run. - - GNU LESSER GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License Agreement applies to any software library or other -program which contains a notice placed by the copyright holder or -other authorized party saying it may be distributed under the terms of -this Lesser General Public License (also called "this License"). -Each licensee is addressed as "you". - - A "library" means a collection of software functions and/or data -prepared so as to be conveniently linked with application programs -(which use some of those functions and data) to form executables. - - The "Library", below, refers to any such software library or work -which has been distributed under these terms. A "work based on the -Library" means either the Library or any derivative work under -copyright law: that is to say, a work containing the Library or a -portion of it, either verbatim or with modifications and/or translated -straightforwardly into another language. (Hereinafter, translation is -included without limitation in the term "modification".) - - "Source code" for a work means the preferred form of the work for -making modifications to it. For a library, complete source code means -all the source code for all modules it contains, plus any associated -interface definition files, plus the scripts used to control compilation -and installation of the library. - - Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running a program using the Library is not restricted, and output from -such a program is covered only if its contents constitute a work based -on the Library (independent of the use of the Library in a tool for -writing it). Whether that is true depends on what the Library does -and what the program that uses the Library does. - - 1. You may copy and distribute verbatim copies of the Library's -complete source code as you receive it, in any medium, provided that -you conspicuously and appropriately publish on each copy an -appropriate copyright notice and disclaimer of warranty; keep intact -all the notices that refer to this License and to the absence of any -warranty; and distribute a copy of this License along with the -Library. - - You may charge a fee for the physical act of transferring a copy, -and you may at your option offer warranty protection in exchange for a -fee. - - 2. You may modify your copy or copies of the Library or any portion -of it, thus forming a work based on the Library, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) The modified work must itself be a software library. - - b) You must cause the files modified to carry prominent notices - stating that you changed the files and the date of any change. - - c) You must cause the whole of the work to be licensed at no - charge to all third parties under the terms of this License. - - d) If a facility in the modified Library refers to a function or a - table of data to be supplied by an application program that uses - the facility, other than as an argument passed when the facility - is invoked, then you must make a good faith effort to ensure that, - in the event an application does not supply such function or - table, the facility still operates, and performs whatever part of - its purpose remains meaningful. - - (For example, a function in a library to compute square roots has - a purpose that is entirely well-defined independent of the - application. Therefore, Subsection 2d requires that any - application-supplied function or table used by this function must - be optional: if the application does not supply it, the square - root function must still compute square roots.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Library, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Library, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote -it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Library. - -In addition, mere aggregation of another work not based on the Library -with the Library (or with a work based on the Library) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may opt to apply the terms of the ordinary GNU General Public -License instead of this License to a given copy of the Library. To do -this, you must alter all the notices that refer to this License, so -that they refer to the ordinary GNU General Public License, version 2, -instead of to this License. (If a newer version than version 2 of the -ordinary GNU General Public License has appeared, then you can specify -that version instead if you wish.) Do not make any other change in -these notices. - - Once this change is made in a given copy, it is irreversible for -that copy, so the ordinary GNU General Public License applies to all -subsequent copies and derivative works made from that copy. - - This option is useful when you wish to copy part of the code of -the Library into a program that is not a library. - - 4. You may copy and distribute the Library (or a portion or -derivative of it, under Section 2) in object code or executable form -under the terms of Sections 1 and 2 above provided that you accompany -it with the complete corresponding machine-readable source code, which -must be distributed under the terms of Sections 1 and 2 above on a -medium customarily used for software interchange. - - If distribution of object code is made by offering access to copy -from a designated place, then offering equivalent access to copy the -source code from the same place satisfies the requirement to -distribute the source code, even though third parties are not -compelled to copy the source along with the object code. - - 5. A program that contains no derivative of any portion of the -Library, but is designed to work with the Library by being compiled or -linked with it, is called a "work that uses the Library". Such a -work, in isolation, is not a derivative work of the Library, and -therefore falls outside the scope of this License. - - However, linking a "work that uses the Library" with the Library -creates an executable that is a derivative of the Library (because it -contains portions of the Library), rather than a "work that uses the -library". The executable is therefore covered by this License. -Section 6 states terms for distribution of such executables. - - When a "work that uses the Library" uses material from a header file -that is part of the Library, the object code for the work may be a -derivative work of the Library even though the source code is not. -Whether this is true is especially significant if the work can be -linked without the Library, or if the work is itself a library. The -threshold for this to be true is not precisely defined by law. - - If such an object file uses only numerical parameters, data -structure layouts and accessors, and small macros and small inline -functions (ten lines or less in length), then the use of the object -file is unrestricted, regardless of whether it is legally a derivative -work. (Executables containing this object code plus portions of the -Library will still fall under Section 6.) - - Otherwise, if the work is a derivative of the Library, you may -distribute the object code for the work under the terms of Section 6. -Any executables containing that work also fall under Section 6, -whether or not they are linked directly with the Library itself. - - 6. As an exception to the Sections above, you may also combine or -link a "work that uses the Library" with the Library to produce a -work containing portions of the Library, and distribute that work -under terms of your choice, provided that the terms permit -modification of the work for the customer's own use and reverse -engineering for debugging such modifications. - - You must give prominent notice with each copy of the work that the -Library is used in it and that the Library and its use are covered by -this License. You must supply a copy of this License. If the work -during execution displays copyright notices, you must include the -copyright notice for the Library among them, as well as a reference -directing the user to the copy of this License. Also, you must do one -of these things: - - a) Accompany the work with the complete corresponding - machine-readable source code for the Library including whatever - changes were used in the work (which must be distributed under - Sections 1 and 2 above); and, if the work is an executable linked - with the Library, with the complete machine-readable "work that - uses the Library", as object code and/or source code, so that the - user can modify the Library and then relink to produce a modified - executable containing the modified Library. (It is understood - that the user who changes the contents of definitions files in the - Library will not necessarily be able to recompile the application - to use the modified definitions.) - - b) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (1) uses at run time a - copy of the library already present on the user's computer system, - rather than copying library functions into the executable, and (2) - will operate properly with a modified version of the library, if - the user installs one, as long as the modified version is - interface-compatible with the version that the work was made with. - - c) Accompany the work with a written offer, valid for at - least three years, to give the same user the materials - specified in Subsection 6a, above, for a charge no more - than the cost of performing this distribution. - - d) If distribution of the work is made by offering access to copy - from a designated place, offer equivalent access to copy the above - specified materials from the same place. - - e) Verify that the user has already received a copy of these - materials or that you have already sent this user a copy. - - For an executable, the required form of the "work that uses the -Library" must include any data and utility programs needed for -reproducing the executable from it. However, as a special exception, -the materials to be distributed need not include anything that is -normally distributed (in either source or binary form) with the major -components (compiler, kernel, and so on) of the operating system on -which the executable runs, unless that component itself accompanies -the executable. - - It may happen that this requirement contradicts the license -restrictions of other proprietary libraries that do not normally -accompany the operating system. Such a contradiction means you cannot -use both them and the Library together in an executable that you -distribute. - - 7. You may place library facilities that are a work based on the -Library side-by-side in a single library together with other library -facilities not covered by this License, and distribute such a combined -library, provided that the separate distribution of the work based on -the Library and of the other library facilities is otherwise -permitted, and provided that you do these two things: - - a) Accompany the combined library with a copy of the same work - based on the Library, uncombined with any other library - facilities. This must be distributed under the terms of the - Sections above. - - b) Give prominent notice with the combined library of the fact - that part of it is a work based on the Library, and explaining - where to find the accompanying uncombined form of the same work. - - 8. You may not copy, modify, sublicense, link with, or distribute -the Library except as expressly provided under this License. Any -attempt otherwise to copy, modify, sublicense, link with, or -distribute the Library is void, and will automatically terminate your -rights under this License. However, parties who have received copies, -or rights, from you under this License will not have their licenses -terminated so long as such parties remain in full compliance. - - 9. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Library or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Library (or any work based on the -Library), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Library or works based on it. - - 10. Each time you redistribute the Library (or any work based on the -Library), the recipient automatically receives a license from the -original licensor to copy, distribute, link with or modify the Library -subject to these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties with -this License. - - 11. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Library at all. For example, if a patent -license would not permit royalty-free redistribution of the Library by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Library. - -If any portion of this section is held invalid or unenforceable under any -particular circumstance, the balance of the section is intended to apply, -and the section as a whole is intended to apply in other circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 12. If the distribution and/or use of the Library is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Library under this License may add -an explicit geographical distribution limitation excluding those countries, -so that distribution is permitted only in or among countries not thus -excluded. In such case, this License incorporates the limitation as if -written in the body of this License. - - 13. The Free Software Foundation may publish revised and/or new -versions of the Lesser General Public License from time to time. -Such new versions will be similar in spirit to the present version, -but may differ in detail to address new problems or concerns. - -Each version is given a distinguishing version number. If the Library -specifies a version number of this License which applies to it and -"any later version", you have the option of following the terms and -conditions either of that version or of any later version published by -the Free Software Foundation. If the Library does not specify a -license version number, you may choose any version ever published by -the Free Software Foundation. - - 14. If you wish to incorporate parts of the Library into other free -programs whose distribution conditions are incompatible with these, -write to the author to ask for permission. For software which is -copyrighted by the Free Software Foundation, write to the Free -Software Foundation; we sometimes make exceptions for this. Our -decision will be guided by the two goals of preserving the free status -of all derivatives of our free software and of promoting the sharing -and reuse of software generally. - - NO WARRANTY - - 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO -WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. -EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR -OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY -KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE -LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME -THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN -WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY -AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU -FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR -CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE -LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING -RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A -FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF -SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH -DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Libraries - - If you develop a new library, and you want it to be of the greatest -possible use to the public, we recommend making it free software that -everyone can redistribute and change. You can do so by permitting -redistribution under these terms (or, alternatively, under the terms of the -ordinary General Public License). - - To apply these terms, attach the following notices to the library. It is -safest to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least the -"copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - -Also add information on how to contact you by electronic and paper mail. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the library, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the - library `Frob' (a library for tweaking knobs) written by James Random Hacker. - - , 1 April 1990 - Ty Coon, President of Vice - -That's all there is to it! - - diff --git a/src/osgPlugins/vrml/Primitives.cpp b/src/osgPlugins/vrml/Primitives.cpp deleted file mode 100644 index c2e0ef580..000000000 --- a/src/osgPlugins/vrml/Primitives.cpp +++ /dev/null @@ -1,539 +0,0 @@ -// -*-c++-*- - -#include "ReaderWriterVRML2.h" - -#include - -#if defined(_MSC_VER) -# pragma warning(disable: 4250) -# pragma warning(disable: 4290) -# pragma warning(disable: 4800) -#endif - -#include - -#include - -osg::ref_ptr ReaderWriterVRML2::convertVRML97IndexedLineSet(openvrml::node *vrml_ifs) const -{ - osg::ref_ptr osg_geom = new deprecated_osg::Geometry(); - - osg_geom->addPrimitiveSet(new osg::DrawArrayLengths(osg::PrimitiveSet::LINE_STRIP)); - - // get array of vertex coordinate_nodes - if(vrml_ifs->type().id() == "IndexedLineSet") - { - std::auto_ptr fv = vrml_ifs->field("coord"); - const openvrml::sfnode *sfn = dynamic_cast(fv.get()); - - openvrml::coordinate_node *vrml_coord_node = dynamic_cast((sfn->value()).get()); - const std::vector &vrml_coord = vrml_coord_node->point(); - - osg::ref_ptr osg_vertices = new osg::Vec3Array(); - - unsigned i; - for (i = 0; i < vrml_coord.size(); i++) - { - openvrml::vec3f vec = vrml_coord[i]; - osg_vertices->push_back(osg::Vec3(vec[0], vec[1], vec[2])); - } - - osg_geom->setVertexArray(osg_vertices.get()); - - // get array of vertex indices - std::auto_ptr fv2 = vrml_ifs->field("coordIndex"); - const openvrml::mfint32 *vrml_coord_index = dynamic_cast(fv2.get()); - - osg::ref_ptr osg_vert_index = new osg::IntArray(); - - int num_vert = 0; - for (i = 0; i < vrml_coord_index->value().size(); i++) - { - int index = vrml_coord_index->value()[i]; - if (index == -1) - { - static_cast(osg_geom->getPrimitiveSet(0))->push_back(num_vert); - num_vert = 0; - } - else - { - osg_vert_index->push_back(index); - ++num_vert; - } - } - - if (num_vert) - { - //GvdB: Last coordIndex wasn't -1 - static_cast(osg_geom->getPrimitiveSet(0))->push_back(num_vert); - } - - osg_geom->setVertexIndices(osg_vert_index.get()); - } - - // get array of colours per vertex (if specified) - { - std::auto_ptr fv = vrml_ifs->field("color"); - const openvrml::sfnode *sfn = dynamic_cast(fv.get()); - openvrml::color_node *vrml_color_node = dynamic_cast(sfn->value().get()); - - if (vrml_color_node != 0) // if no colors, node is NULL pointer - { - const std::vector &vrml_colors = vrml_color_node->color(); - - osg::ref_ptr osg_colors = new osg::Vec3Array(); - - unsigned i; - for (i = 0; i < vrml_colors.size(); i++) - { - const openvrml::color color = vrml_colors[i]; - osg_colors->push_back(osg::Vec3(color.r(), color.g(), color.b())); - } - osg_geom->setColorArray(osg_colors.get()); - - // get array of color indices - std::auto_ptr fv2 = vrml_ifs->field("colorIndex"); - const openvrml::mfint32 *vrml_color_index = dynamic_cast(fv2.get()); - - osg::ref_ptr osg_color_index = new osg::IntArray(); - - if(vrml_color_index->value().size() > 0) - { - for (i = 0; i < vrml_color_index->value().size(); i++) - { - int index = vrml_color_index->value()[i]; - if (index != -1) { - osg_color_index->push_back(index); - } - } - osg_geom->setColorIndices(osg_color_index.get()); - } else - // unspecified, use coordIndices field - osg_geom->setColorIndices(const_cast(osg_geom->getVertexIndices())); - - // get color binding - std::auto_ptr fv3 = vrml_ifs->field("colorPerVertex"); - const openvrml::sfbool *vrml_color_per_vertex = dynamic_cast(fv3.get()); - - if (vrml_color_per_vertex->value()) - { - osg_geom->setColorBinding(deprecated_osg::Geometry::BIND_PER_VERTEX); - } else - { - osg_geom->setColorBinding(deprecated_osg::Geometry::BIND_PER_PRIMITIVE); - } - } - } - - osg_geom->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF); - - return osg_geom; -} - -osg::ref_ptr ReaderWriterVRML2::convertVRML97Box(openvrml::node* vrml_box) const -{ - std::auto_ptr fv = vrml_box->field("size"); - const openvrml::vec3f &size = static_cast (fv.get())->value(); - - osg::Vec3 halfSize(size[0] * 0.5f, size[1] * 0.5f, size[2] * 0.5f); - - BoxLibrary::const_iterator it = m_boxLibrary.find(halfSize); - if (it != m_boxLibrary.end()) - { - return (*it).second.get(); - } - - osg::ref_ptr osg_geom = new deprecated_osg::Geometry(); - osg::ref_ptr osg_vertices = new osg::Vec3Array(); - osg::ref_ptr osg_texcoords = new osg::Vec2Array(); - osg::ref_ptr osg_normals = new osg::Vec3Array(); - - osg::ref_ptr box = new osg::DrawArrays(osg::PrimitiveSet::QUADS); - - osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], halfSize[2])); - - osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], -halfSize[2])); - - osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], -halfSize[2])); - - osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], halfSize[2])); - - osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], -halfSize[2])); - - osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], halfSize[2])); - osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], -halfSize[2])); - osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], halfSize[2])); - - for (int i = 0; i != 6; ++i) - { - osg_texcoords->push_back(osg::Vec2(0.0f, 1.0f)); - osg_texcoords->push_back(osg::Vec2(0.0f, 0.0f)); - osg_texcoords->push_back(osg::Vec2(1.0f, 0.0f)); - osg_texcoords->push_back(osg::Vec2(1.0f, 1.0f)); - } - - osg_normals->push_back(osg::Vec3(0.0f, 0.0f, 1.0f)); - osg_normals->push_back(osg::Vec3(0.0f, 0.0f, -1.0f)); - osg_normals->push_back(osg::Vec3(1.0f, 0.0f, 0.0f)); - osg_normals->push_back(osg::Vec3(-1.0f, 0.0f, 0.0f)); - osg_normals->push_back(osg::Vec3(0.0f, 1.0f, 0.0f)); - osg_normals->push_back(osg::Vec3(0.0f, -1.0f, 0.0f)); - - box->setCount(osg_vertices->size()); - - osg_geom->addPrimitiveSet(box.get()); - - osg_geom->setVertexArray(osg_vertices.get()); - osg_geom->setTexCoordArray(0, osg_texcoords.get()); - osg_geom->setNormalArray(osg_normals.get()); - osg_geom->setNormalBinding(deprecated_osg::Geometry::BIND_PER_PRIMITIVE); - - osg_geom->getOrCreateStateSet()->setAttributeAndModes(new osg::CullFace(osg::CullFace::BACK)); - - m_boxLibrary[halfSize] = osg_geom; - - return osg_geom.get(); -} - -osg::ref_ptr ReaderWriterVRML2::convertVRML97Sphere(openvrml::node* vrml_sphere) const -{ - std::auto_ptr fv = vrml_sphere->field("radius"); - const float radius = static_cast (fv.get())->value(); - - SphereLibrary::const_iterator it = m_sphereLibrary.find(radius); - if (it != m_sphereLibrary.end()) - { - return (*it).second.get(); - } - - osg::ref_ptr osg_geom = new osg::Geometry(); - osg::ref_ptr osg_vertices = new osg::Vec3Array(); - osg::ref_ptr osg_texcoords = new osg::Vec2Array(); - osg::ref_ptr osg_normals = new osg::Vec3Array(); - - unsigned int numSegments = 40; - unsigned int numRows = 20; - - const float thetaDelta = 2.0f * float(osg::PI) / float(numSegments); - const float texCoordSDelta = 1.0f / float(numSegments); - const float phiDelta = float(osg::PI) / float(numRows); - const float texCoordTDelta = 1.0f / float(numRows); - - float phi = -0.5f * float(osg::PI); - float texCoordT = 0.0f; - - osg::ref_ptr sphere = new osg::DrawArrayLengths(osg::PrimitiveSet::QUAD_STRIP); - - for (unsigned int i = 0; i < numRows; ++i, phi += phiDelta, texCoordT += texCoordTDelta) - { - std::complex latBottom = std::polar(1.0f, phi); - std::complex latTop = std::polar(1.0f, phi + phiDelta); - std::complex eBottom = latBottom * radius; - std::complex eTop = latTop * radius; - - float theta = 0.0f; - float texCoordS = 0.0f; - - for (unsigned int j = 0; j < numSegments; ++j, theta += thetaDelta, texCoordS += texCoordSDelta) - { - std::complex n = -std::polar(1.0f, theta); - - osg_normals->push_back(osg::Vec3(latTop.real() * n.imag(), latTop.imag(), latTop.real() * n.real())); - osg_normals->push_back(osg::Vec3(latBottom.real() * n.imag(), latBottom.imag(), latBottom.real() * n.real())); - - osg_texcoords->push_back(osg::Vec2(texCoordS, texCoordT + texCoordTDelta)); - osg_texcoords->push_back(osg::Vec2(texCoordS, texCoordT)); - - osg_vertices->push_back(osg::Vec3(eTop.real() * n.imag(), eTop.imag(), eTop.real() * n.real())); - osg_vertices->push_back(osg::Vec3(eBottom.real() * n.imag(), eBottom.imag(), eBottom.real() * n.real())); - } - - osg_normals->push_back(osg::Vec3(0.0f, latTop.imag(), -latTop.real())); - osg_normals->push_back(osg::Vec3(0.0f, latBottom.imag(), -latBottom.real())); - - osg_texcoords->push_back(osg::Vec2(1.0f, texCoordT + texCoordTDelta)); - osg_texcoords->push_back(osg::Vec2(1.0f, texCoordT)); - - osg_vertices->push_back(osg::Vec3(0.0f, eTop.imag(), -eTop.real())); - osg_vertices->push_back(osg::Vec3(0.0f, eBottom.imag(), -eBottom.real())); - - sphere->push_back(numSegments * 2 + 2); - } - - osg_geom->addPrimitiveSet(sphere.get()); - - osg_geom->setVertexArray(osg_vertices.get()); - osg_geom->setTexCoordArray(0, osg_texcoords.get()); - osg_geom->setNormalArray(osg_normals.get(), osg::Array::BIND_PER_VERTEX); - - osg_geom->getOrCreateStateSet()->setAttributeAndModes(new osg::CullFace(osg::CullFace::BACK)); - - m_sphereLibrary[radius] = osg_geom; - - return osg_geom.get(); -} - -osg::ref_ptr ReaderWriterVRML2::convertVRML97Cone(openvrml::node* vrml_cone) const -{ - float height = static_cast(vrml_cone->field("height").get())->value(); - float radius = static_cast(vrml_cone->field("bottomRadius").get())->value(); - bool bottom = static_cast(vrml_cone->field("bottom").get())->value(); - bool side = static_cast(vrml_cone->field("side").get())->value(); - - QuadricKey key(height, radius, bottom, side, false); - - ConeLibrary::const_iterator it = m_coneLibrary.find(key); - if (it != m_coneLibrary.end()) - { - return (*it).second.get(); - } - - osg::ref_ptr osg_geom = new osg::Geometry(); - osg::ref_ptr osg_vertices = new osg::Vec3Array(); - osg::ref_ptr osg_texcoords = new osg::Vec2Array(); - osg::ref_ptr osg_normals = new osg::Vec3Array(); - - unsigned int numSegments = 40; - - const float thetaDelta = 2.0f * float(osg::PI) / float(numSegments); - - float topY = height * 0.5f; - float bottomY = height * -0.5f; - - if (side) - { - osg::ref_ptr side = new osg::DrawArrays(osg::PrimitiveSet::QUAD_STRIP); - - const float texCoordDelta = 1.0f / float(numSegments); - float theta = 0.0f; - float texCoord = 0.0f; - - for (unsigned int i = 0; i < numSegments; ++i, theta += thetaDelta, texCoord += texCoordDelta) - { - std::complex n = -std::polar(1.0f, theta); - std::complex e = n * radius; - - osg::Vec3 normal(n.imag() * height, radius, n.real() * height); - normal.normalize(); - - osg_normals->push_back(normal); - osg_normals->push_back(normal); - - osg_texcoords->push_back(osg::Vec2(texCoord, 1.0f)); - osg_texcoords->push_back(osg::Vec2(texCoord, 0.0f)); - - osg_vertices->push_back(osg::Vec3(0.0f, topY, 0.0f)); - osg_vertices->push_back(osg::Vec3(e.imag(), bottomY, e.real())); - } - - // do last point by hand to ensure no round off errors. - - osg::Vec3 normal(0.0f, radius, -height); - normal.normalize(); - - osg_normals->push_back(normal); - osg_normals->push_back(normal); - - osg_texcoords->push_back(osg::Vec2(1.0f, 1.0f)); - osg_texcoords->push_back(osg::Vec2(1.0f, 0.0f)); - - osg_vertices->push_back(osg::Vec3(0.0f, topY, 0.0f)); - osg_vertices->push_back(osg::Vec3(0.0f, bottomY, -radius)); - - side->setCount(osg_vertices->size()); - osg_geom->addPrimitiveSet(side.get()); - } - - if (bottom) - { - osg::ref_ptr bottom = new osg::DrawArrays(osg::PrimitiveSet::TRIANGLE_FAN); - - size_t first = osg_vertices->size(); - bottom->setFirst(first); - - float theta = 0.0f; - - for (unsigned int i = 0; i < numSegments; ++i, theta += thetaDelta) - { - std::complex n = -std::polar(1.0f, theta); - std::complex e = n * radius; - - osg_normals->push_back(osg::Vec3(0.0f, -1.0f, 0.0f)); - osg_texcoords->push_back(osg::Vec2(0.5f - 0.5f * n.imag(), 0.5f + 0.5f * n.real())); - osg_vertices->push_back(osg::Vec3(-e.imag(), bottomY, e.real())); - } - - // do last point by hand to ensure no round off errors. - - osg_normals->push_back(osg::Vec3(0.0f, -1.0f, 0.0f)); - osg_texcoords->push_back(osg::Vec2(0.5f, 0.0f)); - osg_vertices->push_back(osg::Vec3(0.0f, bottomY, -radius)); - - bottom->setCount(osg_vertices->size() - first); - osg_geom->addPrimitiveSet(bottom.get()); - } - - osg_geom->setVertexArray(osg_vertices.get()); - osg_geom->setTexCoordArray(0, osg_texcoords.get()); - osg_geom->setNormalArray(osg_normals.get(), osg::Array::BIND_PER_VERTEX); - - osg_geom->getOrCreateStateSet()->setAttributeAndModes(new osg::CullFace(osg::CullFace::BACK)); - - m_coneLibrary[key] = osg_geom; - - return osg_geom.get(); -} - -osg::ref_ptr ReaderWriterVRML2::convertVRML97Cylinder(openvrml::node* vrml_cylinder) const -{ - float height = static_cast(vrml_cylinder->field("height").get())->value(); - float radius = static_cast(vrml_cylinder->field("radius").get())->value(); - bool bottom = static_cast(vrml_cylinder->field("bottom").get())->value(); - bool side = static_cast(vrml_cylinder->field("side").get())->value(); - bool top = static_cast(vrml_cylinder->field("top").get())->value(); - - QuadricKey key(height, radius, bottom, side, top); - - CylinderLibrary::const_iterator it = m_cylinderLibrary.find(key); - if (it != m_cylinderLibrary.end()) - { - return (*it).second.get(); - } - - osg::ref_ptr osg_geom = new osg::Geometry(); - osg::ref_ptr osg_vertices = new osg::Vec3Array(); - osg::ref_ptr osg_texcoords = new osg::Vec2Array(); - osg::ref_ptr osg_normals = new osg::Vec3Array(); - - unsigned int numSegments = 40; - - const float thetaDelta = 2.0f * float(osg::PI) / float(numSegments); - - float topY = height * 0.5f; - float bottomY = height * -0.5f; - - if (side) - { - osg::ref_ptr side = new osg::DrawArrays(osg::PrimitiveSet::QUAD_STRIP); - - const float texCoordDelta = 1.0f / float(numSegments); - float theta = 0.0f; - float texCoord = 0.0f; - - for (unsigned int i = 0; i < numSegments; ++i, theta += thetaDelta, texCoord += texCoordDelta) - { - std::complex n = -std::polar(1.0f, theta); - std::complex e = n * radius; - - osg::Vec3 normal(n.imag(), 0.0f, n.real()); - - osg_normals->push_back(normal); - osg_normals->push_back(normal); - - osg_texcoords->push_back(osg::Vec2(texCoord, 1.0f)); - osg_texcoords->push_back(osg::Vec2(texCoord, 0.0f)); - - osg_vertices->push_back(osg::Vec3(e.imag(), topY, e.real())); - osg_vertices->push_back(osg::Vec3(e.imag(), bottomY, e.real())); - } - - // do last point by hand to ensure no round off errors. - - osg::Vec3 normal(0.0f, 0.0f, -1.0f); - osg_normals->push_back(normal); - osg_normals->push_back(normal); - - osg_texcoords->push_back(osg::Vec2(1.0f, 1.0f)); - osg_texcoords->push_back(osg::Vec2(1.0f, 0.0f)); - - osg_vertices->push_back(osg::Vec3(0.0f, topY, -radius)); - osg_vertices->push_back(osg::Vec3(0.0f, bottomY, -radius)); - - side->setCount(osg_vertices->size()); - osg_geom->addPrimitiveSet(side.get()); - } - - if (bottom) - { - osg::ref_ptr bottom = new osg::DrawArrays(osg::PrimitiveSet::TRIANGLE_FAN); - - size_t first = osg_vertices->size(); - bottom->setFirst(first); - - float theta = 0.0f; - - for (unsigned int i = 0; i < numSegments; ++i, theta += thetaDelta) - { - std::complex n = -std::polar(1.0f, theta); - std::complex e = n * radius; - - osg_normals->push_back(osg::Vec3(0.0f, -1.0f, 0.0f)); - osg_texcoords->push_back(osg::Vec2(0.5f - 0.5f * n.imag(), 0.5f + 0.5f * n.real())); - osg_vertices->push_back(osg::Vec3(-e.imag(), bottomY, e.real())); - } - - // do last point by hand to ensure no round off errors. - - osg_normals->push_back(osg::Vec3(0.0f, -1.0f, 0.0f)); - osg_texcoords->push_back(osg::Vec2(0.5f, 0.0f)); - osg_vertices->push_back(osg::Vec3(0.0f, bottomY, -radius)); - - bottom->setCount(osg_vertices->size() - first); - osg_geom->addPrimitiveSet(bottom.get()); - } - - if (top) - { - osg::ref_ptr top = new osg::DrawArrays(osg::PrimitiveSet::TRIANGLE_FAN); - - size_t first = osg_vertices->size(); - top->setFirst(first); - - float theta = 0.0f; - - for (unsigned int i = 0; i < numSegments; ++i, theta += thetaDelta) - { - std::complex n = -std::polar(1.0f, theta); - std::complex e = n * radius; - - osg_normals->push_back(osg::Vec3(0.0f, 1.0f, 0.0f)); - osg_texcoords->push_back(osg::Vec2(0.5f + 0.5f * n.imag(), 0.5f - 0.5f * n.real())); - osg_vertices->push_back(osg::Vec3(e.imag(), topY, e.real())); - } - - // do last point by hand to ensure no round off errors. - - osg_normals->push_back(osg::Vec3(0.0f, 1.0f, 0.0f)); - osg_texcoords->push_back(osg::Vec2(0.5f, 1.0f)); - osg_vertices->push_back(osg::Vec3(0.0f, topY, -radius)); - - top->setCount(osg_vertices->size() - first); - osg_geom->addPrimitiveSet(top.get()); - } - - osg_geom->setVertexArray(osg_vertices.get()); - osg_geom->setTexCoordArray(0, osg_texcoords.get()); - osg_geom->setNormalArray(osg_normals.get(), osg::Array::BIND_PER_VERTEX); - - osg_geom->getOrCreateStateSet()->setAttributeAndModes(new osg::CullFace(osg::CullFace::BACK)); - - m_cylinderLibrary[key] = osg_geom; - - return osg_geom.get(); -} diff --git a/src/osgPlugins/vrml/README.txt b/src/osgPlugins/vrml/README.txt deleted file mode 100644 index 078b5666c..000000000 --- a/src/osgPlugins/vrml/README.txt +++ /dev/null @@ -1,14 +0,0 @@ -######################################################## -# Replacement VRML plugin for OpenSceneGraph. # -# (C) J.Ciger B.Herbelin T.Abaci 2003,2004 VRlab EPFL # -######################################################## - -- dependencies: - OpenVRML (http://openvrml.org/) - Boost (http://www.boost.org/) - OpenSceneGraph (http://www.openscenegraph.org/) - -CAUTION! -This version of the plugin requires OpenVRML 0.17.12 and Boost 1.38. -Older version *may* work, but were not tested! - diff --git a/src/osgPlugins/vrml/ReaderWriterVRML2.cpp b/src/osgPlugins/vrml/ReaderWriterVRML2.cpp deleted file mode 100644 index 7b7b782c7..000000000 --- a/src/osgPlugins/vrml/ReaderWriterVRML2.cpp +++ /dev/null @@ -1,651 +0,0 @@ -// -*-c++-*- - -/* - * - * VRML2 file converter for OpenSceneGraph. - * - * authors : - * Johan Nouvel (johan_nouvel@yahoo.com) for the writeNode function. - * - * Jan Ciger (jan.ciger@gmail.com), - * Tolga Abaci (tolga.abaci@gmail.com), - * Bruno Herbelin (bruno.herbelin@gmail.com) - * - * (c) VRlab EPFL, Switzerland, 2004-2006 - * - * Gino van den Bergen, DTECTA (gino@dtecta.com) - * Xiangxian Wang (xiangxianwang@yahoo.com.cn) - * - */ - -#include "ReaderWriterVRML2.h" -#include "ConvertToVRML.h" - -#include -#include - -#include -#include - -#if defined(_MSC_VER) -# pragma warning(disable: 4250) -# pragma warning(disable: 4290) -# pragma warning(disable: 4800) -#endif - -#include -#include - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include -#include - -// ------------------------------------------------------------------------------------- -// OpenVRML helper class -// ------------------------------------------------------------------------------------- -class resource_fetcher: public openvrml::resource_fetcher -{ - private: - virtual std::auto_ptr do_get_resource(const std::string & uri) - { - using std::auto_ptr; - using std::invalid_argument; - using std::string; - using openvrml::resource_istream; - - class file_resource_istream: public resource_istream - { - std::string url_; - std::filebuf buf_; - - public: - explicit file_resource_istream(const std::string & path) : - resource_istream(&this->buf_) - { - // - // Note that the failbit is set in the constructor if no data - // can be read from the stream. This is important. If the - // failbit is not set on such a stream, OpenVRML will attempt - // to read data from a stream that cannot provide it. - // - if (!this->buf_.open(path.c_str(), ios_base::in | ios_base::binary)) - { - this->setstate(ios_base::badbit); - } - } - - void url(const std::string & str) throw (std::bad_alloc) - { - this->url_ = str; - } - - private: - virtual const std::string do_url() const throw () - { - return this->url_; - } - - virtual const std::string do_type() const throw () - { - // - // A real application should use OS facilities for this; - // however, that is beyond the scope of this example (which - // is intended to be portable and stupid). - // - using std::find; - using std::string; - using boost::algorithm::iequals; - string media_type = "application/octet-stream"; - - const string::const_reverse_iterator dot_pos = find(this->url_.rbegin(), this->url_.rend(), '.'); - if (dot_pos == this->url_.rend() || boost::next(dot_pos.base()) == this->url_.end()) - { - return media_type; - } - - const string::const_iterator hash_pos = find(boost::next(dot_pos.base()), this->url_.end(), '#'); - const string ext(dot_pos.base(), hash_pos); - - if (iequals(ext, "wrl") || iequals(ext, "vrml")) - { - media_type = "model/vrml"; - } - else if (iequals(ext, "png")) - { - media_type = "image/png"; - } - else if (iequals(ext, "jpg") || iequals(ext, "jpeg")) - { - media_type = "image/jpeg"; - } - return media_type; - } - - virtual bool do_data_available() const throw () - { - return !!(*this); - } - }; - - const string scheme = uri.substr(0, uri.find_first_of(':')); - if (scheme != "file") - { - throw invalid_argument('\"' + scheme + "\" URI scheme not " - "supported"); - } - // - // file:// - // ^ - // 01234567 - // - string path = uri.substr(uri.find_first_of('/', 7)); - - auto_ptr in(new file_resource_istream(path)); - static_cast (in.get())->url(uri); - - return in; - } -}; - -// ------------------------------------------------------------------------------------- - - -// Register with Registry to instantiate the above reader/writer. -REGISTER_OSGPLUGIN(vrml, ReaderWriterVRML2) - -osgDB::ReaderWriter::ReadResult ReaderWriterVRML2::readNode(const std::string& fname, const osgDB::Options* opt) const -{ - std::string fileName = osgDB::findDataFile(fname, opt); - if (fileName.empty()) - return ReadResult::FILE_NOT_FOUND; - - std::fstream null; - resource_fetcher fetcher; - openvrml::browser *b = new openvrml::browser(fetcher, null, null); - - osgDB::ifstream vrml_stream(fileName.c_str()); - if (!vrml_stream.is_open()) - { - OSG_INFO << "ReaderWriterVRML2: Could not open \"" << fileName << "\"" << std::endl; - return ReadResult::FILE_NOT_FOUND; - } - - try - { - const std::vector< boost::intrusive_ptr< openvrml::node > > & mfn = b->create_vrml_from_stream(vrml_stream); - - if(mfn.empty()) - { - OSG_INFO << "ReaderWriterVRML2: OpenVRML library did not return any vrml nodes." << std::endl; - return ReadResult::FILE_NOT_HANDLED; - } - else - { - osg::ref_ptr osg_root = new osg::MatrixTransform(osg::Matrix( 1, 0, 0, 0, - 0, 0, 1, 0, - 0, -1, 0, 0, - 0, 0, 0, 1)); - - osgDB::getDataFilePathList().push_front(osgDB::getFilePath(fileName)); - for (unsigned i = 0; i < mfn.size(); i++) - { - openvrml::node *vrml_node = mfn[i].get(); - osg_root->addChild(convertFromVRML(vrml_node)); - } - osgDB::getDataFilePathList().pop_front(); - return osg_root.get(); - } - } - - catch (const openvrml::invalid_vrml& e) - { - OSG_INFO << "ReaderWriterVRML2: Invalid VRML in line " << e.line << " at column " << e.column << ": \"" << e.what() << "\"" << std::endl; - return ReadResult::FILE_NOT_HANDLED; - } - catch (const std::invalid_argument& e) - { - OSG_INFO << "ReaderWriterVRML2: Invalid argument: \"" << e.what() << "\"" << std::endl; - return ReadResult::FILE_NOT_HANDLED; - } -} - -osgDB::ReaderWriter::WriteResult ReaderWriterVRML2::writeNode(const osg::Node& root,const std::string& filename, const osgDB::ReaderWriter::Options *options) const -{ - std::string ext = osgDB::getLowerCaseFileExtension(filename); - if (!acceptsExtension(ext)) return WriteResult::FILE_NOT_HANDLED; - - - osg::notify(osg::INFO) << "osgDB::ReaderWriterVRML::writeNode() Writing file " - << filename << std::endl; - - return(convertToVRML(root,filename,options)); -} - - - - -osg::Node* ReaderWriterVRML2::convertFromVRML(openvrml::node *obj) const -{ - //static int osgLightNum = 0; //light - - if (obj->type().id() == "Group") // Group node - - { - osg::ref_ptr osg_group = new osg::Group; - - if (!obj->id().empty()) - osg_group->setName(obj->id()); - - try - { - std::auto_ptr fv = obj->field("children"); - - if ( fv->type() == openvrml::field_value::mfnode_id ) - { - const openvrml::mfnode* mfn = dynamic_cast(fv.get()); - openvrml::mfnode::value_type node_ptr_vector = mfn->value(); - openvrml::mfnode::value_type::iterator it_npv; - - for (it_npv = node_ptr_vector.begin(); it_npv != node_ptr_vector.end(); it_npv++) - { - openvrml::node *node = (*(it_npv)).get(); - osg_group->addChild(convertFromVRML(node)); - } - } - } - catch (openvrml::unsupported_interface&) - { - // no children - } - - return osg_group.release(); - - } - - else if (obj->type().id() == "Transform") // Handle transforms - - { - openvrml::transform_node *vrml_transform; - vrml_transform = dynamic_cast(obj); - - openvrml::mat4f vrml_m = vrml_transform->transform(); - osg::ref_ptr osg_m = new osg::MatrixTransform(osg::Matrix(vrml_m[0][0], vrml_m[0][1], vrml_m[0][2], vrml_m[0][3], vrml_m[1][0], vrml_m[1][1], vrml_m[1][2], vrml_m[1][3], vrml_m[2][0], vrml_m[2][1], vrml_m[2][2], vrml_m[2][3], vrml_m[3][0], vrml_m[3][1], vrml_m[3][2], vrml_m[3][3])); - - if (!obj->id().empty()) - osg_m->setName(obj->id()); - - try - { - std::auto_ptr fv = obj->field("children"); - - if ( fv->type() == openvrml::field_value::mfnode_id ) - { - const openvrml::mfnode* mfn = dynamic_cast(fv.get()); - openvrml::mfnode::value_type node_ptr_vector = mfn->value(); - openvrml::mfnode::value_type::iterator it_npv; - - for (it_npv = node_ptr_vector.begin(); it_npv != node_ptr_vector.end(); it_npv++) - { - openvrml::node *node = (*(it_npv)).get(); - osg_m->addChild(convertFromVRML(node)); - } - } - } - catch (openvrml::unsupported_interface&) - { - // no children - } - - return osg_m.release(); - - } - - else if ((obj->type()).id() == "Shape") // Handle Shape node - - { - osg::ref_ptr osg_geom; - - // parse the geometry - { - std::auto_ptr fv = obj->field("geometry"); - - if (fv->type() == openvrml::field_value::sfnode_id) - { - const openvrml::sfnode * sfn = dynamic_cast(fv.get()); - openvrml::sfnode::value_type node_ptr = sfn->value(); - - if (node_ptr.get()) { - // is it indexed_face_set_node ? - if (node_ptr->type().id()=="IndexedFaceSet") - osg_geom = convertVRML97IndexedFaceSet(node_ptr.get()); - - else if (node_ptr->type().id()=="IndexedLineSet") - osg_geom = convertVRML97IndexedLineSet(node_ptr.get()); - - else if (node_ptr->type().id() == "Box") - osg_geom = convertVRML97Box(node_ptr.get()); - - else if (node_ptr->type().id() == "Sphere") - osg_geom = convertVRML97Sphere(node_ptr.get()); - - else if (node_ptr->type().id() == "Cone") - osg_geom = convertVRML97Cone(node_ptr.get()); - - else if (node_ptr->type().id() == "Cylinder") - osg_geom = convertVRML97Cylinder(node_ptr.get()); - - else - { - // other geometry types not handled yet - } - - if (osg_geom.valid() && !node_ptr->id().empty()) - osg_geom->setName(node_ptr->id()); - } - } - } - - osg::ref_ptr osg_geode = new osg::Geode(); - if (!obj->id().empty()) - osg_geode->setName(obj->id()); - osg_geode->addDrawable(osg_geom.get()); - osg::StateSet *osg_stateset = osg_geode->getOrCreateStateSet(); - - osg::ref_ptr osg_mat = new osg::Material(); - osg_stateset->setAttributeAndModes(osg_mat.get()); - osg_mat->setColorMode(osg::Material::AMBIENT_AND_DIFFUSE); - - // parse the appearance - { - std::auto_ptr fv = obj->field("appearance"); - - if (fv->type() == openvrml::field_value::sfnode_id) - { - const openvrml::sfnode *sfn = dynamic_cast(fv.get()); - openvrml::appearance_node *vrml_app = dynamic_cast(sfn->value().get()); - - const boost::intrusive_ptr vrml_material_node = vrml_app->material(); - const boost::intrusive_ptr vrml_texture_node = openvrml::node_cast(vrml_app->texture().get()); - const openvrml::material_node *vrml_material = dynamic_cast(vrml_material_node.get()); - - if (vrml_material != NULL) - { - osg_mat->setAmbient(osg::Material::FRONT_AND_BACK, - osg::Vec4(vrml_material->ambient_intensity(), - vrml_material->ambient_intensity(), - vrml_material->ambient_intensity(), - 1.0)); - osg_mat->setDiffuse(osg::Material::FRONT_AND_BACK, - osg::Vec4(vrml_material->diffuse_color().r(), - vrml_material->diffuse_color().g(), - vrml_material->diffuse_color().b(), - 1.0)); - osg_mat->setEmission(osg::Material::FRONT_AND_BACK, - osg::Vec4(vrml_material->emissive_color().r(), - vrml_material->emissive_color().g(), - vrml_material->emissive_color().b(), - 1.0)); - osg_mat->setSpecular(osg::Material::FRONT_AND_BACK, - osg::Vec4(vrml_material->specular_color().r(), - vrml_material->specular_color().g(), - vrml_material->specular_color().b(), - 1.0)); - - osg_mat->setShininess(osg::Material::FRONT_AND_BACK, vrml_material->shininess() ); - - if (vrml_material->transparency() > 0.0f) - { - osg_mat->setTransparency(osg::Material::FRONT_AND_BACK, vrml_material->transparency()); - osg_stateset->setMode(GL_BLEND, osg::StateAttribute::ON); - osg_stateset->setAttribute(new osg::Depth(osg::Depth::LESS, 0.0, 1.0, false)); // GvdB: transparent objects do not write depth - osg_stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN); - } - else - { - osg_stateset->setMode(GL_BLEND, osg::StateAttribute::OFF); - osg_stateset->setRenderingHint(osg::StateSet::OPAQUE_BIN); - } - - osg_stateset->setAttributeAndModes(osg_mat.get()); - - } - - // if texture is provided - if (vrml_texture_node != 0) - { - osg::ref_ptr image; - - if (vrml_texture_node->type().id() == "ImageTexture") - { - try - { - std::auto_ptr texture_url_fv = vrml_texture_node->field("url"); - const openvrml::mfstring *mfs = dynamic_cast(texture_url_fv.get()); - const std::string &url = mfs->value()[0]; - - image = osgDB::readRefImageFile(url); - - if (!image.valid()) - { - std::cerr << "texture file " << url << " not found !" << std::endl << std::flush; - } - } - catch (openvrml::unsupported_interface&) - { - // no url field in the texture - } - } - - if (!image.valid()) - { - // If we cannot read the image try the openvrml builtin mechanisms to read the image. - // This includes PixelTexture fields. - const openvrml::image& vrml_image = vrml_texture_node->image(); - - // Convert to an osg image - image = new osg::Image; - image->allocateImage(vrml_image.x(), vrml_image.y(), 1, GL_RGBA, GL_UNSIGNED_BYTE); - for (std::size_t y = 0; y < vrml_image.y(); ++y) - { - for (std::size_t x = 0; x < vrml_image.x(); ++x) - { - openvrml::int32 p = vrml_image.pixel(x, y); - unsigned char* data = image->data(x, y); - data[0] = 0xff & (p >> 24); - data[1] = 0xff & (p >> 16); - data[2] = 0xff & (p >> 8); - data[3] = 0xff & (p >> 0); - } - } - } - - if (image.valid()) - { - osg::ref_ptr texture = new osg::Texture2D; - texture->setImage(image.get()); - - // get the real texture wrapping parameters - if (vrml_texture_node->repeat_s()) - { - texture->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT); - } - else - { - texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP); - } - - if (vrml_texture_node->repeat_t()) - { - texture->setWrap(osg::Texture::WRAP_T, osg::Texture::REPEAT); - } - else - { - texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP); - } - texture->setWrap(osg::Texture::WRAP_R, osg::Texture::REPEAT); - - osg_stateset->setTextureAttributeAndModes(0, texture.get()); - - if (image->isImageTranslucent()) { - osg_stateset->setMode(GL_BLEND, osg::StateAttribute::ON); - osg_stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN); - } - } - } - } - } - - return osg_geode.release(); - } - else - { - return 0; - } -#if 0 - /* - } else if(obj->type.id == "DirectionalLight") // Handle lights - { - osg::Group* lightGroup = new osg::Group; - - openvrml::vrml97_node::directional_light_node *vrml_light; - vrml_light = dynamic_cast(obj); - - // create light with global params - osg::Light* myLight = new osg::Light; - myLight->setLightNum(osgLightNum); - myLight->setAmbient(osg::Vec4(vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity())); - float osgR = vrml_light->color().r()*vrml_light->intensity(); - float osgG = vrml_light->color().g()*vrml_light->intensity(); - float osgB = vrml_light->color().b()*vrml_light->intensity(); - myLight->setDiffuse(osg::Vec4(osgR, osgG, osgB, 1.0f)); - myLight->setSpecular(osg::Vec4(osgR, osgG, osgB, 1.0f)); - - // configure light as DIRECTIONAL - openvrml::sfvec3f &dir = vrml_light->direction_; - myLight->setDirection(osg::Vec3(dir.value[0],dir.value[1],dir.value[2])); - myLight->setPosition(osg::Vec4(dir.value[0],dir.value[1],dir.value[2], 0.0f)); - - // add the light in the scenegraph - osg::LightSource* lightS = new osg::LightSource; - lightS->setLight(myLight); - if (vrml_light->on()) { - lightS->setLocalStateSetModes(osg::StateAttribute::ON); - //lightS->setStateSetModes(*rootStateSet,osg::StateAttribute::ON); - } - - lightGroup->addChild(lightS); - osgLightNum++; - - return lightGroup; - - } else if(obj->type.id == "PointLight") // Handle lights - { - osg::Group* lightGroup = new osg::Group; - - openvrml::vrml97_node::point_light_node *vrml_light; - vrml_light = dynamic_cast(obj); - - // create light with global params - osg::Light* myLight = new osg::Light; - myLight->setLightNum(osgLightNum); - //std::cout<<"lightnum = "<location_; - myLight->setPosition(osg::Vec4(pos.value[0], pos.value[1], pos.value[2], 1.0f)); - - myLight->setAmbient(osg::Vec4(vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity())); - float osgR = vrml_light->color().r()*vrml_light->intensity(); - float osgG = vrml_light->color().g()*vrml_light->intensity(); - float osgB = vrml_light->color().b()*vrml_light->intensity(); - myLight->setDiffuse(osg::Vec4(osgR, osgG, osgB, 1.0f)); - myLight->setSpecular(osg::Vec4(osgR, osgG, osgB, 1.0f)); - - // configure light as POINT - myLight->setDirection(osg::Vec3(0.f,0.f,0.f)); - - // add the light in the scenegraph - osg::LightSource* lightS = new osg::LightSource; - lightS->setLight(myLight); - if (vrml_light->on()) { - lightS->setLocalStateSetModes(osg::StateAttribute::ON); - //lightS->setStateSetModes(*rootStateSet,osg::StateAttribute::ON); - } - - lightGroup->addChild(lightS); - osgLightNum++; - - return lightGroup; - - } else if(obj->type.id == "SpotLight") // Handle lights - { - osg::Group* lightGroup = new osg::Group; - - openvrml::vrml97_node::spot_light_node *vrml_light; - vrml_light = dynamic_cast(obj); - - // create light with global params - osg::Light* myLight = new osg::Light; - myLight->setLightNum(osgLightNum); - myLight->setPosition(osg::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); - myLight->setAmbient(osg::Vec4(vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity())); - float osgR = vrml_light->color().r()*vrml_light->intensity(); - float osgG = vrml_light->color().g()*vrml_light->intensity(); - float osgB = vrml_light->color().b()*vrml_light->intensity(); - myLight->setDiffuse(osg::Vec4(osgR, osgG, osgB, 1.0f)); - myLight->setSpecular(osg::Vec4(osgR, osgG, osgB, 1.0f)); - - // configure light as SPOT - openvrml::sfvec3f &dir = vrml_light->direction_; - myLight->setDirection(osg::Vec3(dir.value[0],dir.value[1],dir.value[2])); - - // The cutOff value in osg ranges from 0 to 90, we need - // to divide by 2 to avoid openGL error. - // myLight->setSpotCutoff(ls.fallsize/2.0f); - // The bigger the differens is between fallsize and hotsize - // the bigger the exponent should be. - // float diff = ls.fallsize - ls.hotsize; - // myLight->setSpotExponent(diff); - - // add the light in the scenegraph - osg::LightSource* lightS = new osg::LightSource; - lightS->setLight(myLight); - if (vrml_light->on()) { - lightS->setLocalStateSetModes(osg::StateAttribute::ON); - //lightS->setStateSetModes(*rootStateSet,osg::StateAttribute::ON); - } - - lightGroup->addChild(lightS); - osgLightNum++; - - return lightGroup; - - } else { - - return NULL; - } - */ - -#endif - - return 0; -} - diff --git a/src/osgPlugins/vrml/ReaderWriterVRML2.h b/src/osgPlugins/vrml/ReaderWriterVRML2.h deleted file mode 100644 index 061b7a55d..000000000 --- a/src/osgPlugins/vrml/ReaderWriterVRML2.h +++ /dev/null @@ -1,118 +0,0 @@ -// -*-c++-*- - -/* - * - * VRML2 file converter for OpenSceneGraph. - * - * authors : - * Johan Nouvel (johan_nouvel@yahoo.com) for the writeNode function. - * - * Jan Ciger (jan.ciger@gmail.com), - * Tolga Abaci (tolga.abaci@gmail.com), - * Bruno Herbelin (bruno.herbelin@gmail.com) - * - * (c) VRlab EPFL, Switzerland, 2004-2006 - * - * Gino van den Bergen, DTECTA (gino@dtecta.com) - * Xiangxian Wang (xiangxianwang@yahoo.com.cn) - * - */ - -#include -#include - -#include -#ifndef OSG_USE_DEPRECATED_GEOMETRY_METHODS -#define OSG_USE_DEPRECATED_GEOMETRY_METHODS 1 -#endif - -#include -#include - -#include -#include -#include -#include - - -namespace openvrml -{ - class node; -} - -class QuadricKey -{ -public: - QuadricKey(float height, float radius, unsigned bottom, unsigned side, unsigned top) - : m_height(height) - , m_radius(radius) - , m_flags(bottom | (side << 1) | (top << 2)) - {} - - bool operator<(const QuadricKey& rhs) const - { - return m_height < rhs.m_height || - (m_height == rhs.m_height && (m_radius < rhs.m_radius || - (m_radius == rhs.m_radius && m_flags < rhs.m_flags))); - } - -private: - float m_height; - float m_radius; - unsigned m_flags; -}; - - - - -/** - * OpenSceneGraph plugin wrapper/converter. - */ -class ReaderWriterVRML2 - : public osgDB::ReaderWriter -{ -public: - ReaderWriterVRML2() - { - supportsExtension("wrl","VRML format"); - supportsOption("directoryTexture=","Export option. If a texture needs to be copied, it will be into directory instead of the working one"); - supportsOption("convertTextures=0","Export option. Keep textures in their original format but copy them into directory"); - supportsOption("convertTextures=-1","Export option. Use textures but do not convert them, keep them in their original format and location."); - supportsOption("convertTextures=-2","Export option. Do not use textures, export only geometry"); - supportsOption("convertTextures=-3","Export option. Default value.Convert textures to jpeg or png format, according to alpha values, and copy them into directory "); - supportsOption("textureUnit=","Export option. Use parameters of texture unit X instead of unit 0 in case of multitexture input file"); - } - - virtual const char* className() const { return "VRML2 Reader/Writer"; } - - virtual ReadResult readObject(const std::string& fileName, const osgDB::ReaderWriter::Options* options) const - { - return readNode(fileName, options); - } - - virtual ReadResult readNode(const std::string&, const osgDB::Options *options) const; - // virtual ReadResult readNode(std::istream& fin, const osgDB::Options* options) const; - - virtual WriteResult writeNode(const osg::Node&,const std::string& filename,const osgDB::ReaderWriter::Options *options) const; - -private: - typedef std::map > SphereLibrary; - typedef std::map > BoxLibrary; - typedef std::map > ConeLibrary; - typedef std::map > CylinderLibrary; - - osg::Node* convertFromVRML(openvrml::node *obj) const; - - - osg::ref_ptr convertVRML97IndexedFaceSet(openvrml::node *vrml_ifs) const; - osg::ref_ptr convertVRML97IndexedLineSet(openvrml::node *vrml_ifs) const; - osg::ref_ptr convertVRML97Box(openvrml::node* vrml_box) const; - osg::ref_ptr convertVRML97Sphere(openvrml::node* vrml_sphere) const; - osg::ref_ptr convertVRML97Cone(openvrml::node* vrml_cone) const; - osg::ref_ptr convertVRML97Cylinder(openvrml::node* vrml_cylinder) const; - - mutable BoxLibrary m_boxLibrary; - mutable SphereLibrary m_sphereLibrary; - mutable ConeLibrary m_coneLibrary; - mutable CylinderLibrary m_cylinderLibrary; -};