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

Timestamp:

06/05/06 23:14:04 (18 years ago)

Author:

mattausch

Message:

added mesh instance support
improved support for occlusion queries + other extensions

File:

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

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

@@ -29 +29 @@
 #include "Triangle3.h"
 #include "ViewCellsManager.h"
+#include "ResourceManager.h"
 
 namespace GtpVisibilityPreprocessor {
@@ -60 +61 @@
 #define ROTATE_SCENE 0
 
-
-static void RotateMesh(Mesh *mesh)
+static int sUniqueMeshIdx = 0;
+
+// hack: rotate mesh by n degrees
+static void RotateMesh(Mesh *mesh, const float angle)
 {
         VertexContainer::iterator it, it_end = mesh->mVertices.end();
 
-        const float angle = 30.0f * PI / 180.0f;
-        const Matrix4x4 rot = RotationYMatrix(angle);
+        const float angleRad = angle * PI / 180.0f;
+        const Matrix4x4 rot = RotationYMatrix(angleRad);
 
         for (it = mesh->mVertices.begin(); it != it_end; ++ it)
@@ -83 +86 @@
   , mSpaceCount(0)
   , mLoadPolygonsAsMeshes(loadPolygonsAsMeshes)
-{
-  mCurrentNode = root;
-  // this matrix should never be removed from stack
-  //mTransformations.push(IdentityMatrix());
+  , mCurrentMesh(NULL)
+{
+        mCurrentNode = root;
+
+        // this matrix should never be removed from stack
+        //mTransformations.push(IdentityMatrix());
 }
 
@@ -99 +104 @@
 //  StdInParseHandlers: Implementation of the SAX DocumentHandler interface
 // ---------------------------------------------------------------------------
+
 void X3dParseHandlers::endElement(const XMLCh* const name)
 {
-  StrX lname(name);
-  string element(lname.LocalForm());
-  
-  // only create new mesh instance if define mechanism was not used
-  if (element == "Shape")
-    EndShape();
-
-  if (element == "Transform")
-          EndTransform();
-}
-
-
-
-
-void X3dParseHandlers::ApplyTransformation(Mesh *mesh, 
-                                                                                   const Matrix4x4 &m) const
-{
-        VertexContainer::iterator it, it_end = mesh->mVertices.end();
-
-        for (it = mesh->mVertices.begin(); it != it_end; ++ it)
-        {
-                (*it) = m * (*it);        
-        }
+        StrX lname(name);
+        string element(lname.LocalForm());
+
+        // only create new mesh instance if define mechanism was not used
+        if (element == "Shape")
+                EndShape();
+
+        if (element == "Transform")
+                EndTransform();
 }
 
@@ -134 +126 @@
                 trafos.pop();
 
-                ApplyTransformation(mesh, m);
-        }
-}
+                mesh->ApplyTransformation(m);
+        }
+}
+
+
+void X3dParseHandlers::ApplyTransformations(TrafoStack trafos, 
+                                                                                        TransformedMeshInstance *mi) const
+{
+        while (!trafos.empty())
+        {
+                const Matrix4x4 m = trafos.top();
+                trafos.pop();
+
+                mi->ApplyWorldTransform(m);
+        }
+}
+
 
 void X3dParseHandlers::StartTransform(AttributeList&  attributes)
@@ -143 +149 @@
 
         const int len = attributes.getLength();
+
     Matrix4x4 *rotm = NULL;
         Matrix4x4 *scalem = NULL;
@@ -208 +215 @@
 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;
