Examples/Tutorial/12traversal2.cpp

   1 // all needed include files
   2 #ifdef OSG_BUILD_ACTIVE
   3 #include <OSGGLUT.h>
   4 #include <OSGConfig.h>
   5 #include <OSGSimpleGeometry.h>
   6 #include <OSGGLUTWindow.h>
   7 #include <OSGSimpleSceneManager.h>
   8
   9 #include <OSGSceneFileHandler.h>
  10 #include <OSGNameAttachment.h>
  11
  12 #include <OSGGraphOpSeq.h>
  13 #include <OSGSplitGraphOp.h>
  14 #include <OSGVerifyGeoGraphOp.h>
  15 #include <OSGSharePtrGraphOp.h>
  16 #else
  17 #include <OpenSG/OSGGLUT.h>
  18 #include <OpenSG/OSGConfig.h>
  19 #include <OpenSG/OSGSimpleGeometry.h>
  20 #include <OpenSG/OSGGLUTWindow.h>
  21 #include <OpenSG/OSGSimpleSceneManager.h>
  22
  23 #include <OpenSG/OSGSceneFileHandler.h>
  24 #include <OpenSG/OSGNameAttachment.h>
  25
  26 #include <OpenSG/OSGGraphOpSeq.h>
  27 #include <OpenSG/OSGSplitGraphOp.h>
  28 #include <OpenSG/OSGVerifyGeoGraphOp.h>
  29 #include <OpenSG/OSGSharePtrGraphOp.h>
  30 #endif
  31
  32 OSG::SimpleSceneManagerRefPtr mgr;
  33 OSG::NodeRecPtr               scene;
  34
  35 // A simple class that counts the number of entered nodes
  36 class counter
  37 {
  38     public:
  39         //constructor
  40         counter(void)
  41         {
  42             mCount = 0;
  43         }
  44
  45         //method that will be called when entering
  46         //a new node
  47         OSG::Action::ResultE enter(OSG::Node * const)
  48         {
  49             mCount++;
  50             return OSG::Action::Continue;
  51         }
  52
  53         OSG::UInt16 getCount(void)
  54         {
  55             return mCount;
  56         }
  57
  58         void reset(void)
  59         {
  60             mCount = 0;
  61         }
  62
  63     private:
  64         OSG::UInt16 mCount;
  65 };
  66
  67 int setupGLUT(int *argc, char *argv[]);
  68
  69 //This is the function that will be called when a node
  70 //is entered during traversal.
  71 OSG::Action::ResultE enter(OSG::Node * const node)
  72 {
  73     if (getName(node))
  74     {
  75         std::cout << getName(node) << std::endl;
  76     }
  77     else
  78     {
  79         std::cout << "No name was set!" << std::endl;
  80     }
  81
  82     return OSG::Action::Continue;
  83 }
  84
  85 //This function will test if the core is of type
  86 //geometry and if it is, it will print the node's
  87 //name
  88 OSG::Action::ResultE isGeometry(OSG::Node * const node)
  89 {
  90     // this tests if the core is derived from geometry
  91     if (node->getCore()->getType().isDerivedFrom(OSG::Geometry::getClassType()))
  92     {
  93         if (getName(node))
  94         {
  95             std::cout << "Found a geometry core stored in " << getName(node)
  96                       << std::endl;
  97         }
  98         else
  99         {
 100             std::cout << "Found a geometry core but node has no name"
 101                       << std::endl;
 102         }
 103     }
 104
 105     return OSG::Action::Continue;
 106 }
 107
 108
 109 OSG::NodeTransitPtr createScenegraph(const char* filename)
 110 {
 111     //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE);
 112
 113     // define the Graph Op Sequence here
 114     OSG::GraphOpSeqRefPtr graphOperator = OSG::GraphOpSeq::create();
 115     OSG::GraphOpRefPtr    go;
 116
 117     //first we verify the geometry
 118     go = OSG::VerifyGeoGraphOp::create();
 119     graphOperator->addGraphOp(go);
 120     //merge identical field containers
 121     go = OSG::SharePtrGraphOp::create();
 122     graphOperator->addGraphOp(go);
 123     //verify again
 124     go = OSG::VerifyGeoGraphOp::create();
 125     graphOperator->addGraphOp(go);
 126
 127     std::cout << "Loading " << filename << " now" << std::endl;
 128
 129     OSG::NodeRecPtr n =
 130         OSG::SceneFileHandler::the()->read(filename, graphOperator);
 131
 132     //we check the result
 133     if(n == NULL)
 134     {
 135         std::cout << "Loading the specified file was not possible!"
 136                   << std::endl;
 137         return OSG::NodeTransitPtr();
 138     }
 139
 140     return OSG::NodeTransitPtr(n);
 141 }
 142
 143 int main(int argc, char **argv)
 144 {
 145     OSG::osgInit(argc,argv);
 146
 147     {
 148         int winid = setupGLUT(&argc, argv);
 149         OSG::GLUTWindowRecPtr gwin = OSG::GLUTWindow::create();
 150         gwin->setGlutId(winid);
 151         gwin->init();
 152
 153         if (argc > 1)
 154             scene = createScenegraph(argv[1]);
 155         else
 156             scene = createScenegraph("Data/brick_quads.wrl");
 157
 158         mgr = OSG::SimpleSceneManager::create();
 159         mgr->setWindow(gwin );
 160         mgr->setRoot  (scene);
 161         mgr->showAll();
 162
 163         OSG::commitChanges();
 164     }
 165
 166     glutMainLoop();
 167
 168     return 0;
 169 }
 170
 171 void reshape(int w, int h)
 172 {
 173     mgr->resize(w, h);
 174     glutPostRedisplay();
 175 }
 176
 177 void display(void)
 178 {
 179     mgr->redraw();
 180 }
 181
 182 void mouse(int button, int state, int x, int y)
 183 {
 184     if (state)
 185         mgr->mouseButtonRelease(button, x, y);
 186     else
 187         mgr->mouseButtonPress(button, x, y);
 188
 189     glutPostRedisplay();
 190 }
 191
 192 void motion(int x, int y)
 193 {
 194     mgr->mouseMove(x, y);
 195     glutPostRedisplay();
 196 }
 197
 198 void keyboard(unsigned char k, int x, int y)
 199 {
 200     switch(k)
 201     {
 202     case 27:
 203     {
 204         // clean up global variables
 205         scene = NULL;
 206         mgr   = NULL;
 207
 208         OSG::osgExit();
 209         exit(1);
 210     }
 211     break;
 212
 213     // this will print the names of all nodes
 214     // in the whole graph
 215     case 'p':
 216     {
 217         std::cout << std::endl << std::endl;
 218         std::cout << "Printing all node names";
 219         std::cout << "---------------------------------------";
 220         std::cout << std::endl << std::endl;
 221
 222         // now we invoke the traversal
 223         traverse(scene, enter);
 224     }
 225     break;
 226
 227     // this will only print the names of nodes
 228     // which have a geometry core
 229     case 'g':
 230     {
 231         std::cout << std::endl << std::endl;
 232         std::cout << "Printing all geometry nodes";
 233         std::cout << "---------------------------------------";
 234         std::cout << std::endl << std::endl;
 235
 236         // traverse the graph
 237         traverse(scene, isGeometry);
 238     }
 239     break;
 240
 241     case 's':
 242     {
 243         std::cout << "Splitting Graph now...";
 244
 245         counter c;
 246
 247         traverse(scene, boost::bind(&counter::enter, &c, _1));
 248
 249         std::cout << "Number of nodes before splitting: " << c.getCount()
 250                   << std::endl;
 251
 252         OSG::SplitGraphOpRefPtr spo = OSG::SplitGraphOp::create();
 253         spo->setMaxPolygons(50);
 254         spo->traverse(scene);
 255
 256         std::cout << "done" << std::endl;
 257
 258         c.reset();
 259
 260         traverse(scene, boost::bind(&counter::enter, &c, _1));
 261
 262         std::cout << "Number of nodes after splitting: " << c.getCount()
 263                   << std::endl;
 264     }
 265     break;
 266     }
 267 }
 268
 269 int setupGLUT(int *argc, char *argv[])
 270 {
 271     glutInit(argc, argv);
 272     glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
 273
 274     int winid = glutCreateWindow("OpenSG First Application");
 275
 276     glutDisplayFunc(display);
 277     glutMouseFunc(mouse);
 278     glutMotionFunc(motion);
 279     glutReshapeFunc(reshape);
 280     glutIdleFunc(display);
 281     glutKeyboardFunc(keyboard);
 282
 283     return winid;
 284 }