Examples/Tutorial/12traversal3.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) : mCount(0)
  41         {
  42         }
  43
  44         //method that will be called when entering
  45         //a new node
  46         OSG::Action::ResultE enter(OSG::Node * const)
  47         {
  48             mCount++;
  49             return OSG::Action::Continue;
  50         }
  51
  52         OSG::UInt16 getCount(void)
  53         {
  54             return mCount;
  55         }
  56
  57         void reset(void)
  58         {
  59             mCount = 0;
  60         }
  61
  62     private:
  63         OSG::UInt16 mCount;
  64 };
  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 OSG::NodeTransitPtr createScenegraph(const char* filename)
 109 {
 110     OSG::NodeRecPtr n = OSG::SceneFileHandler::the()->read(filename);
 111
 112     //we check the result
 113     if(n == NULL)
 114     {
 115         std::cout << "Loading the specified file was not possible!"
 116                 << std::endl;
 117         return OSG::NodeTransitPtr();
 118     }
 119
 120     return OSG::NodeTransitPtr(n);
 121 }
 122
 123 int main(int argc, char **argv)
 124 {
 125     OSG::osgInit(argc,argv);
 126
 127     {
 128         int winid = setupGLUT(&argc, argv);
 129         OSG::GLUTWindowRecPtr gwin= OSG::GLUTWindow::create();
 130         gwin->setGlutId(winid);
 131         gwin->init();
 132
 133         if (argc > 1)
 134             scene = createScenegraph(argv[1]);
 135         else
 136             scene = createScenegraph("Data/brick_quads.wrl");
 137
 138         mgr = OSG::SimpleSceneManager::create();
 139         mgr->setWindow(gwin );
 140         mgr->setRoot  (scene);
 141         mgr->showAll();
 142
 143         OSG::commitChanges();
 144     }
 145
 146     glutMainLoop();
 147
 148     return 0;
 149 }
 150
 151 void reshape(int w, int h)
 152 {
 153     mgr->resize(w, h);
 154     glutPostRedisplay();
 155 }
 156
 157 void display(void)
 158 {
 159     mgr->redraw();
 160 }
 161
 162 void mouse(int button, int state, int x, int y)
 163 {
 164     if (state)
 165     {
 166         mgr->mouseButtonRelease(button, x, y);
 167     }
 168     else
 169     {
 170         mgr->mouseButtonPress(button, x, y);
 171
 172         OSG::Line                  ray  = mgr->calcViewRay(x, y);
 173         OSG::IntersectActionRefPtr iAct = OSG::IntersectAction::create();
 174         iAct->setLine(ray);
 175         iAct->apply(scene);
 176
 177         if(iAct->didHit())
 178         {
 179             OSG::Pnt3f p = iAct->getHitPoint();
 180             std::cout << "Hit point : " << p[0] << " " << p[1] << " " << p[2]
 181                       << std::endl;
 182             OSG::NodeRecPtr n      = iAct->getHitObject();
 183             OSG::NodeRecPtr parent = n->getParent();
 184
 185             parent->subChild(n);
 186         }
 187
 188         iAct = NULL;
 189     }
 190
 191     glutPostRedisplay();
 192 }
 193
 194 void motion(int x, int y)
 195 {
 196     mgr->mouseMove(x, y);
 197     glutPostRedisplay();
 198 }
 199
 200 void keyboard(unsigned char k, int x, int y)
 201 {
 202     switch(k)
 203     {
 204     case 27:
 205     {
 206         // clean up global variables
 207         scene = NULL;
 208         mgr   = NULL;
 209
 210         OSG::osgExit();
 211         exit(1);
 212     }
 213     break;
 214
 215     // this will print the names of all nodes
 216     // in the whole graph
 217     case 'p':
 218     {
 219         std::cout << std::endl << std::endl;
 220         std::cout << "Printing all node names";
 221         std::cout << "---------------------------------------";
 222         std::cout << std::endl << std::endl;
 223
 224         // now we invoke the traversal
 225         traverse(scene, enter);
 226     }
 227     break;
 228
 229     // this will only print the names of nodes
 230     // which have a geometry core
 231     case 'g':
 232     {
 233         std::cout << std::endl << std::endl;
 234         std::cout << "Printing all geometry nodes";
 235         std::cout << "---------------------------------------";
 236         std::cout << std::endl << std::endl;
 237
 238         // traverse the graph
 239         traverse(scene, isGeometry);
 240     }
 241     break;
 242
 243     case 's':
 244         std::cout << "Splitting Graph now...";
 245
 246         counter c;
 247
 248         traverse(scene, boost::bind(&counter::enter, &c, _1));
 249
 250         std::cout << "Number of nodes before splitting: " << c.getCount()
 251                   << std::endl;
 252
 253         OSG::SplitGraphOpRefPtr spo = OSG::SplitGraphOp::create();
 254         spo->setMaxPolygons(50);
 255         spo->traverse(scene);
 256
 257         std::cout << "done" << std::endl;
 258
 259         c.reset();
 260
 261         traverse(scene, boost::bind(&counter::enter, &c, _1));
 262
 263         std::cout << "Number of nodes after splitting: " << c.getCount()
 264                   << std::endl;
 265     break;
 266
 267     }
 268 }
 269
 270 int setupGLUT(int *argc, char *argv[])
 271 {
 272     glutInit(argc, argv);
 273     glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
 274
 275     int winid = glutCreateWindow("OpenSG First Application");
 276
 277     glutDisplayFunc(display);
 278     glutMouseFunc(mouse);
 279     glutMotionFunc(motion);
 280     glutReshapeFunc(reshape);
 281     glutIdleFunc(display);
 282     glutKeyboardFunc(keyboard);
 283
 284     return winid;
 285 }