Changeset 9053

Timestamp:

10/25/08 15:17:22 (5 years ago)

Author:

robert

Message:

From Jim Vaughan,

- Matrix transform nodes were stripped out, and the
vertices and normals of each node were
transposed by the modelling matrix. My change preserves
the matrix transform nodes, so that
models can still be articulated by changing the matrices.

- Lights were copied from the COIN scenegraph to the OSG
scenegraph, but they were not associated
with a LightSource? node. My change for this creates a
Group and adds a LightSource? for each Light.

- If VRML textures have names, the name is now copied to

--

Form Robert Osfild, changed SbString? to std::string usage

M Inventor/ConvertFromInventor.h
M Inventor/ConvertFromInventor.cpp

Location:

OpenSceneGraph/trunk/src/osgPlugins/Inventor

Files:

• ConvertFromInventor.cpp (modified) (20 diffs)
• ConvertFromInventor.h (modified) (4 diffs)

OpenSceneGraph/trunk/src/osgPlugins/Inventor/ConvertFromInventor.cpp

@@ -18 +18 @@
 #include <osg/CullFace>
 #include <osg/LightModel>
+#include <osg/LightSource>
 #include <osg/ShadeModel>
 #include <osg/LOD>
@@ -40 +41 @@
 #include <Inventor/SoPrimitiveVertex.h>
 #include <Inventor/SbLinear.h>
+#include <Inventor/nodes/SoTransform.h>
+#include <Inventor/nodes/SoInfo.h>
 
 #ifdef __COIN__
 #include <Inventor/VRMLnodes/SoVRMLImageTexture.h>
+#include <Inventor/VRMLnodes/SoVRMLTransform.h>
+#include <Inventor/VRMLnodes/SoVRMLAppearance.h>
+#include <Inventor/VRMLnodes/SoVRMLMaterial.h>
 #endif
 
@@ -50 +56 @@
 #include <assert.h>
 #include <math.h>
+#include <string.h>
 #ifdef __linux
 #include <values.h>
@@ -62 +69 @@
 {
     numPrimitives = 0;
+    transformInfoName = "";
+    appearanceName = "";
+    inAppearanceWithNoTexture = false;
+    lightGroup = NULL;
 }
 ///////////////////////////////////////////
@@ -99 +110 @@
     cbAction.addPreCallback(SoVRMLImageTexture::getClassTypeId(),
                             preVRMLImageTexture, this);
+    cbAction.addPreCallback(SoVRMLAppearance::getClassTypeId(),
+                            preVRMLAppearance, this);
+    cbAction.addPreCallback(SoInfo::getClassTypeId(), preInfo, this);
 #endif
     cbAction.addPreCallback(SoLight::getClassTypeId(), preLight, this);
@@ -246 +260 @@
     osg::ref_ptr<osg::Geometry> geometry = new osg::Geometry;
 
-    // Get the modeling matrix
-    osg::Matrix modelMat;
-    modelMat.set((float *)action->getModelMatrix().getValue());
-
-    // Tranform the vertices based on the modeling matrix
+
     osg::ref_ptr<osg::Vec3Array> coords = new osg::Vec3Array(thisPtr->vertices.size());
     for (unsigned int i = 0; i < thisPtr->vertices.size(); i++)
-        (*coords)[i] = modelMat.preMult(thisPtr->vertices[i]);
-
+        (*coords)[i] = thisPtr->vertices[i];
     geometry->setVertexArray(coords.get());
 
-
-    // Normals need to be transformed using the transpose of the inverse 
-    // modeling matrix
-    osg::Matrix invModelMat;
-    invModelMat.invert(modelMat);
-    thisPtr->transposeMatrix(invModelMat);
-
-    // Tranform the normals based on the modeling matrix
     osg::ref_ptr<osg::Vec3Array> norms = NULL;
     if (thisPtr->normalBinding == osg::Geometry::BIND_OVERALL)
