Changeset 752 for GTP/trunk/Lib/Vis/Preprocessing/src/X3dParser.cpp

Timestamp:

04/20/06 13:25:41 (18 years ago)

Author:

mattausch

Message:

after rendering workshop submissioin
x3dparser can use def - use constructs
implemented improved evaluation (samples are only stored in leaves, only propagate pvs size)

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/X3dParser.cpp (modified) (14 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/X3dParser.cpp

@@ -100 +100 @@
   string element(lname.LocalForm());
   
+  // only create new mesh instance if define mechanism was not used
   if (element == "Shape")
     EndShape();
-  if (1)
+
   if (element == "Transform")
           EndTransform();
@@ -138 +139 @@
 
         const int len = attributes.getLength();
+    Matrix4x4 *rotm = NULL;
+        Matrix4x4 *scalem = NULL;
+        Matrix4x4 *translm = NULL;
     
         for (int i = 0; i < len; ++ i) 
@@ -153 +157 @@
                         if (sscanf(ptr, "%f %f %f %f", &axis.x, &axis.y, &axis.z, &angle) == 4)
                         {
-                                Matrix4x4 rot = RotationAxisMatrix(axis, angle);
-                                currentTransform *= rot;
+                                rotm = new Matrix4x4(RotationAxisMatrix(axis, angle));
                         }
                 }
@@ -163 +166 @@
                         if (sscanf(ptr, "%f %f %f %f", &transl.x, &transl.y, &transl.z) == 3)
                         {
-                                Matrix4x4 tm = TranslationMatrix(transl);
-
-                                currentTransform *= tm;
+                                translm = new Matrix4x4(TranslationMatrix(transl));
                         }
                 }
+                else if (attrName == "scale")
+                {
+                        Vector3 scale;
+
+                        if (sscanf(ptr, "%f %f %f %f", &scale.x, &scale.y, &scale.z) == 3)
+                        {
+                                scalem = new Matrix4x4(ScaleMatrix(scale.x, scale.y, scale.z));
+                        }
+                }
+                // todo: scale orientation
         }
         
+        if (scalem)
+                currentTransform *= (*scalem);
+        if (rotm)
+                currentTransform *= (*rotm);
+        if (translm)
+                currentTransform *= (*translm);
+
+        DEL_PTR(scalem);
+        DEL_PTR(rotm);
+        DEL_PTR(translm);
+
         mTransformations.push(currentTransform);
 }
