Source/WindowSystem/X/testParCullDraw.cpp

   1 // Parallel Culling/Drawing
   2 // This is a very ugly hack and more a tesbed than an actually usable
   3 // application. For that it's much too brittle...
   4
   5 #define OSG_LOG_MODULE "testParCullDraw"
   6
   7 #include <fstream>
   8
   9 // GLUT is used for window handling
  10 #include "OSGGLUT.h"
  11
  12 // General OpenSG configuration, needed everywhere
  13 #include "OSGConfig.h"
  14
  15 #include "OSGXWindow.h"
  16 #include "OSGPassiveWindow.h"
  17
  18 // A little helper to simplify scene management and interaction
  19 #include "OSGSimpleSceneManager.h"
  20
  21 // Methods to create simple geometry: boxes, spheres, tori etc.
  22 #include "OSGSimpleGeometry.h"
  23
  24 #include "OSGGradientBackground.h"
  25
  26 #include "OSGImageFileHandler.h"
  27 #include "OSGPathHandler.h"
  28
  29 #include "OSGSceneFileHandler.h"
  30 #include "OSGThread.h"
  31 #include "OSGBarrier.h"
  32
  33 #include "OSGRenderAction.h"
  34
  35
  36 OSG::SimpleSceneManager  *mgr;
  37 OSG::XWindowRecPtr        xwin;
  38 OSG::PassiveWindowRecPtr  pwin;
  39
  40 OSG::NodeRecPtr scene = NULL;
  41
  42 // Threading stuff
  43
  44 bool doThreading = true;
  45 bool doParDraw   = true;
  46
  47 OSG::UInt16 numBuf = 2;
  48
  49 // The three threads
  50 OSG::Thread *appthread, *cullthread, *drawthread;
  51
  52 // barriers to sync app, cull and draw
  53 OSG::Barrier *cullenter, *cullleave;
  54 OSG::Barrier *drawenter;
  55 OSG::Barrier *exitB;
  56
  57 // Action to use
  58 OSG::RenderAction *rentravact;
  59
  60 bool doExit = false;
  61 OSG::UInt16 numthreads;
  62
  63 // Do the drawing for one frame
  64 // extra function to test in sequential
  65
  66 #if 0
  67 void doDraw(void)
  68 {
  69     static int curBuf = 0;
  70
  71     pwin->frameInit();
  72     FNOTICE(("doDraw:start Draw buf %d\n", curBuf));
  73     rentravact->drawBuffer(curBuf);
  74     FNOTICE(("doDraw:finished Draw buf %d\n", curBuf));
  75     xwin->swap();
  76     pwin->frameExit();
  77     FNOTICE(("doDraw:swapped buf %d\n", curBuf));
  78
  79     if(0)
  80     {
  81         std::string stats;
  82
  83         if(rentravact->getStatCollector() != NULL)
  84             rentravact->getStatCollector()->putToString(stats);
  85
  86         std::cout << stats << std::endl;
  87     }
  88
  89     curBuf = (curBuf + 1) % numBuf;
  90 }
  91
  92 // Drawer function executed in a third thread
  93
  94 void draw(void* data)
  95 {
  96     // need my own Display connection
  97     Display *dpy = XOpenDisplay(NULL);
  98     xwin->setDisplay(dpy);
  99     xwin->init();
 100
 101     while(!doExit)
 102     {
 103         FNOTICE(("draw:enter Barrier\n"));
 104         // Wait for the cull thread to finish culling
 105         drawenter->enter(2);
 106         FNOTICE(("draw:left Barrier\n"));
 107
 108         // Do the drawing
 109         doDraw();
 110     };
 111     FNOTICE(("draw: waiting for exit\n"));
 112     exitB->enter(numthreads);
 113     FNOTICE(("draw: exit\n"));
 114 }
 115
 116 // Do the culling for one frame
 117 // extra function to test in sequential
 118
 119 void doCull(void)
 120 {
 121     static int curBuf = 0;
 122
 123     rentravact->setCurrentBuffer(curBuf);
 124     FNOTICE(("doCull:start culling buf %d\n", curBuf));
 125     pwin->renderAllViewports(rentravact);
 126     FNOTICE(("doCull:done culling buf %d\n", curBuf));
 127
 128     curBuf = (curBuf + 1) % numBuf;
 129 }
 130
 131 // Culler function executed in a second thread
 132
 133 void cull(void* data)
 134 {
 135     appthread->getChangeList()->applyAndClear();
 136     if(!doParDraw)
 137     {
 138         // need my own Display connection
 139         Display *dpy = XOpenDisplay(NULL);
 140         xwin->setDisplay(dpy);
 141         xwin->init();
 142     }
 143     else
 144     {
 145         drawthread = Thread::get("drawThread");
 146         drawthread->runFunction(draw, 1, NULL);
 147     }
 148
 149     while(!doExit)
 150     {
 151         // Wait for the app thread to commit changes
 152         FNOTICE(("cull:enter barrier\n"));
 153         cullenter->enter(2);
 154
 155         //Sync them into my aspect
 156         FNOTICE(("cull:start sync\n"));
 157         appthread->getChangeList()->applyAndClear();
 158         Thread::getCurrentChangeList()->commitChanges();
 159         FNOTICE(("cull:finished sync\n"));
 160         // Tell the App thread to continue
 161         cullleave->enter(2);
 162
 163         // Do the culling
 164         doCull();
 165
 166         // Now draw
 167         if(doParDraw)
 168         {
 169             // Wait for drawer to finish last frame
 170             FNOTICE(("cull:wait for draw\n"));
 171             drawenter->enter(2);
 172             FNOTICE(("cull:got draw\n"));
 173         }
 174         else
 175         {
 176             doDraw();
 177         }
 178     }
 179     FNOTICE(("cull: waiting for exit\n"));
 180     exitB->enter(numthreads);
 181     FNOTICE(("cull: exit\n"));
 182 }
 183
 184 // Standard GLUT callback functions
 185 void display( void )
 186 {
 187     Thread::getCurrentChangeList()->commitChanges();
 188     mgr->update();
 189     if(doThreading)
 190     {
 191         // Wait for the cull thrad to finish culling the last frame
 192         cullenter->enter(2);
 193         // Wait for it to do the sync
 194         cullleave->enter(2);
 195         // Now continue apping
 196     }
 197     else
 198     {
 199         doCull();
 200         doDraw();
 201     }
 202 }
 203
 204 void reshape( int w, int h )
 205 {
 206     mgr->resize( w, h );
 207 }
 208
 209 void
 210 motion(int x, int y)
 211 {
 212     mgr->mouseMove( x, y );
 213 }
 214
 215 void
 216 mouse(int button, int state, int x, int y)
 217 {
 218     if ( state )
 219         mgr->mouseButtonRelease( button, x, y );
 220     else
 221         mgr->mouseButtonPress( button, x, y );
 222 }
 223
 224
 225 // Open X Window
 226
 227 int wait_for_map_notify(Display *, XEvent *event, char *arg)
 228 {
 229     return( event->type == MapNotify && event->xmap.window == ::Window(arg) );
 230 }
 231
 232 #ifdef OSG_DEBUG_OLD_C_CASTS
 233 #ifdef DefaultScreen
 234 #undef DefaultScreen
 235 #endif
 236 #ifdef ScreenOfDisplay
 237 #undef ScreenOfDisplay
 238 #endif
 239
 240 #define DefaultScreen(dpy)((reinterpret_cast<_XPrivDisplay>(dpy))->default_screen)
 241
 242 #define ScreenOfDisplay(dpy, scr)(&(reinterpret_cast<_XPrivDisplay>(dpy))->screens[scr])
 243 #endif
 244
 245 Display *openWindow(XWindow *xwin, char **argv, int &argc)
 246 {
 247     static int dblBuf[] = {GLX_RGBA, GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER,
 248                            None};
 249     static int snglBuf[] = {GLX_RGBA, GLX_DEPTH_SIZE, 16, None};
 250
 251     DisplayP      dpy;
 252     X11Window     hwin;
 253
 254     XVisualInfo   *vi;
 255     Colormap      cmap;
 256     XEvent        event;
 257     XSetWindowAttributes swa;
 258
 259     dpy = XOpenDisplay(NULL);
 260     if (dpy == NULL)
 261     {
 262         std::cerr << "Error: Could not open display!" << std::endl;
 263     }
 264
 265     int dummy;
 266     if( ! glXQueryExtension( dpy, &dummy, &dummy ) )
 267     {
 268         std::cerr << "Error: X server has no OpenGL GLX extension" << std::endl;
 269     }
 270
 271     vi = glXChooseVisual( dpy, DefaultScreen(dpy), dblBuf );
 272     if ( vi == NULL )
 273     {
 274
 275        vi = glXChooseVisual( dpy, DefaultScreen(dpy), snglBuf );
 276        if (vi == NULL)
 277        {
 278            std::cerr << "no RGB visual with depth buffer" << std::endl;
 279        }
 280     }
 281     if (vi->c_class != TrueColor)
 282     {
 283         std::cerr << "TrueColor visual required for this program" << std::endl;
 284     }
 285
 286     cmap = XCreateColormap( dpy,
 287                             RootWindow(dpy, vi->screen),
 288                             vi->visual,
 289                             AllocNone );
 290     swa.colormap = cmap;
 291     swa.border_pixel = 0;
 292     swa.event_mask = ExposureMask |
 293                      ButtonPressMask |
 294                      ButtonReleaseMask |
 295                      KeyPressMask |
 296                      Button1MotionMask |
 297                      Button2MotionMask |
 298                      Button3MotionMask |
 299                      StructureNotifyMask;
 300
 301     // Create Window
 302
 303     // Create a Window and connect it to the main display dpy
 304     hwin = XCreateWindow( dpy,
 305                           RootWindow(dpy, vi->screen),
 306                           0, 0, 300, 300,
 307                           0,
 308                           vi->depth,
 309                           InputOutput,
 310                           vi->visual,
 311                           CWBorderPixel | CWColormap | CWEventMask,
 312                           &swa );
 313
 314     XSetStandardProperties(dpy, hwin, "testWindowX", "testWindowX", None, argv, argc, NULL);
 315
 316     xwin->setDisplay ( dpy );
 317     xwin->setWindow ( hwin );
 318
 319     XMapWindow(dpy, hwin);
 320     XIfEvent(dpy, &event, wait_for_map_notify, reinterpret_cast<char *>(hwin));
 321
 322     return dpy;
 323 }
 324
 325 // Initialize GLUT & OpenSG and set up the scene
 326 int main (int argc, char **argv)
 327 {
 328     // OSG init
 329     osgInit(argc,argv);
 330
 331     // Add Timestamps to log output
 332     osgLog().addHeaderElem(LOG_TIMESTAMP_HEADER);
 333
 334     // Passive Window for culling
 335     pwin = PassiveWindow::create();
 336
 337     Real32 cnear = -1., cfar = -1.;
 338
 339     // check command line options
 340     while(argc > 1 && argv[1][0] == '-')
 341     {
 342         switch(argv[1][1])
 343         {
 344         case 's':   doThreading = false;
 345                     break;
 346         case 'c':   doParDraw = false;
 347                     break;
 348         case 'n':   cnear = atof(argv[2]);
 349                     argc --;
 350                     argv ++;
 351                     break;
 352         case 'f':   cfar = atof(argv[2]);
 353                     argc --;
 354                     argv ++;
 355                     break;
 356         default:    FFATAL(("Unknown option '%s'!\n", argv[1]));
 357                     exit(1);
 358         }
 359         argc --;
 360         argv ++;
 361     }
 362
 363     // create the scene
 364
 365     const char *fileName = (argc > 1) ? argv[1] : "None";
 366
 367     FNOTICE(("Reading file %s...\n",fileName));
 368
 369     scene = SceneFileHandler::the()->read(fileName, NULL);
 370
 371     FNOTICE(("File read\n"));
 372
 373     if(scene == NULL)
 374     {
 375         std::cerr << "Error loading " << fileName << "!" << std::endl;
 376
 377         scene = makeCoredNode<Group>();
 378
 379         SimpleMaterialUnrecPtr sm = SimpleMaterial::create();
 380
 381         sm->setDiffuse(Color3f(0,1,1));
 382         sm->setSpecular(Color3f(1,1,1));
 383         sm->setTransparency(.5);
 384
 385         GeometryUnrecPtr geo = makeTorusGeo( .5, 2, 16, 16 );
 386         geo->setMaterial(sm);
 387         scene->addChild(makeNodeFor(geo));
 388
 389         geo = makeTorusGeo( .3, .5, 16, 16 );
 390         geo->setMaterial(sm);
 391         scene->addChild(makeNodeFor(geo));
 392     }
 393
 394     //scene->dump();
 395     Thread::getCurrentChangeList()->commitChanges();
 396
 397     // file out test.
 398     //SceneFileHandler::the()->write(scene, "torus2.osb");
 399
 400
 401     // X init
 402     xwin = XWindow::create();
 403     Display *dpy = openWindow(xwin, argv, argc);
 404
 405     // create the SimpleSceneManager helper
 406     mgr = new SimpleSceneManager;
 407
 408     mgr->setWindow( pwin );
 409     mgr->setRoot( scene );
 410
 411     mgr->showAll();
 412
 413     if(cnear != -1)
 414         mgr->getCamera()->setNear(mgr->getCamera()->getNear() * cnear);
 415
 416     if(cfar != -1)
 417         mgr->getCamera()->setFar(mgr->getCamera()->getFar() * cfar);
 418
 419     // We'll be using the new style action here
 420     rentravact = RenderAction::create();
 421
 422     rentravact->setDoCullOnly(true);
 423     rentravact->setNumBuffers(numBuf);
 424
 425 #if 0
 426     // create a gradient background.
 427     GradientBackgroundPtr gback = GradientBackground::create();
 428     gback->clearLines();
 429     gback->addLine(Color3f(0.7, 0.7, 0.8), 0);
 430     gback->addLine(Color3f(0.0, 0.1, 0.3), 1);
 431
 432     WindowPtr win = mgr->getWindow();
 433     for(int i=0;i<win->getPort().size();++i)
 434     {
 435         ViewportPtr vp = win->getPort()[i];
 436         vp->setBackground(gback);
 437     }
 438 #endif
 439
 440     // Start threading
 441
 442     if(doThreading)
 443     {
 444         // Create barriers for syncing
 445         cullenter = Barrier::create();
 446         cullleave = Barrier::create();
 447         drawenter = Barrier::create();
 448         exitB = Barrier::create();
 449
 450         numthreads = 1 + (doThreading?1:0) + (doParDraw?1:0);
 451
 452         appthread = Thread::getCurrent();
 453
 454         cullthread = Thread::get("cullThread");
 455         cullthread->runFunction(cull, 1, NULL);
 456     }
 457     else
 458     {
 459         xwin->init();
 460     }
 461
 462     // main loop ( event dispatching )
 463
 464     bool stopIt = false;
 465     // First redraw
 466     display();
 467
 468     while ( !stopIt )
 469     {
 470         XEvent event;
 471         bool needRedraw = false;
 472
 473         do
 474         {
 475             XNextEvent(dpy, &event);
 476             switch (event.type)
 477             {
 478                 case KeyPress:
 479                     FINFO(("Key pressed: %d \n",event.xkey.keycode));
 480                     switch ( event.xkey.keycode )
 481                     {
 482                         case 9:
 483                             stopIt = true;
 484                             doExit = true;
 485                             // need to render a frame to get the other threads
 486                             // out of their barriers
 487                             FNOTICE(("app: Display for exit\n"));
 488                             display();
 489                             FNOTICE(("app: Waiting for exit\n"));
 490                             exitB->enter(numthreads);
 491                             FNOTICE(("app: Got exit\n"));
 492
 493
 494                             delete mgr;
 495
 496                             xwin  = NULL;
 497                             pwin  = NULL;
 498                             scene = NULL;
 499
 500                             osgExit();
 501
 502                             exit(0);
 503                     }
 504                     break;
 505
 506                 case ButtonPress:
 507                     FINFO(("Button pressed: %d\n", event.xbutton.button));
 508                     mouse(event.xbutton.button - 1, 0, event.xbutton.x,
 509                                 event.xbutton.y);
 510                     break;
 511
 512                 case ButtonRelease:
 513                     FINFO(("Button released: %d\n", event.xbutton.button));
 514                     mouse(event.xbutton.button - 1, 1, event.xbutton.x,
 515                                 event.xbutton.y);
 516                     break;
 517
 518                 case MotionNotify:
 519                     FINFO(("MotionNotify %d %d\n",event.xmotion.x,
 520                                 event.xmotion.y));
 521
 522                     motion(event.xmotion.x, event.xmotion.y);
 523                     needRedraw = true;
 524                     break;
 525
 526                 case ConfigureNotify:
 527                     FINFO(("ConfigureNotify\n"));
 528                     reshape(event.xconfigure.width, event.xconfigure.height );
 529                     needRedraw = true;
 530                     break;
 531
 532                 case Expose:
 533                     needRedraw = true;
 534                     break;
 535              }
 536
 537         }
 538         while ( XPending(dpy) );
 539         if(needRedraw)
 540             display();
 541     }
 542     return 0;
 543 }
 544 #else
 545 int main (int argc, char **argv)
 546 {
 547     return 0;
 548 }
 549 #endif