Source/Contrib/ComplexSceneManager/Native-X/appClusterServerX.cpp

   1 // OpenSG Tutorial Example: Cluster Server
   2 //
   3 // This is a full functional OpenSG cluster server. In OpenSG
   4 // the terms server and client are used similar to X11. The
   5 // application is the client. Instances that are used for
   6 // rendering are called server.
   7 //
   8 // See the ClusterClient.cpp for an example of how to use them.
   9
  10 #ifndef WIN32
  11
  12 #include <iostream>
  13
  14 #include <unistd.h>
  15
  16 #include "OSGGL.h"
  17 #include <GL/glx.h>
  18
  19 // General OpenSG configuration, needed everywhere
  20 #include "OSGConfig.h"
  21 // The Cluster server definition
  22 #include "OSGClusterServer.h"
  23 // The GLUT-OpenSG connection class
  24 #include "OSGXWindow.h"
  25 // Render action definition.
  26 #include "OSGRenderAction.h"
  27 #include "OSGGeoFunctions.h"
  28 #include "OSGFrameHandler.h"
  29
  30 // local glut window
  31 OSG::XWindowRefPtr       window      = NULL;
  32 // render action
  33 OSG::RenderActionRefPtr  ract        = NULL;
  34 // pointer the the cluster server instance
  35 OSG::ClusterServer      *server      = NULL;
  36 bool                     exitOnError = false;
  37 int                      iCache      = 0;
  38
  39 void cleanup(void)
  40 {
  41     window = NULL;
  42     ract   = NULL;
  43
  44     server->stop();
  45     delete server;
  46
  47     server = NULL;
  48
  49     OSG::osgExit();
  50 }
  51
  52 // forward declaration so we can have the interesting stuff upfront
  53 void display(void);
  54 void reshape(int width, int height);
  55
  56 int wait_for_map_notify(Display *, XEvent *event, char *arg)
  57 {
  58     return( (event->type == MapNotify) &&
  59             (event->xmap.window == reinterpret_cast< ::Window >(arg) ) );
  60 }
  61
  62 #ifdef OSG_DEBUG_OLD_C_CASTS
  63 #ifdef ScreenOfDisplay
  64 #undef ScreenOfDisplay
  65 #endif
  66 #ifdef DefaultScreen
  67 #undef DefaultScreen
  68 #endif
  69 #define ScreenOfDisplay(dpy, scr)(&(_XPrivDisplay(dpy))->screens[scr])
  70 #define DefaultScreen(dpy)      ((_XPrivDisplay(dpy))->default_screen)
  71 #endif
  72
  73 // Initialize GLUT & OpenSG and start the cluster server
  74 int main(int argc,char **argv)
  75 {
  76     const char           *name           = "ClusterServer";
  77     const char           *connectionType = "StreamSock";
  78           bool            fullscreen     = true;
  79           std::string     address        = "";
  80           bool            doStereo       = false;
  81           std::string     serviceGroup   = "224.245.211.234";
  82           bool            noDecor        = false;
  83
  84           bool            geoSpec        = false;
  85
  86           OSG::UInt32     width          = 512;
  87           OSG::UInt32     height         = 512;
  88           OSG::UInt32     xPos           = 0;
  89           OSG::UInt32     yPos           = 0;
  90
  91     FILE *pOut = fopen("/tmp/cluster_server.log", "w");
  92
  93     if(pOut != NULL)
  94     {
  95         char **pVal = environ;
  96
  97         while(*pVal != NULL)
  98         {
  99             fprintf(pOut, "%s\n", *pVal);
 100
 101             ++pVal;
 102         }
 103
 104         fclose(pOut);
 105     }
 106
 107     // evaluate params
 108     for(int a = 1 ; a < argc ; ++a)
 109     {
 110         if(argv[a][0] == '-')
 111         {
 112             switch(argv[a][1])
 113             {
 114                 case 'a':
 115                     address = argv[a][2] ? argv[a]+2 : argv[++a];
 116
 117                     if(address == argv[argc])
 118                     {
 119                         SLOG << "address missing" << OSG::endLog;
 120                         return 0;
 121                     }
 122
 123                     std::cout << address << OSG::endLog;
 124                     break;
 125
 126                 case 'd':
 127                     noDecor = true;
 128                     break;
 129
 130                 case 'e':
 131                     exitOnError=true;
 132                     break;
 133
 134                 case 'g':
 135                 {
 136                     int rc = 0;
 137
 138                     if(argv[a][2] != '\0')
 139                     {
 140                         rc = sscanf(argv[a] + 2,
 141                                     "%ux%u+%u+%u",
 142                                     &width,
 143                                     &height,
 144                                     &xPos,
 145                                     &yPos          );
 146                     }
 147                     else
 148                     {
 149                         rc = sscanf(argv[++a],
 150                                     "%ux%u+%u+%u",
 151                                     &width,
 152                                     &height,
 153                                     &xPos,
 154                                     &yPos          );
 155                     }
 156
 157                     if(rc == 4)
 158                     {
 159                         geoSpec = true;
 160                     }
 161
 162                     break;
 163                 }
 164
 165                 case 'j':
 166
 167                     if(argv[a][2] != '\0')
 168                         serviceGroup=argv[a]+2;
 169                     else
 170                         serviceGroup=argv[++a];
 171                     break;
 172
 173                 case 'm':
 174                     connectionType="Multicast";
 175                     break;
 176
 177
 178                 case 's':
 179                     doStereo=true;
 180                     break;
 181
 182                 case 'w':
 183                     fullscreen = false;
 184                     break;
 185
 186
 187
 188
 189                 case 'h':
 190                 default:
 191                     std::cout << argv[0]
 192                               << "-m "
 193                               << "-s "
 194                               << "-w "
 195                               << "-e "
 196                               << "-a Address "
 197                               << "-j group "
 198                               << std::endl;
 199                     std::cout << "-m         use multicast" << std::endl;
 200                     std::cout << "-s         enable stereo" << std::endl;
 201                     std::cout << "-w         no fullscreen" << std::endl;
 202                     std::cout << "-e         exit after closed connection"
 203                               << std::endl;
 204                     std::cout << "-a Address Server network address"
 205                               << std::endl;
 206                     std::cout << "-m Address wait for requests on "
 207                               << "multicast group" << std::endl;
 208                     std::cout << "-p port    wait for requests on port"
 209                               << std::endl;
 210                     return 0;
 211             }
 212         }
 213         else
 214         {
 215             name=argv[a];
 216         }
 217     }
 218     try
 219     {
 220         // init OpenSG
 221         OSG::osgInit            (argc, argv);
 222         OSG::ClusterServer::init(argc, argv);
 223
 224         OSG::setVBOUsageOnPropertyProtos(true);
 225
 226         int snglBuf[] = {GLX_RGBA,
 227                          GLX_DEPTH_SIZE, 16,
 228                          None};
 229
 230         int dblBuf[16];
 231
 232         dblBuf[0] = GLX_RGBA;
 233         dblBuf[1] = GLX_DEPTH_SIZE;
 234         dblBuf[2] = 16;
 235         dblBuf[3] = GLX_DOUBLEBUFFER;
 236         dblBuf[4] = (doStereo == true) ? GLX_STEREO : None;
 237         dblBuf[5] = None;
 238
 239         // X init
 240         OSG::DisplayP dpy = XOpenDisplay(NULL);
 241
 242         if(dpy == NULL)
 243         {
 244             std::cerr << "Error: Could not open display!" << std::endl;
 245         }
 246
 247         int dummy;
 248
 249         if(!glXQueryExtension( dpy, &dummy, &dummy))
 250         {
 251             std::cerr << "Error: X server has no OpenGL GLX extension"
 252                       << std::endl;
 253         }
 254
 255         XVisualInfo *vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
 256
 257         if(vi == NULL)
 258         {
 259             vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
 260
 261             if(vi == NULL)
 262             {
 263                 std::cerr << "no RGB visual with depth buffer" << std::endl;
 264             }
 265         }
 266
 267         if(vi->c_class != TrueColor)
 268         {
 269             std::cerr << "TrueColor visual required for this program"
 270                       << std::endl;
 271         }
 272
 273         Colormap cmap = XCreateColormap(dpy,
 274                                         RootWindow(dpy, vi->screen),
 275                                         vi->visual,
 276                                         AllocNone);
 277         XSetWindowAttributes swa;
 278
 279         swa.colormap = cmap;
 280         swa.border_pixel = 0;
 281         swa.event_mask =
 282             ExposureMask      |
 283             ButtonPressMask   |
 284             ButtonReleaseMask |
 285             KeyPressMask      |
 286             Button1MotionMask |
 287             Button2MotionMask |
 288             Button3MotionMask |
 289             StructureNotifyMask;
 290
 291         // Create Window
 292
 293         // Create a Window and connect it to the main display dpy
 294         OSG::X11Window hwin = XCreateWindow(dpy,
 295                                             RootWindow(dpy, vi->screen),
 296                                             0, 0, 300, 300,
 297                                             0,
 298                                             vi->depth,
 299                                             InputOutput,
 300                                             vi->visual,
 301                                             CWBorderPixel |
 302                                             CWColormap    |
 303                                             CWEventMask,
 304                                             &swa );
 305
 306         XSetStandardProperties(dpy, hwin, "testWindowX", "testWindowX",
 307                                None, argv, argc, NULL);
 308
 309         if(fullscreen == true || noDecor == true)
 310         {
 311             Atom noDecorAtom = XInternAtom(dpy,
 312                                            "_MOTIF_WM_HINTS",
 313                                            0);
 314
 315             if(noDecorAtom == None)
 316             {
 317                 fprintf(stderr,
 318                         "Could not intern X atom for _MOTIF_WM_HINTS.\n");
 319             }
 320
 321             struct NoDecorHints
 322             {
 323                 long flags;
 324                 long functions;
 325                 long decorations;
 326                 long input_mode;
 327             };
 328
 329             NoDecorHints oHints;
 330
 331             oHints.flags = 2;
 332             oHints.decorations = 0;
 333
 334             XChangeProperty(dpy,
 335                             hwin,
 336                             noDecorAtom,
 337                             noDecorAtom,
 338                             32,
 339                             PropModeReplace,
 340                             reinterpret_cast<unsigned char *>(&oHints), 4);
 341
 342         }
 343
 344         XStoreName(dpy, hwin, name);
 345
 346         // create the render action
 347         ract = OSG::RenderAction::create();
 348
 349         // setup the OpenSG Glut window
 350         window     = OSG::XWindow::create();
 351
 352         window->setDisplay(dpy );
 353         window->setWindow (hwin);
 354
 355         window->init();
 356
 357         XEvent        event;
 358
 359         XMapWindow(dpy, hwin);
 360         XIfEvent( dpy,
 361                  &event,
 362                   wait_for_map_notify,
 363                   reinterpret_cast<char *>(hwin));
 364
 365         if(fullscreen == true)
 366         {
 367             XMoveWindow  (dpy, hwin, 0, 0);
 368             XResizeWindow(dpy, hwin,
 369                           DisplayWidth (dpy, vi->screen),
 370                           DisplayHeight(dpy, vi->screen));
 371
 372             static char data[1] = {0};
 373
 374             Cursor cursor;
 375             Pixmap blank;
 376             XColor dummyCol;
 377
 378             blank = XCreateBitmapFromData(dpy,
 379                                           hwin,
 380                                           data, 1, 1);
 381
 382             cursor = XCreatePixmapCursor(dpy,
 383                                          blank,
 384                                          blank,
 385                                          &dummyCol, &dummyCol, 0, 0);
 386
 387             XFreePixmap(dpy, blank);
 388
 389             XDefineCursor(dpy,
 390                           hwin,
 391                           cursor);
 392             XFlush(dpy);
 393         }
 394         else if(geoSpec == true)
 395         {
 396             XMoveResizeWindow(dpy,
 397                               hwin,
 398                               xPos,
 399                               yPos,
 400                               width,
 401                               height);
 402         }
 403
 404         window->activate();
 405
 406         glEnable(GL_LIGHTING );
 407         glEnable(GL_LIGHT0   );
 408         glEnable(GL_NORMALIZE);
 409
 410         // create the cluster server
 411         server     = new OSG::ClusterServer(window,
 412                                             name,
 413                                             connectionType,
 414                                             address       );
 415         // start the server
 416         server->start();
 417
 418         bool        stopIt = false;
 419         int         ip;
 420
 421 //        OSG::FieldContainerFactory::the()->dump();
 422
 423         while(!stopIt)
 424         {
 425             while((ip = XPending(dpy)) != 0)
 426             {
 427                 XNextEvent(dpy, &event);
 428
 429                 switch (event.type)
 430                 {
 431                     case ConfigureNotify:
 432                     {
 433                         reshape(event.xconfigure.width,
 434                                 event.xconfigure.height);
 435                     }
 436                     break;
 437
 438                     case Expose:
 439                         display();
 440                         break;
 441
 442                 }
 443
 444             }
 445
 446             display();
 447         }
 448     }
 449
 450     catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
 451     {
 452         SLOG << e.what() << OSG::endLog;
 453         cleanup();
 454         OSG::osgExit();
 455     }
 456
 457     return 0;
 458 }
 459
 460 /* render loop */
 461 void display(void)
 462 {
 463     try
 464     {
 465         if(iCache < 5)
 466         {
 467 //            fprintf(stderr, "cache %d\n", iCache);
 468
 469             ract->setFrustumCulling(false);
 470         }
 471
 472         OSG::FrameHandler::the()->frame();
 473
 474         // receive scenegraph and do rendering
 475         server->render(ract);
 476
 477         if(iCache < 5)
 478         {
 479             ract->setFrustumCulling(false);
 480             ++iCache;
 481         }
 482
 483
 484         // clear changelist
 485         OSG::Thread::getCurrentChangeList()->clear();
 486     }
 487
 488     catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
 489     {
 490         if(exitOnError)
 491         {
 492             SLOG << e.what() << std::endl;
 493
 494             printf("Exit on error %s",e.what());
 495
 496             try
 497             {
 498                 cleanup();
 499             }
 500             catch(...)
 501             {
 502             }
 503
 504             exit(0);
 505         }
 506         else
 507         {
 508             SLOG << e.what() << OSG::endLog;
 509             // try to restart server
 510             server->stop();
 511
 512             ract = OSG::RenderAction::create();
 513
 514             // start server, wait for client to connect
 515             server->start();
 516         }
 517     }
 518 }
 519
 520 /* window reshape */
 521 void reshape( int width, int height )
 522 {
 523     // set new window size
 524         window->resize( width, height );
 525 }
 526
 527 #else
 528
 529 #include <iostream>
 530
 531 int main(int argc,char **argv)
 532 {
 533     std::cerr << "Not supported on windows platform!" << std::endl;
 534 }
 535
 536 #endif // WIN32