+         //-- if shape is merely a definition => don't create particular mesh instance
+         if (!mCurrentMesh || mIsMeshDefinition) 
+         { 
+                 return;
+         }
+
+         //-- each polygon is one single mesh
+         if (mLoadPolygonsAsMeshes)
+         {
+                 FaceContainer::const_iterator fit, fit_end = mCurrentMesh->mFaces.end();
+
+                 cout << "m";
                 
-                return;
-        }
-
-        // each polygon is one single mesh
-        if (mLoadPolygonsAsMeshes)
-        {
-                //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();
+                 for (fit = mCurrentMesh->mFaces.begin(); fit != fit_end; ++ fit)
+                 {
+                         cout << "f";
+
+                         Face *face = *fit;
+                
+                         // we create a new mesh for each face from the current mesh
+                         Mesh *mesh = MeshManager::GetSingleton()->CreateResource();
                         
-                        int i = 0;
-                        for (vit = face->mVertexIndices.begin(); vit != vit_end; ++ vit, ++ i)
+                         VertexIndexContainer::const_iterator vit, vit_end = face->mVertexIndices.end();
+                
+                         int i = 0;
+                         VertexIndexContainer vcIndices;
+
+                         for (vit = face->mVertexIndices.begin(); vit != vit_end; ++ vit, ++ i)
+                         {
+                                 cout << "i";
+                                 const int index = (*vit);
+
+                                 // add vertices
+                                 mesh->mVertices.push_back(mCurrentMesh->mVertices[index]);
+
+                                 // indices don't make much sense if mesh = face, but
+                                 // we need them anyway ...
+                                 vcIndices.push_back(i);
+                         }
+
+                         mesh->mFaces.push_back(new Face(vcIndices));
+
+                         // 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);
+                 }
+
+                 // this mesh is not needed, unless it is used as a definition
+                 if (!mUsingMeshDefinition) 
+                         MeshManager::GetSingleton()->DestroyEntry(mCurrentMesh->GetId());
+        }
+        else // default usage: create a mesh instance from the current mesh
+        { 
+                MeshInstance *mi;
+
+                if (0 && !mUsingMeshDefinition) 
+                {
+                        // make an instance of this mesh
+            mi = new MeshInstance(mCurrentMesh);
+
+                        // this mesh is used only once => write transformations directly into it
+                        ApplyTransformations(mTransformations, mCurrentMesh);
+                }
+                else
+                {
+                         // make an instance of this mesh
+                         TransformedMeshInstance *tmi = new TransformedMeshInstance(mCurrentMesh);
+
+                         // apply transformation on the instance of the mesh 
+                         ApplyTransformations(mTransformations, tmi);
+
+                         mi = tmi;
+                }
+                
+                if (mCurrentMaterial)
+                {
+                        // HACK: add the material to the mesh directly if no material yet
+                        if (mCurrentMesh->mMaterial)
                         {
-                                cout << "i";
-                                int index = (*vit);
-                                // add vertices
-                                mesh->mVertices.push_back(mCurrentMesh->mVertices[index]);
-                                vc.push_back(i);
+                                mCurrentMesh->mMaterial = mCurrentMaterial;
                         }
-
-                        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.empty()) 
-                {
-                        // should rather be written into the transformation
-                        // of a mesh instance
-                        ApplyTransformations(mTransformations, mCurrentMesh);
-
-                        mCurrentMesh->Preprocess();
-                        // make an instance of this mesh
-                        MeshInstance *mi = new MeshInstance(mCurrentMesh);
-
-                        mCurrentNode->mGeometry.push_back(mi);
-                        // set the object id to a unique value
-                        //mi->SetId(mCurrentObjectId ++);
-                } 
-                else 
-                {
-                        // empty mesh => discard
-                        cout<<"X";
-
-                        delete mCurrentMesh;
-                }
-
+                        else // add material to the instance
+                        {
+                                mi->SetMaterial(mCurrentMaterial);
+                        }
+                }
+
+                // create local mesh kd tree
+                mCurrentMesh->Preprocess();
+                // add to scene graph
+                mCurrentNode->mGeometry.push_back(mi);
+        
+                // reset current mesh
                 mCurrentMesh = NULL;
         }