@@ -271 +272 @@
         const SbVec3f &norm = action->getNormal(0);
         (*norms)[0].set(norm[0], norm[1], norm[2]);
-        (*norms)[0] = invModelMat.transform3x3((*norms)[0],invModelMat);
-        (*norms)[0].normalize();
     }
     else
@@ -279 +278 @@
         for (unsigned int i = 0; i < thisPtr->normals.size(); i++)
         {
-            (*norms)[i] = invModelMat.transform3x3(thisPtr->normals[i], 
-                                                invModelMat);
-            (*norms)[i].normalize();
+            (*norms)[i] = thisPtr->normals[i];
         }
     }
@@ -361 +358 @@
     geode->addDrawable(geometry.get());
 
+    // copy name
+    std::string name = stateSet->getName();
+    if (name != "") {
+        geode->setName(name);
+    }
     // Add geode to scenegraph
     thisPtr->groupStack.top()->addChild(geode.get());
@@ -386 +388 @@
 //////////////////////////////////////////////////////////////////////////////////
 SoCallbackAction::Response 
+ConvertFromInventor::preVRMLAppearance(void* data, SoCallbackAction* action,
+                                         const SoNode* node)
+{
+#ifdef DEBUG_IV_PLUGIN
+    osg::notify(osg::INFO) << "preVRMLAppearance()  " 
+              << node->getTypeId().getName().getString() << std::endl;
+#endif
+
+#ifdef __COIN__
+    ConvertFromInventor* thisPtr = (ConvertFromInventor *) (data);
+
+    // If there is a VRML appearance node without a texture node, then
+    // we push a NULL texture onto the stack
+    bool foundTex = false;
+    SoChildList *kids = node->getChildren();
+    for (int i=0; i<kids->getLength(); i++) {
+        SoNode* kid = (SoNode*)kids->get(i);
+        if (kid->isOfType(SoVRMLMaterial::getClassTypeId())) {
+            thisPtr->appearanceName = kid->getName();
+        }
+        if (kid->isOfType(SoVRMLTexture::getClassTypeId())) {
+            foundTex = true;
+        }
+    }
+    if (!foundTex) {
+        thisPtr->soTexStack.push(NULL);
+        thisPtr->inAppearanceWithNoTexture = true;
+    }
+#endif
+    return SoCallbackAction::CONTINUE;
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+SoCallbackAction::Response 
 ConvertFromInventor::preVRMLImageTexture(void* data, SoCallbackAction* action,
                                          const SoNode* node)
@@ -433 +469 @@
     osg::ref_ptr<osg::Light> osgLight = new osg::Light;
     osgLight->setLightNum(lightNum++);
+
+    const char* name = ivLight->getName().getString();
+    osgLight->setName(name);
     
     // Get color and intensity
@@ -487 +526 @@
         thisPtr->lightStack.push(lightList);
     }
+
+    // add a light source node to the scene graph
+    osg::ref_ptr<osg::LightSource> ls = new osg::LightSource();
+    ls->setLight(osgLight.get());
+    ls->setName(ivLight->getName().getString());
+    if (thisPtr->lightGroup == NULL) {
+        thisPtr->lightGroup = new osg::Group;
+        thisPtr->lightGroup->setName("IvLightGroup");
+        thisPtr->_root->addChild(thisPtr->lightGroup.get());
+    }
+    thisPtr->lightGroup->addChild(ls.get());
 
     return SoCallbackAction::CONTINUE;
@@ -519 +569 @@
         
         stateSet->setTextureAttributeAndModes(0, texture.get(), osg::StateAttribute::ON);
+        
+        // propogate name
+        std::string name = texture->getName();
+        if (name != "")
+            stateSet->setName(name);
 
         // Set the texture environment
@@ -668 +723 @@
 
         stateSet->setAttributeAndModes(material.get(), osg::StateAttribute::ON);
+        stateSet->setName(appearanceName.getString());
         stateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON);
 