@@ -180 +202 @@
 
 
-void
-X3dParseHandlers::EndShape()
-{
+void X3dParseHandlers::EndShape()
+{
+        // this shape is a definition => don't create mesh instance
+        if (mIsMeshDefinition) 
+{
+                mMeshDefinitions[mCurrentMeshName.c_str()] = mCurrentMesh;
+                //cout << "new definition: " << mCurrentMeshName << endl;
+                
+                return;
+        }
+
+        // each polygon is one single mesh
         if (mLoadPolygonsAsMeshes)
         {
-                vector<VertexIndexContainer>::const_iterator it, it_end = mCurrentVertexIndices.end();
+                
+                /*vector<VertexIndexContainer>::const_iterator it, 
+                        it_end = mCurrentVertexIndices.end();
 
                 for (it = mCurrentVertexIndices.begin(); it != it_end; ++ it)
@@ -211 +244 @@
                         mCurrentNode->mGeometry.push_back(mi);
 
-                }
-
-                delete mCurrentMesh;
-                mCurrentVertices.clear();
-                mCurrentVertexIndices.clear();
+                }*/
+
+                //if (mCurrentMesh->mFaces.empty())     cout << "error!" << endl;
+
+                FaceContainer::const_iterator fit, fit_end = mCurrentMesh->mFaces.end();
+
+                cout << "m";
+                //cout << "m: " << mCurrentMesh->mFaces.size() << endl;
+                for (fit = mCurrentMesh->mFaces.begin(); fit != fit_end; ++ fit)
+                {
+                        cout << "f";
+
+                        Face *face = *fit;
+                        // only one face per mesh
+                        Mesh *mesh = new Mesh();
+                        VertexIndexContainer vc;
+                                        
+                        VertexIndexContainer::const_iterator vit, vit_end = face->mVertexIndices.end();
+                        
+                        int i = 0;
+                        for (vit = face->mVertexIndices.begin(); vit != vit_end; ++ vit, ++ i)
+                        {
+                                cout << "i";
+                                int index = (*vit);
+                                // add vertices
+                                mesh->mVertices.push_back(mCurrentMesh->mVertices[index]);
+                                vc.push_back(i);
+                        }
+
+                        mesh->mFaces.push_back(new Face(vc));
+
+                        // NOTE: should rather be written into trafo of mesh instance
+                        ApplyTransformations(mTransformations, mesh);
+
+                        mesh->Preprocess();
+                                
+                        // make an instance of this mesh
+                        MeshInstance *mi = new MeshInstance(mesh);
+                        mCurrentNode->mGeometry.push_back(mi);
+                }
+
+                // LEAK!! TODO: delete if not defd
+                if (!mUsingMeshDefinition)
+                        delete mCurrentMesh;
+
+                //mCurrentVertices.clear();
+                //mCurrentVertexIndices.clear();
         }
         else
         { 
-                if (mCurrentMesh->mFaces.size()) 
+                if (!mCurrentMesh->mFaces.empty()) 
                 {
                         // should rather be written into the transformation
@@ -228 +303 @@
                         // make an instance of this mesh
                         MeshInstance *mi = new MeshInstance(mCurrentMesh);
+
                         mCurrentNode->mGeometry.push_back(mi);
                         // set the object id to a unique value
@@ -234 +310 @@
                 else 
                 {
+                        // empty mesh => discard
                         cout<<"X";
+
                         delete mCurrentMesh;
                 }
@@ -243 +321 @@
 
 
-void
-X3dParseHandlers::StartIndexedFaceSet(
-                                                                          AttributeList&  attributes)
+void X3dParseHandlers::StartIndexedFaceSet(AttributeList&  attributes)
 {
   int len = attributes.getLength();
+
   int i;
   VertexIndexContainer vertices;
   
-  for (i=0; i < len; i++) {
-    string attrName(StrX(attributes.getName(i)).LocalForm());
-    if (attrName == "coordIndex") {
-      StrX attrValue(attributes.getValue(i));
-      // handle coordIndex
-      vertices.clear();
-      const char *ptr = attrValue.LocalForm();
-      char *endptr;
-      while(1) {
-        int index = strtol(ptr, &endptr, 10);
-        if (ptr == endptr || index == -1) {
-          if (vertices.size() > 2) {
-                  Face *face = new Face(vertices);
-
-                   if (!mLoadPolygonsAsMeshes)
-                   {
-                           mCurrentMesh->mFaces.push_back(face);
-                   }
-                   else
-                   // every polygon is a mesh
-                   {
-                           mCurrentVertexIndices.push_back(vertices);
-                   }
-          }
-
-          vertices.clear();
-          if (ptr == endptr)
-            break;
-        } else {
-          vertices.push_back(index);
-        }
-        ptr = endptr;
-          }
-    }
-  }
-}
+        mIsMeshDefinition = false;
+        mUsingMeshDefinition = false;
+        for (i = 0; i < len; ++ i) 
+        {
+                string attrName(StrX(attributes.getName(i)).LocalForm());
+          
+                // this is a definition of a mesh
+                if (attrName == "DEF")
+                {
+                        mIsMeshDefinition = true;
+                        StrX attrValue(attributes.getValue(i));
+                        const char *ptr = attrValue.LocalForm();
+                        mCurrentMeshName = ptr;
+
+                        cout << "d";
+                }
+                
+                // we use an already defined mesh
+                if (attrName == "USE")
+                {
+                        StrX attrValue(attributes.getValue(i));
+
+                        // discard new mesh and assign defined mesh
+                        DEL_PTR(mCurrentMesh);
+                        const char *ptr = attrValue.LocalForm();
+
+                        mCurrentMesh = mMeshDefinitions[ptr];
+                        mUsingMeshDefinition = true;
+                        cout << "u";
+                }
+                
+                if (attrName == "coordIndex") 
+                {
+                        StrX attrValue(attributes.getValue(i));
+                        // handle coordIndex
+                        vertices.clear();
+                        const char *ptr = attrValue.LocalForm();
+                  
+                        char *endptr;
+          
+                        while (1) 
+                        {
+                                int index = strtol(ptr, &endptr, 10);
+                                  
+                                if (ptr == endptr || index == -1) 
+                                {
+                                        if (vertices.size() > 2) 
+                                        {
+                                                Face *face = new Face(vertices);                 
+                                                mCurrentMesh->mFaces.push_back(face);
+                                        } 
+                          
+                                        vertices.clear();
+                  
+                                        if (ptr == endptr)
+                                                break;
+                          
+                                  } 
+                                  else 
+                                  {
+                                          vertices.push_back(index);
+                                  }
+                                  ptr = endptr;
+                        }
+                }
+        }
+}
+
 
 void
@@ -358 +467 @@
                                 vertices.push_back(v);
                         }
-                        if (mLoadPolygonsAsMeshes)
-                        {
-                                mCurrentVertices = vertices;
-                        }
-                        else
-                        {
-                                mCurrentMesh->mVertices = vertices;
-                        }
+                        
+                        mCurrentMesh->mVertices = vertices;
                 }
         }
@@ -388 +491 @@
   }
   
-  if (element == "Coordinate") {
+  if (element == "Coordinate") 
+  {
     if (mCurrentMesh)
       StartCoordinate(attributes);
@@ -396 +500 @@
     StartMaterial(attributes);
   }
-if (1)
+  
   if (element == "Transform") {
           StartTransform(attributes);
@@ -599 +703 @@
 X3dViewCellsParseHandlers::EndShape()
 {
+        // currently processing no shape
 }
 
@@ -607 +712 @@
         int len = attributes.getLength();
         int i;
+        
         // clear previous vertex indices
         mCurrentVertexIndices.clear();
+
+
         for (i=0; i < len; i++) 
         {
                 string attrName(StrX(attributes.getName(i)).LocalForm());
             
+
                 if (attrName == "coordIndex") 
                 {