@@ -297 +320 @@
 void X3dParseHandlers::StartIndexedFaceSet(AttributeList&  attributes)
 {
-  int len = attributes.getLength();
-
-  int i;
-  VertexIndexContainer vertices;
+        //-- indexedfaceset corresponds  to Mesh in our implementation
+        const int len = attributes.getLength();
+
+        VertexIndexContainer vertices;
   
         mIsMeshDefinition = false;
         mUsingMeshDefinition = false;
-        for (i = 0; i < len; ++ i) 
+
+        for (int i = 0; i < len; ++ i) 
         {
-                string attrName(StrX(attributes.getName(i)).LocalForm());
-          
-                // this is a definition of a mesh
-                if (attrName == "DEF")
-                {
+                const string attrName(StrX(attributes.getName(i)).LocalForm());
+        
+                //-- we use an already defined mesh
+                if (attrName == "USE")
+                {
+                        StrX attrValue(attributes.getValue(i));
+                        const char *meshName = attrValue.LocalForm();
+
+                        mUsingMeshDefinition = true;
+
+            // retrieve mesh from mesh container
+                        const int meshIdx = mMeshDefinitions[meshName];
+
+                        mCurrentMesh = 
+                                MeshManager::GetSingleton()->FindEntry(meshIdx);
+
+                        //Debug << "retrieving mesh definition: " << mCurrentMeshName << endl;
+                        cout << "u";
+                }
+                else if (attrName == "DEF") //-- a definition of a mesh
+                {
+                        const StrX attrValue(attributes.getValue(i));
+                        const char *meshName = attrValue.LocalForm();
+
+                        // this is only a definition, don't create actual  instance
                         mIsMeshDefinition = true;
+                        
+                        //-- create new mesh definition
+                        mCurrentMesh = MeshManager::GetSingleton()->CreateResource();
+                        
+                        // store the mesh defination in a lookup table
+                        mMeshDefinitions[meshName] = mCurrentMesh->GetId();
+                        cout << "d";
+                }
+                
+                //-- read coordinate indices for current mesh
+                else if (attrName == "coordIndex") 
+                {
                         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));
+
+                        //-- immediate use: create a new mesh using a generic name
+                        if (!mCurrentMesh)
+                        {
+                                mCurrentMesh = MeshManager::GetSingleton()->CreateResource();
+                        }
+
                         // handle coordIndex
                         vertices.clear();
-                        const char *ptr = attrValue.LocalForm();
+                        
                   
                         char *endptr;
@@ -372 +413 @@
 
 void
-X3dParseHandlers::StartMaterial(
-                                AttributeList&  attributes)
-{
-  int len = attributes.getLength();
-  int i;
-  if (!mCurrentMesh->mMaterial)
-    mCurrentMesh->mMaterial = new Material;
-  for (i=0; i < len; i++) {
-    string attrName(StrX(attributes.getName(i)).LocalForm());
-    StrX attrValue(attributes.getValue(i));
-    const char *ptr = attrValue.LocalForm();
-    if (attrName == "diffuseColor") {
-      float r, g, b;
-      if (sscanf(ptr, "%f %f %f", &r, &g, &b) == 3)
-        mCurrentMesh->mMaterial->mDiffuseColor = RgbColor(r, g, b);
-    }
-  }
-}
-
-void
-X3dParseHandlers::StartCoordinate(
-                                  AttributeList&  attributes)
-{
-        int len = attributes.getLength();
+X3dParseHandlers::StartMaterial(AttributeList&  attributes)
+{
+        const int len = attributes.getLength();
+                
+        mCurrentMaterial = MaterialManager::GetSingleton()->CreateResource();
+  
+        for (int i = 0; i < len; ++ i) 
+        {
+                const string attrName(StrX(attributes.getName(i)).LocalForm());
+                
+                const StrX attrValue(attributes.getValue(i));
+                const char *ptr = attrValue.LocalForm();
+
+
+                //-- we use an already defined material
+                if (attrName == "USE")
+                {
+                        //mUsingMaterialDefinition = true;
+                        string matName(ptr);
+
+            // retrieve mesh from mesh container
+                        const int matIdx = mMaterialDefinitions[matName];
+
+                        mCurrentMaterial = 
+                                MaterialManager::GetSingleton()->FindEntry(matIdx);
+
+                        //Debug << "retrieving mesh definition: " << mCurrentMeshName << endl;
+                        cout << "u";
+                }
+                else if (attrName == "DEF") //-- a definition of a material
+                {
+                        //mIsMaterialDefinition = true;
+                        string matName(ptr);
+                
+                        //-- create new material definition
+                        mCurrentMaterial = MaterialManager::GetSingleton()->CreateResource();
+                        // store the mesh defination in a lookup table
+                        mMaterialDefinitions[matName] = mCurrentMaterial->GetId();
+                        cout << "d";
+                }
+                // TODO: support not only diffuse material
+                else if (attrName == "diffuseColor") 
+                {
+                        float r, g, b;
+      
+                        if (sscanf(ptr, "%f %f %f", &r, &g, &b) == 3)
+                                mCurrentMaterial->mDiffuseColor = RgbColor(r, g, b);
+                }
+        }
+}
+
+
+void
+X3dParseHandlers::StartCoordinate(AttributeList&  attributes)
+{
+        const int len = attributes.getLength();
         
         int i;
@@ -402 +475 @@
         for (i=0; i < len; i++) 
         {
-                string attrName(StrX(attributes.getName(i)).LocalForm());
+                const string attrName(StrX(attributes.getName(i)).LocalForm());
           
                 if (attrName == "point") 
@@ -441 +514 @@
                                 vertices.push_back(v);
                         }
-                        
+        
+                        // substitute vertices into current mesh
                         mCurrentMesh->mVertices = vertices;
                 }
@@ -456 +530 @@
   
   if (element == "IndexedFaceSet") {
-    // create a new mesh node in the scene graph
-    StartIndexedFaceSet(attributes);
+          // create a new mesh node in the scene graph
+          StartIndexedFaceSet(attributes);
   }
  
   if (element == "Shape") {
-    cout << "+";
-        mCurrentMesh = new Mesh;
+          cout << "+"; 
+
+          // reset current shape values
+          mCurrentMesh = NULL;
+          mCurrentMaterial = NULL;
+          mCurrentVertexIndices.clear();
+          //mCurrentVertices.clear();
   }
   
-  if (element == "Coordinate") 
-  {
-    if (mCurrentMesh)
-      StartCoordinate(attributes);
+  if (element == "Coordinate") {
+          StartCoordinate(attributes);
   }
-  
-  if (element == "Material") {
-    StartMaterial(attributes);
+
+  // todo
+  if (0 && element == "Material") {
+          StartMaterial(attributes);
   }
   
@@ -479 +557 @@
   }
 
-  mElementCount++;
+  ++ mElementCount;
   mAttrCount += attributes.getLength();
 }
@@ -485 +563 @@
 void
 X3dParseHandlers::characters(const XMLCh* const chars,
-                             const unsigned int length)
+                                                         const unsigned int length)
 {
   mCharacterCount += length;
@@ -492 +570 @@
 void
 X3dParseHandlers::ignorableWhitespace(const XMLCh* const chars,
-                                      const unsigned int length)
+                                                                          const unsigned int length)
 {
   mSpaceCount += length;
@@ -507 +585 @@
 
 
-
 // ---------------------------------------------------------------------------
 //  StdInParseHandlers: Overrides of the SAX ErrorHandler interface
 // ---------------------------------------------------------------------------
+
+
 void
 X3dParseHandlers::error(const SAXParseException& e)
@@ -600 +679 @@
         const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
         parser->parse(filename.c_str());
+        
         const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
         duration = endMillis - startMillis;
@@ -674 +754 @@
 void X3dViewCellsParseHandlers::endElement(const XMLCh* const name)
 {
-  StrX lname(name);
-  string element(lname.LocalForm());
- 
-  if (element == "Shape")
-    EndShape();
+        StrX lname(name);
+
+        string element(lname.LocalForm());
+
+        if (element == "Shape")
+                EndShape();
 }
 
@@ -694 +775 @@
         int i;
         
-        // clear previous vertex indices
-        mCurrentVertexIndices.clear();
-
-
         for (i=0; i < len; i++) 
         {