@@ -709 +765 @@
     // Copy the texture image data from the inventor texture
     memcpy(osgImageData, soImageData, soSize[0] * soSize[1] * soNC);
+
+    // Copy the name
+    std::string name = soNode->getName().getString();
 
     // File name
@@ -740 +799 @@
     osg::Texture2D *osgTex = new osg::Texture2D;
     osgTex->setImage(osgImage.get());
+    if (name != "") {
+        osgTex->setName(name);
+    }
 
     static std::map<SoTexture2::Wrap, osg::Texture2D::WrapMode> texWrapMap;
@@ -776 +838 @@
 ///////////////////////////////////////////////////////////////////
 SoCallbackAction::Response 
-ConvertFromInventor::preGroup(void* data, SoCallbackAction*, 
+ConvertFromInventor::preInfo(void* data, SoCallbackAction* action, 
+                              const SoNode* node)
+{
+#ifdef DEBUG_IV_PLUGIN
+    osg::notify(osg::INFO) << "preInfo()    " 
+              << node->getTypeId().getName().getString() << std::endl;
+#endif
+    ConvertFromInventor* thisPtr = (ConvertFromInventor *) (data);
+    SoInfo* info = (SoInfo*)node;
+    thisPtr->transformInfoName = info->string.getValue();
+
+    return SoCallbackAction::CONTINUE;
+}
+    
+///////////////////////////////////////////////////////////////////
+SoCallbackAction::Response 
+ConvertFromInventor::preGroup(void* data, SoCallbackAction* action, 
                               const SoNode* node)
 {
@@ -783 +861 @@
               << node->getTypeId().getName().getString() << std::endl;
 #endif
-
     ConvertFromInventor* thisPtr = (ConvertFromInventor *) (data);
 
     // Create a new Group or LOD and add it to the stack
     osg::ref_ptr<osg::Group> group;
-    if (node->isOfType(SoLOD::getClassTypeId()))
+    if (node->isOfType(SoLOD::getClassTypeId())) {
         group = new osg::LOD;
-    else
+    }
+    else {
         group = new osg::Group;
+    }
+
     thisPtr->groupStack.top()->addChild(group.get());
     thisPtr->groupStack.push(group.get());
-
+    
+    // handle transform nodes
+    if (node->isOfType(SoTransform::getClassTypeId())) {
+        SoTransform* t = (SoTransform*)node;
+        SbVec3f axis, center, trans, scale;
+        float angle;
+
+        center = t->center.getValue();
+        t->rotation.getValue(axis, angle);
+        trans = t->translation.getValue();
+        scale = t->scaleFactor.getValue();
+        std::string name = t->getName().getString();
+
+        thisPtr->addMatrixTransform(name, axis, angle, center, trans, scale);
+    }
+#ifdef __COIN__
+    if (node->isOfType(SoVRMLTransform::getClassTypeId())) {
+        std::string name;
+        if (thisPtr->transformInfoName != "") {
+            name = std::string("INFO_");
+            name += thisPtr->transformInfoName.getString();
+            name += "_trans";
+        }
+        else {
+            name = node->getName();
+        }
+        
+        SoVRMLTransform* vt = (SoVRMLTransform*)node;
+        SbVec3f axis, center, trans, scale;
+        float angle;
+
+        center = vt->center.getValue();
+        vt->rotation.getValue(axis, angle);
+        trans = vt->translation.getValue();
+        scale = vt->scale.getValue();
+
+        thisPtr->addMatrixTransform(name, axis, angle, center, trans, scale);
+    }
+#endif
     if (node->isOfType(SoSeparator::getClassTypeId()))
     {
@@ -823 +941 @@
               << node->getTypeId().getName().getString() << std::endl;
 #endif
-
     ConvertFromInventor* thisPtr = (ConvertFromInventor *) (data);
 
@@ -1047 +1164 @@
 }
 ////////////////////////////////////////////////////////////////////////////
+void ConvertFromInventor::addMatrixTransform(const std::string& name, SbVec3f axis, float angle, SbVec3f center, SbVec3f trans, SbVec3f scale)
+{
+    osg::Matrix mat;
+    if (trans.length() != 0.0 || name != "")
+    {
+        mat.makeIdentity();
+        mat.setTrans(trans[0], trans[1], trans[2]);
+        osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform(mat);
+        if (name != "") {
+            std::string name2 = name;
+            name2 += "_t";
+            mt->setName(name2);
+        }
+        groupStack.top()->addChild(mt.get());
+        groupStack.push(mt.get());
+    }
+
+    if (center.length() != 0.0) {
+        mat.makeIdentity();
+        mat.setTrans(center[0], center[1], center[2]);
+        osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform(mat);
+        groupStack.top()->addChild(mt.get());
+        groupStack.push(mt.get());
+    }
+
+    if (angle != 0.0 || name != "")
+    {
+        osg::Quat q(angle, osg::Vec3f(axis[0], axis[1], axis[2]));
+        mat.makeIdentity();
+        mat.setRotate(q); 
+        osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform(mat);
+        if (name != "") {
+            std::string name2 = name;
+            name2 += "_r";
+            mt->setName(name2);
+        }
+        groupStack.top()->addChild(mt.get());
+        groupStack.push(mt.get());
+    }
+
+    if (center.length() != 0.0) {
+        center.negate();
+        mat.makeIdentity();
+        mat.setTrans(center[0], center[1], center[2]);
+        osg::ref_ptr<osg::MatrixTransform>  mt = new osg::MatrixTransform(mat);
+        groupStack.top()->addChild(mt.get());
+        groupStack.push(mt.get());
+    }
+
+    if (scale[0] != 1.0 || scale[1] != 1.0 || scale[2] != 1.0)    {
+        mat.makeIdentity();
+        mat.makeScale(scale[0], scale[1], scale[2]);
+        osg::ref_ptr<osg::MatrixTransform>  smt = new osg::MatrixTransform(mat);
+        groupStack.top()->addChild(smt.get());
+        groupStack.push(smt.get());
+    }
+}
+////////////////////////////////////////////////////////////////////////////
 void ConvertFromInventor::addTriangleCB(void* data, SoCallbackAction* action,
                                         const SoPrimitiveVertex* v0,

OpenSceneGraph/trunk/src/osgPlugins/Inventor/ConvertFromInventor.h

@@ -8 +8 @@
 #include <osg/Light>
 #include <Inventor/actions/SoCallbackAction.h>
+#include <Inventor/SbLinear.h>
 #include <vector>
 #include <stack>
@@ -50 +51 @@
         static SoCallbackAction::Response preVRMLImageTexture(void* data,
                                  SoCallbackAction* action, const SoNode* node);
+        static SoCallbackAction::Response preVRMLAppearance(void* data,
+                                 SoCallbackAction* action, const SoNode* node);
+        static SoCallbackAction::Response postVRMLAppearance(void* data,
+                                 SoCallbackAction* action, const SoNode* node);
+        static SoCallbackAction::Response preInfo(void* data,
+                                 SoCallbackAction* action, const SoNode* node);
 
         static void addTriangleCB(void* data, SoCallbackAction* action,
@@ -62 +69 @@
 
     private:
+        SbString transformInfoName;
+        SbName appearanceName;
+        bool inAppearanceWithNoTexture;
 
+        void addMatrixTransform(const std::string& name, SbVec3f axis, float angle, SbVec3f center, SbVec3f trans, SbVec3f scale);
         void addVertex(SoCallbackAction* action, const SoPrimitiveVertex* v, 
                        int index);
@@ -113 +124 @@
 
         osg::ref_ptr<osg::MatrixTransform> _root;///<The root node;
+
+        osg::ref_ptr<osg::Group> lightGroup;
 };