Changeset 2600 for GTP/trunk/Lib/Vis


Ignore:
Timestamp:
01/16/08 09:38:50 (17 years ago)
Author:
mattausch
Message:

preparing for moving objects (contains compile errors!)

Location:
GTP/trunk/Lib/Vis/Preprocessing
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/Preprocessing/include/SceneGraph.h

    r68 r2600  
    77namespace GtpVisibilityPreprocessor { 
    88   
    9   /** Basic scene graph node, we are interested only in bounding boxes and topology 
    10       of the scene graph */ 
    11   class SceneGraphNode { 
    12   public: 
    13      
    14      
    15   protected: 
    16     MeshContainer mGeometry; 
    17     NodeContainer mChildren; 
    18     AxisAlignedBox3 mBox; 
    19   }; 
     9/** Basic scene graph node, we are interested only in bounding boxes and topology 
     10    of the scene graph  
     11*/ 
     12class SceneGraphNode 
     13{ 
     14public: 
     15        virtual bool IsLeaf() const = NULL; 
     16 
     17protected: 
     18 
     19        AxisAlignedBox3 mBox; 
     20}; 
    2021   
    2122 
    22   /** Scene graph class */ 
    23   class SceneGraph { 
    24      
    25   protected: 
    26     SceneGraphNode *mRoot; 
    27   }; 
     23 
     24/** Basic scene graph node, we are interested only in bounding boxes and topology 
     25  of the scene graph */ 
     26class SceneGraphInterior: public SceneGraphNode 
     27{ 
     28public: 
     29        ~SceneGraphInterior(); 
     30 
     31        virtual bool IsLeaf() const { return false; } 
     32 
     33protected: 
     34 
     35        NodeContainer mChildren; 
     36}; 
     37 
     38 
     39/** Basic scene graph node, we are interested only in bounding boxes and topology 
     40  of the scene graph */ 
     41class SceneGraphLeaf: public SceneGraphNode  
     42{ 
     43public: 
     44        ~SceneGraphLeaf(); 
     45        virtual bool IsLeaf() const { return true; } 
     46 
     47protected: 
     48        MeshContainer mGeometry; 
     49}; 
     50 
     51 
     52/** Scene graph class  
     53*/ 
     54class SceneGraph  
     55{ 
     56protected: 
     57        SceneGraphNode *mRoot; 
     58}; 
    2859   
    2960 

  • GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.cpp

    r2598 r2600  
    1515#include "SamplingStrategy.h" 
    1616#include "Preprocessor.h" 
     17#include "SceneGraph.h" 
    1718 
    1819 
    … …  
    399400        OcclusionQuery::GenQueries(mOcclusionQueries, 10); 
    400401 
    401         CreateVertexArrays(); 
     402        CreateVertexArrays(static_cast<SceneGraphLeaf *>(mSceneGraph->GetRoot())); 
    402403} 
    403404 
    … …  
    484485GlRenderer::RenderScene() 
    485486{ 
    486   Intersectable::NewMail(); 
     487        Intersectable::NewMail(); 
    487488 
    488489#if 1 
    489    
    490   _RenderSceneTrianglesWithDrawArrays(); 
     490 
     491        _RenderSceneTrianglesWithDrawArrays(); 
    491492 
    492493#else 
    493   static int glList = -1; 
    494   if (mUseGlLists) { 
    495         if (glList == -1) { 
    496           glList = glGenLists(1); 
    497           glNewList(glList, GL_COMPILE); 
    498           _RenderSceneTriangles(); 
    499           glEndList(); 
    500         } 
    501          
    502         glCallList(glList); 
    503   } else 
    504         _RenderSceneTriangles(); 
    505          
    506 #endif 
    507   return true; 
     494        static int glList = -1; 
     495        if (mUseGlLists) { 
     496                if (glList == -1) { 
     497                        glList = glGenLists(1); 
     498                        glNewList(glList, GL_COMPILE); 
     499                        _RenderSceneTriangles(); 
     500                        glEndList(); 
     501                } 
     502 
     503                glCallList(glList); 
     504        } else 
     505                _RenderSceneTriangles(); 
     506 
     507#endif 
     508        return true; 
    508509} 
    509510 
    … …  
    17011702#endif 
    17021703 
    1703 void GlRenderer::CreateVertexArrays() 
    1704 { 
    1705         mData = new Vector3[mObjects.size() * 6]; 
    1706         mIndices = new unsigned int[mObjects.size() * 3]; 
    1707  
    1708         size_t offset = mObjects.size() * 3; 
    1709  
    1710         for (size_t i = 0; i < mObjects.size(); ++ i) 
    1711         { 
    1712                 TriangleIntersectable *obj = static_cast<TriangleIntersectable *>(mObjects[i]); 
     1704 
     1705void GlRenderer::CreateVertexArrays(SceneGraphLeaf *leaf) 
     1706{ 
     1707    mData = new Vector3[leaf->mGeometry.size() * 6]; 
     1708        mIndices = new unsigned int[leaf->mGeometry.size() * 3]; 
     1709 
     1710        size_t offset = leaf->mGeometry.size() * 3; 
     1711 
     1712        for (size_t i = 0; i < leaf->mGeometry.size(); ++ i) 
     1713        { 
     1714                TriangleIntersectable *obj = static_cast<TriangleIntersectable *>(leaf->mGeometry[i]); 
    17131715 
    17141716                Triangle3 tri = obj->GetItem(); 
    … …  
    17341736                glNormalPointer(GL_FLOAT, 0, (char *)NULL + offset * sizeof(Vector3)); 
    17351737 
    1736                 glBufferDataARB(GL_ARRAY_BUFFER_ARB, mObjects.size() * 6 * sizeof(Vector3), mData, GL_STATIC_DRAW_ARB); 
     1738                glBufferDataARB(GL_ARRAY_BUFFER_ARB, leaf->mObjects.size() * 6 * sizeof(Vector3), mData, GL_STATIC_DRAW_ARB); 
    17371739                glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); 
    17381740 

  • GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.h

    r2598 r2600  
    2828class BvhNode; 
    2929class SimpleRayContainer; 
     30class SceneGraphLeaf; 
    3031 
    3132struct VssRayContainer; 
    … …  
    222223protected: 
    223224 
    224         void CreateVertexArrays(); 
     225        void CreateVertexArrays(SceneGraphLeaf *leaf); 
    225226        void DeleteVbos(); 
    226227        void EnableDrawArrays(); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjParser.cpp

    r2575 r2600  
    183183static void ProcessMesh(FaceContainer &faces,  
    184184                                                map<int, Vector3> &hashTable, 
    185                                                 SceneGraphNode *root, 
     185                                                SceneGraphLeaf *root, 
    186186                                                vector<FaceParentInfo> *parents) 
    187187{ 
    … …  
    222222 
    223223bool ObjParser::ParseFile(const string filename, 
    224                                                   SceneGraphNode *root, 
     224                                                  SceneGraphLeaf *root, 
    225225                                                  const bool loadMeshes, 
    226226                                                  vector<FaceParentInfo> *parents) 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjParser.h

    r1379 r2600  
    1616   
    1717  virtual bool ParseFile(const std::string filename,  
    18                                                  SceneGraphNode *root, 
     18                                                 SceneGraphLeaf *root, 
    1919                                                 const bool loadMeshes = true, 
    2020                                                 vector<FaceParentInfo> *parents = NULL); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Parser.h

    r1786 r2600  
    1010 
    1111class SceneGraphNode; 
     12class SceneGraphLeaf; 
    1213class Intersectable; 
    1314 
    … …  
    1920 
    2021  virtual bool ParseFile(const std::string filename, 
    21                                                  SceneGraphNode *root, 
     22                                                 SceneGraphLeaf *root, 
    2223                                                 const bool loadMeshes = true, 
    2324                                                 std::vector<FaceParentInfo> *parents = NULL)  

  • GTP/trunk/Lib/Vis/Preprocessing/src/PlyParser.cpp

    r2575 r2600  
    5656bool 
    5757PlyParser::ParseSingleFile(const std::string filename, 
    58                                                    SceneGraphNode *root) 
     58                                                   SceneGraphLeaf *root) 
    5959{ 
    6060  /*** the PLY object ***/ 
    … …  
    260260bool 
    261261PlyParser::ParseFile(const string filename, 
    262                                          SceneGraphNode *root, 
     262                                         SceneGraphLeaf *root, 
    263263                                         const bool loadMeshes, 
    264264                                         vector<FaceParentInfo> *parents) 

  • GTP/trunk/Lib/Vis/Preprocessing/src/PlyParser.h

    r2176 r2600  
    1515   
    1616  bool ParseFile(const std::string filename, 
    17                                  SceneGraphNode *root, 
     17                                 SceneGraphLeaf *root, 
    1818                                 const bool loadMeshes = true, 
    1919                                 std::vector<FaceParentInfo> *parents = NULL); 
    … …  
    2323  bool 
    2424  ParseSingleFile(const std::string filename, 
    25                                   SceneGraphNode *root); 
     25                                  SceneGraphLeaf *root); 
    2626         
    2727}; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp

    r2599 r2600  
    187187 
    188188bool Preprocessor::LoadBinaryObj(const string &filename, 
    189                                                                  SceneGraphNode *root, 
     189                                                                 SceneGraphLeaf *root, 
    190190                                                                 vector<FaceParentInfo> *parents) 
    191191{ 
    … …  
    16171617                                                           const ObjectContainer &preprocessorObjects) 
    16181618{ 
    1619 //      bool success = LoadBinaryObj(filename, mSceneGraph->GetRoot(), &mFaseParents); 
     1619//      bool success = LoadBinaryObj(filename, mSceneGraph->GetRoot(), &mFaceParents); 
    16201620        bool success = LoadBinaryObj(filename, mSceneGraph->GetRoot(), NULL); 
    16211621 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.h

    r2593 r2600  
    3131class RayCaster; 
    3232class GlobalLinesRenderer; 
     33class SceneGraphLeaf; 
    3334 
    3435 
    … …  
    277278 
    278279        bool LoadBinaryObj(const std::string &filename, 
    279                        SceneGraphNode *root, 
     280                       SceneGraphLeaf *root, 
    280281                                           std::vector<FaceParentInfo> *parents); 
    281282 
    282         bool ExportBinaryObj(const std::string &filename, SceneGraphNode *root); 
     283        bool ExportBinaryObj(const std::string &filename, SceneGraphLeaf *root); 
    283284 
    284285        void SetupRay(Ray &ray, const Vector3 &point, 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SceneGraph.cpp

    r2544 r2600  
    3232SceneGraphNode::~SceneGraphNode() 
    3333{ 
    34         CLEAR_CONTAINER(mGeometry); 
     34} 
     35 
     36 
     37SceneGraphLeaf::~SceneGraphLeaf() 
     38{ 
     39    CLEAR_CONTAINER(mGeometry); 
     40} 
     41 
     42 
     43SceneGraphInterior::~SceneGraphInterior() 
     44{ 
    3545        // recursivly delete all children 
    3646        CLEAR_CONTAINER(mChildren); 
    3747} 
     48 
    3849 
    3950 
    … …  
    6172 
    6273 
    63 void SceneGraph::SetRoot(SceneGraphNode *root) 
     74void SceneGraph::SetRoot(SceneGraphLeaf *root) 
    6475{ 
    6576        mRoot = root; 
    … …  
    6778 
    6879 
    69 int 
    70 SceneGraph::CollectObjects(ObjectContainer *instances) 
     80int SceneGraph::CollectObjects(ObjectContainer &instances) 
    7181{ 
    7282        instances->clear(); 
    … …  
    7484 
    7585        stack<SceneGraphNode *> nodeStack; 
    76         nodeStack.push(mRoot); 
    77  
    78         while (!nodeStack.empty()) { 
    79                 SceneGraphNode *node = nodeStack.top(); 
    80                 nodeStack.pop(); 
    81                  
    82                 ObjectContainer::const_iterator mi = node->mGeometry.begin(); 
    83                 for (; mi != node->mGeometry.end(); mi++) 
    84                 { 
    85                         instances->push_back(*mi); 
    86                 } 
    87          
    88                 SceneGraphNodeContainer::iterator ni = node->mChildren.begin(); 
    89                 for (; ni != node->mChildren.end(); ni++) { 
    90                         nodeStack.push(*ni);     
    91                         number++; 
    92                 } 
    93         } 
    94  
    95         return number; 
    96 } 
    97  
    98  
    99 int 
    100 SceneGraph::AssignObjectIds() 
    101 { 
    102         // matt: rather start with id zero 
    103         int id = 0; 
    104         stack<SceneGraphNode *> nodeStack; 
    105  
    10686        nodeStack.push(mRoot); 
    10787 
    … …  
    11191                nodeStack.pop(); 
    11292 
    113                 ObjectContainer::iterator mi = node->mGeometry.begin(); 
    114  
    115                 for (; mi != node->mGeometry.end(); mi ++)  
    116                 { 
    117                         (*mi)->SetId(id ++); 
    118                 } 
    119  
    120                 SceneGraphNodeContainer::iterator ni = node->mChildren.begin(); 
    121                 for (; ni != node->mChildren.end(); ni ++)  
    122                 { 
    123                         nodeStack.push(*ni); 
     93                if (node->IsLeaf()) 
     94                { 
     95                        SceneGraphLeaf *leaf = static_cast<SceneGraphNodeLeaf *>(node); 
     96 
     97                        ObjectContainer::const_iterator mi = leaf->mGeometry.begin(); 
     98 
     99                        for (; mi != leaf->mGeometry.end(); mi++) 
     100                        { 
     101                                instances->push_back(*mi); 
     102                        } 
     103                } 
     104                else 
     105                { 
     106                        SceneGraphInterior *interior = static_cast<SceneGraphNodeInterior *>(node); 
     107                        SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     108 
     109                        for (; ni != interior->mChildren.end(); ++ ni)  
     110                        { 
     111                                nodeStack.push(*ni);     
     112                                number++; 
     113                        } 
     114                } 
     115        } 
     116 
     117        return number; 
     118} 
     119 
     120 
     121int 
     122SceneGraph::AssignObjectIds() 
     123{ 
     124        // matt: rather start with id zero 
     125        int id = 0; 
     126        stack<SceneGraphNode *> nodeStack; 
     127 
     128        nodeStack.push(mRoot); 
     129 
     130        while (!nodeStack.empty())  
     131        { 
     132                SceneGraphNode *node = nodeStack.top(); 
     133                nodeStack.pop(); 
     134 
     135                if (node->IsLeaf) 
     136                { 
     137                        SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node); 
     138                        ObjectContainer::iterator mi = leaf->mGeometry.begin(); 
     139 
     140                        for (; mi != leaf->mGeometry.end(); mi ++)  
     141                        { 
     142                                (*mi)->SetId(id ++); 
     143                        } 
     144                } 
     145                else 
     146                { 
     147                        SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node); 
     148                        SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     149                        for (; ni != node->mChildren.end(); ni ++)  
     150                        { 
     151                                nodeStack.push(*ni); 
     152                        } 
    124153                } 
    125154        } 
    … …  
    132161SceneGraph::GetStatistics(int &intersectables, int &faces) const 
    133162{ 
    134   stack<SceneGraphNode *> nodeStack; 
    135    
    136   nodeStack.push(mRoot); 
    137   faces = 0; 
     163        stack<SceneGraphNode *> nodeStack; 
     164 
     165        nodeStack.push(mRoot); 
     166        faces = 0; 
    138167        intersectables = 0; 
    139   while (!nodeStack.empty()) { 
    140     SceneGraphNode *node = nodeStack.top(); 
    141     nodeStack.pop(); 
    142                  
    143     ObjectContainer::const_iterator mi = node->mGeometry.begin(); 
    144     for (; mi != node->mGeometry.end(); mi++) { 
     168        while (!nodeStack.empty()) { 
     169                SceneGraphNode *node = nodeStack.top(); 
     170                nodeStack.pop(); 
     171 
     172                ObjectContainer::const_iterator mi = node->mGeometry.begin(); 
     173                for (; mi != node->mGeometry.end(); mi++) { 
    145174                        intersectables++; 
    146175                        faces += (*mi)->NumberOfFaces(); 
    147176                } 
    148      
    149     SceneGraphNodeContainer::iterator ni = node->mChildren.begin(); 
    150     for (; ni != node->mChildren.end(); ni++) { 
    151       nodeStack.push(*ni); 
    152     } 
    153   } 
     177 
     178                SceneGraphNodeContainer::iterator ni = node->mChildren.begin(); 
     179                for (; ni != node->mChildren.end(); ni++) { 
     180                        nodeStack.push(*ni); 
     181                } 
     182        } 
     183 
     184} 
     185 
     186 
     187void SceneGraphInterior::UpdateBox() 
     188{ 
     189        AxisAlignedBox3 box; 
     190        box.Initialize(); 
     191 
     192        ObjectContainer::const_iterator mi = mGeometry.begin(); 
     193        for (; mi != mGeometry.end(); mi++) 
     194                box.Include((*mi)->GetBox()); 
     195 
     196        mBox = box; 
     197} 
     198 
     199 
     200void SceneGraphLeaf::UpdateBox() 
     201{ 
     202        AxisAlignedBox3 box; 
     203 
     204        box.Initialize(); 
     205 
     206        SceneGraphNodeContainer::iterator ni = mChildren.begin(); 
    154207         
    155 } 
    156  
    157  
    158 void 
    159 SceneGraphNode::UpdateBox() 
    160 { 
    161   AxisAlignedBox3 box; 
    162    
    163   box.Initialize(); 
    164    
    165   ObjectContainer::const_iterator mi = mGeometry.begin(); 
    166   for (; mi != mGeometry.end(); mi++) 
    167         box.Include((*mi)->GetBox()); 
    168    
    169   SceneGraphNodeContainer::iterator ni = mChildren.begin(); 
    170   for (; ni != mChildren.end(); ni++) { 
    171         (*ni)->UpdateBox(); 
    172         box.Include((*ni)->mBox); 
    173   } 
    174    
    175   mBox = box; 
    176 } 
     208        for (; ni != mChildren.end(); ++ ni)  
     209        { 
     210                (*ni)->UpdateBox(); 
     211                box.Include((*ni)->mBox); 
     212        } 
     213 
     214        mBox = box; 
     215} 
     216 
    177217 
    178218 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SceneGraph.h

    r2176 r2600  
    33 
    44#include <string> 
    5 // 
    6  
    75#include "Containers.h" 
    86#include "AxisAlignedBox3.h" 
    97 
     8 
    109namespace GtpVisibilityPreprocessor { 
    11    
     10 
     11 
    1212/** Basic scene graph node, we are interested only in bounding boxes and topology 
    1313    of the scene graph  
    14         */ 
    15 class SceneGraphNode { 
     14*/ 
     15class SceneGraphNode  
     16{ 
    1617public: 
    17   ObjectContainer mGeometry; 
    18   SceneGraphNodeContainer mChildren; 
    19   AxisAlignedBox3 mBox; 
    20   ~SceneGraphNode(); 
    21   void UpdateBox(); 
     18 
     19        virtual ~SceneGraphNode(); 
     20        virtual bool IsLeaf() const = 0; 
     21 
     22        virtual void UpdateBox() = 0; 
     23 
     24//protected: 
     25 
     26        AxisAlignedBox3 mBox; 
    2227}; 
     28   
     29 
     30 
     31/** Scene graph interior node. 
     32*/ 
     33class SceneGraphInterior: public SceneGraphNode  
     34{ 
     35public: 
     36        virtual bool IsLeaf() const { return false; } 
     37        virtual void UpdateBox(); 
     38 
     39//protected: 
     40 
     41        NodeContainer mChildren; 
     42}; 
     43 
     44 
     45/** Scene graph leaf node. 
     46*/ 
     47class SceneGraphLeaf: public SceneGraphNode  
     48{ 
     49public: 
     50 
     51        virtual bool IsLeaf() const { return true; } 
     52        virtual void UpdateBox(); 
     53 
     54//protected: 
     55 
     56        MeshContainer mGeometry; 
     57}; 
     58 
    2359 
    2460 

  • GTP/trunk/Lib/Vis/Preprocessing/src/UnigraphicsParser.cpp

    r2572 r2600  
    4646bool 
    4747UnigraphicsParser::ParseFile(const string filename, 
    48                                                          SceneGraphNode *root, 
     48                                                         SceneGraphLeaf *root, 
    4949                                                         const bool loadMeshes, 
    5050                                                         vector<FaceParentInfo> *parents) 

  • GTP/trunk/Lib/Vis/Preprocessing/src/UnigraphicsParser.h

    r1379 r2600  
    1616   
    1717  virtual bool ParseFile(const std::string filename,  
    18                                                  SceneGraphNode *root,  
     18                                                 SceneGraphLeaf *root,  
    1919                                                 const bool loadMeshes = false, 
    2020                                                 vector<FaceParentInfo> *parents = NULL); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

    r2599 r2600  
    16881688                // create temporary scene graph for loading the view cells geometry 
    16891689                // note: delete the meshes as they are created two times for transformed mesh instances. 
    1690                 SceneGraphNode *root = new SceneGraphNode(); 
     1690                SceneGraphNode *root = new SceneGraphLeaf(); 
    16911691                const bool success = parser.ParseFile(filename, root, true); 
    16921692                 

  • GTP/trunk/Lib/Vis/Preprocessing/src/X3dExporter.cpp

    r2176 r2600  
    190190  stream<<"<Group>"<<endl; 
    191191 
    192   SceneGraphNodeContainer::iterator ni = node->mChildren.begin(); 
    193   for (; ni != node->mChildren.end(); ni++) 
    194     ExportSceneNode(*ni); 
    195    
    196    
    197   ObjectContainer::const_iterator mi = node->mGeometry.begin(); 
    198   for (; mi != node->mGeometry.end(); mi++) { 
    199     // export the transform... 
    200     ExportIntersectable(*mi); 
    201   } 
    202    
     192  if (!node->IsLeaf()) 
     193  { 
     194          SceneGraphInterior *interior = static_cast<SceneGraphInterior *>(node); 
     195 
     196          SceneGraphNodeContainer::iterator ni = interior->mChildren.begin(); 
     197          for (; ni != interior->mChildren.end(); ni++) 
     198                  ExportSceneNode(*ni); 
     199  } 
     200  else 
     201  { 
     202          SceneGraphLeaf *leaf = static_cast<SceneGraphLeaf *>(node); 
     203 
     204          ObjectContainer::const_iterator mi = leaf->mGeometry.begin(); 
     205          for (; mi != leaf->mGeometry.end(); ++ mi)  
     206          { 
     207                  // export the transform... 
     208                  ExportIntersectable(*mi); 
     209          } 
     210  } 
     211 
    203212  stream<<"</Group>"<<endl; 
    204213 

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

    r2539 r2600  
    8585//  StdInParseHandlers: Constructors and Destructor 
    8686// --------------------------------------------------------------------------- 
    87 X3dParseHandlers::X3dParseHandlers(SceneGraphNode *root,  
     87X3dParseHandlers::X3dParseHandlers(SceneGraphLeaf *root,  
    8888                                                                   const bool loadMeshes): 
    8989  mElementCount(0) 
    … …  
    637637bool 
    638638X3dParser::ParseFile(const string filename, 
    639                                          SceneGraphNode *root, 
     639                                         SceneGraphLeaf *root, 
    640640                                         const bool loadMeshes, 
    641641                                         vector<FaceParentInfo> *parents) 

  • GTP/trunk/Lib/Vis/Preprocessing/src/X3dParser.h

    r2176 r2600  
    1515        X3dParser(); 
    1616   
    17         bool ParseFile( 
    18                                    const std::string filename,  
    19                                    SceneGraphNode *root,  
     17        bool ParseFile(const std::string filename,  
     18                                   SceneGraphLeaf *root,  
    2019                                   const bool loadMeshes = false, 
    2120                                   vector<FaceParentInfo> *parents = NULL); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/X3dParserXerces.h

    r2176 r2600  
    1717 
    1818class SceneGraphNode; 
     19class SceneGraphLeaf; 
    1920class Mesh; 
    2021class Material; 
    … …  
    4142  //  Constructors and Destructor 
    4243  // ----------------------------------------------------------------------- 
    43   X3dParseHandlers(SceneGraphNode *root, const bool loadMeshes = false); 
     44  X3dParseHandlers(SceneGraphLeaf *root, const bool loadMeshes = false); 
    4445  ~X3dParseHandlers(); 
    4546   
    … …  
    7879  void resetDocument(); 
    7980 
    80   SceneGraphNode *mCurrentNode; 
     81  SceneGraphLeaf *mCurrentNode; 
    8182  
    8283  vector<VertexIndexContainer> mCurrentVertexIndices; 
Note: See TracChangeset for help on using the changeset viewer.