Source/System/Cluster/Window/Base/OSGClusterWindow.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <stdlib.h>
  44 #include <stdio.h>
  45
  46 #include <sstream>
  47
  48 #include "OSGConfig.h"
  49 #include "OSGSystemDef.h"
  50 #include "OSGClusterWindow.h"
  51 #include "OSGDgramSocket.h"
  52 #include "OSGStreamSocket.h"
  53 #include "OSGRemoteAspect.h"
  54 #include "OSGConnection.h"
  55 #include "OSGBinaryMessage.h"
  56 #include "OSGRemoteAspect.h"
  57 #include "OSGConnectionFactory.h"
  58 #include "OSGClusterNetwork.h"
  59 #include "OSGGroupSockConnection.h"
  60 #include "OSGStatCollector.h"
  61
  62 #if 0
  63 #include "OSGDisplayCalibration.h"
  64 #include "OSGImageComposer.h"
  65 #endif
  66
  67 OSG_USING_NAMESPACE
  68
  69 /** \class OSG::ClusterWindow
  70  *  \ingroup GrpSystemCluster
  71  *  \brief Abstract base class for cluster configurations
  72  *
  73  * A ClusterWindow describes a clustering algorithm. A ClusterWindow
  74  * inherits the ability to connect rendering servers and initiate
  75  * remote rendering. By configuring the cluster algorithm with an
  76  * OpenSG Window structure, it is possible to use cluster rendering
  77  * in the same way as rendering in a GLUT or Qt window.
  78  *
  79  **/
  80
  81 StatElemDesc<StatTimeElem> ClusterWindow::statActivateTime
  82   ("statActivateTime", "time to activate remote window");
  83
  84 StatElemDesc<StatTimeElem> ClusterWindow::statFrameInitTime
  85   ("statFrameInitTime", "time to frameInit remote window");
  86
  87 StatElemDesc<StatTimeElem> ClusterWindow::statRAVTime
  88   ("statRAVTime", "time to RAV remote window");
  89
  90 StatElemDesc<StatTimeElem> ClusterWindow::statSwapTime
  91   ("statSwapTime", "time to swap remote window");
  92
  93 StatElemDesc<StatTimeElem> ClusterWindow::statFrameExitTime
  94   ("statFrameExitTime", "time to frameExit remote window");
  95
  96 /*-------------------------------------------------------------------------*/
  97 /*                          window functions                               */
  98
  99 //! react to field changes
 100
 101 void ClusterWindow::changed(ConstFieldMaskArg whichField,
 102                             UInt32            origin,
 103                             BitVector         details)
 104 {
 105     Inherited::changed(whichField, origin, details);
 106 }
 107
 108 //! output the instance for debug purposes
 109
 110 void ClusterWindow::dump(      UInt32    ,
 111                          const BitVector ) const
 112 {
 113     SLOG << "Dump ClusterWindow NI" << std::endl;
 114 }
 115
 116 #if 0
 117 void (*ClusterWindow::getFunctionByName(const Char8 *s))()
 118 {
 119     return NULL;
 120 }
 121 #endif
 122
 123 /*! init cluster window. connect to all servers
 124  */
 125
 126 void ClusterWindow::init(GLInitFunctor)
 127 {
 128     GroupConnection    *connection;
 129     RemoteAspect       *remoteAspect;
 130     UInt32             c, id;
 131     MFString::const_iterator  s;
 132     Connection::Channel channel;
 133     bool                directConnect=false;
 134
 135     if(getNetwork()->getMainConnection())
 136     {
 137         SWARNING << "init called twice" << std::endl;
 138         return;
 139     }
 140
 141     // create connection
 142     if(getConnectionType().empty())
 143     {
 144         setConnectionType("StreamSock");
 145     }
 146
 147     connection = ConnectionFactory::the()->createGroup(getConnectionType());
 148
 149     if(connection == NULL)
 150     {
 151         SFATAL << "Unknown connection type "
 152                << getConnectionType()
 153                << std::endl;
 154         return;
 155     }
 156
 157     connection->setDestination(getConnectionDestination());
 158     connection->setInterface  (getConnectionInterface  ());
 159     connection->setParams     (getConnectionParams     ());
 160
 161     getNetwork()->setMainConnection(connection);
 162
 163     // create remote aspect
 164
 165     remoteAspect = new RemoteAspect();
 166
 167     getNetwork()->setAspect(remoteAspect);
 168
 169     if(_statistics)
 170         remoteAspect->setStatistics(_statistics);
 171
 172     // autostart servers
 173     std::string server;
 174     std::string autostart;
 175     std::string env;
 176
 177     Real32 progress = 0.0f;
 178     Real32 progressStep = 1.0f / Real32(getMFServers()->size());
 179
 180     if(getMFAutostart()->size())
 181     {
 182         progressStep /= 2;
 183         std::vector<FILE*>           pipes;
 184
 185         for(id=0 ; id<getMFServers()->size() ; ++id)
 186         {
 187             std::ostringstream command;
 188
 189             server    = (*getMFServers())[id];
 190             SizeT pos = server.find(":");
 191
 192             if(pos != std::string::npos)
 193                 server.erase(pos);
 194
 195             autostart = (*getMFAutostart())[id % getMFAutostart()->size()];
 196
 197             for(c = 0 ; c < autostart.length() ; ++c)
 198             {
 199                 if(autostart[c] == '%' && c+1 < autostart.length())
 200                     switch(autostart[++c])
 201                     {
 202                         case 's':
 203                             command << server;
 204                             break;
 205                         case 'n':
 206                             command << (*getMFServers())[id];
 207                             break;
 208                         case 'i':
 209                             command << id;
 210                             break;
 211                         case '{':
 212                             env = "" ;
 213                             while(++c < autostart.length() &&
 214                                   autostart[c] != '}')
 215                                 env += autostart[c];
 216                             if(getenv(env.c_str()))
 217                                 command << getenv(env.c_str());
 218                             break;
 219                         case '%':
 220                             command << '%';
 221                             break;
 222                         default:
 223                             command << '%' << autostart[c];
 224                     }
 225                 else
 226                     command << autostart[c];
 227             }
 228             SINFO << command.str() << std::endl;
 229 #ifdef WIN32
 230             FILE *pipe = _popen(command.str().c_str(),"r");
 231 #else
 232             FILE *pipe = popen(command.str().c_str(),"r");
 233 #endif
 234             if(!pipe)
 235                 SFATAL << "Error starting: " << command.str() << std::endl;
 236             pipes.push_back(pipe);
 237         }
 238
 239         for(id = 0 ; id < getMFServers()->size() ; ++id)
 240         {
 241             if(pipes[id])
 242             {
 243                 // update progress
 244                 if(_connectionFP != NULL)
 245                 {
 246                     if(!_connectionFP("Starting:", (*getMFServers())[id], progress))
 247                     {
 248                         // abort, cleanup remaining pipes
 249                         for( ; id<getMFServers()->size() ; ++id)
 250                         {
 251                             if(pipes[id])
 252                             {
 253 #ifdef WIN32
 254                                 _pclose(pipes[id]);
 255 #else
 256                                 pclose(pipes[id]);
 257 #endif
 258                             }
 259                             throw AsyncCancel();
 260                         }
 261                     }
 262                 }
 263                 SINFO << "Waiting for "
 264                       << getServers(id)
 265                       << " to start."
 266                       << std::endl;
 267
 268                 int result;
 269                 std::string line="";
 270
 271                 while((result=fgetc(pipes[id])) != EOF)
 272                 {
 273                     line += result;
 274
 275                     if(result == '\n')
 276                     {
 277                         SINFO << line;
 278                         line = "";
 279                     }
 280                 }
 281
 282                 if(!line.empty())
 283                     SINFO << line << std::endl;
 284 #ifdef WIN32
 285                 _pclose(pipes[id]);
 286 #else
 287                 pclose(pipes[id]);
 288 #endif
 289                 SINFO << getServers(id) << " started." << std::endl;
 290
 291                 progress += progressStep;
 292             }
 293         }
 294     }
 295
 296     // connect to all servers
 297     for(s = getMFServers()->begin();
 298         s!= getMFServers()->end();
 299         s++)
 300     {
 301         DgramSocket      serviceSock;
 302         BinaryMessage    msg;
 303         std::string      respServer;
 304         std::string      respAddress;
 305         bool             retry=true;
 306
 307         if(strstr((*s).c_str(),":"))
 308             directConnect = true;
 309         else
 310             directConnect = false;
 311
 312         SINFO << "Connect to " << (*s) << std::endl;
 313
 314         serviceSock.open();
 315         serviceSock.setTTL(8);
 316
 317         // set interface
 318         if(!getServiceInterface().empty())
 319         {
 320             serviceSock.setMCastInterface(
 321                 SocketAddress(getServiceInterface().c_str()));
 322         }
 323
 324         while(retry)
 325         {
 326             try
 327             {
 328                 // update progress
 329                 if(_connectionFP != NULL)
 330                 {
 331                     if(!_connectionFP("Connecting:", *s, progress))
 332                     {
 333                         serviceSock.close();
 334                         throw AsyncCancel();
 335                     }
 336                 }
 337
 338                 // try to connect with the servers name
 339                 try
 340                 {
 341                     if(directConnect)
 342                     {
 343                         channel = connection->connectPoint(*s,0.5);
 344                         if(channel >= 0)
 345                         {
 346                             retry = false;
 347
 348                             SINFO << "Connected with address:"
 349                                   << *s
 350                                   << std::endl;
 351                             break;
 352                         }
 353                     }
 354                 }
 355                 catch(...)
 356                 {
 357                 }
 358
 359                 // find server
 360                 msg.clear();
 361                 msg.putString(*s);
 362                 msg.putString(getConnectionType());
 363
 364                 if(_sfServiceAddress.getValue().size() != 0)
 365                 {
 366                     SINFO << "send request to:"
 367                           << _sfServiceAddress.getValue()
 368                           << std::endl;
 369
 370                     try
 371                     {
 372                         serviceSock.sendTo(
 373                             msg,SocketAddress(
 374                                 _sfServiceAddress.getValue().c_str(),
 375                                 getServicePort()));
 376                     }
 377                     catch(AsyncCancel &)
 378                     {
 379                         throw;
 380                     }
 381                     catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
 382                     {
 383                         SINFO << e.what() << std::endl;
 384                     }
 385                 }
 386                 SINFO << "send request to:"
 387                       << SocketAddress(SocketAddress::BROADCAST,
 388                                        getServicePort()).getHost().c_str()
 389                       << std::endl;
 390
 391                 try
 392                 {
 393                     serviceSock.sendTo(
 394                         msg,SocketAddress(SocketAddress::BROADCAST,
 395                                           getServicePort()));
 396                 }
 397                 catch(AsyncCancel &)
 398                 {
 399                     throw;
 400                 }
 401                 catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
 402                 {
 403                     SINFO << e.what() << std::endl;
 404                 }
 405
 406                 if(serviceSock.waitReadable(0.1))
 407                 {
 408                     SocketAddress from;
 409                     serviceSock.recvFrom(msg, from);
 410                     msg.getString(respServer);
 411                     msg.getString(respAddress);
 412
 413                     if(respServer == *s)
 414                     {
 415                         GroupSockConnection *pointSock =
 416                             dynamic_cast<GroupSockConnection*> (connection);
 417
 418                         if(pointSock != NULL)
 419                         {
 420                             /* for all socket connections ignore the
 421                                incoming host and use the host from
 422                                the last response. */
 423
 424                             char port[16];
 425
 426                             if(sscanf(respAddress.c_str(),
 427                                       "%*[^:]:%15s",port) == 1)
 428                             {
 429                                 respAddress = from.getHost() + ":" + port;
 430                             }
 431                         }
 432
 433                         SINFO << "Found at address "
 434                               << respAddress
 435                               << std::endl;
 436
 437                         // connect to server
 438                         channel = connection->connectPoint(respAddress);
 439
 440                         if(channel >= 0)
 441                             retry=false;
 442                     }
 443                 }
 444             }
 445             catch(AsyncCancel &)
 446             {
 447                 throw;
 448             }
 449             catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
 450             {
 451                 SINFO << e.what() << std::endl;
 452             }
 453         }
 454
 455         serviceSock.close();
 456
 457         progress += progressStep;
 458     }
 459
 460     // determine byte order
 461     UInt8 serverLittleEndian;
 462     UInt8 forceNetworkOrder=false;
 463 #if BYTE_ORDER == LITTLE_ENDIAN
 464     UInt8 littleEndian = true;
 465 #else
 466     UInt8 littleEndian = false;
 467 #endif
 468
 469     for(UInt32 i=0;i<getMFServers()->size();++i)
 470     {
 471         channel = connection->selectChannel();
 472         connection->subSelection(channel);
 473         connection->getValue(serverLittleEndian);
 474
 475         if(serverLittleEndian != littleEndian)
 476         {
 477             forceNetworkOrder=true;
 478         }
 479     }
 480     connection->resetSelection();
 481     // tell the servers the encoding mode
 482     connection->putValue(forceNetworkOrder);
 483     connection->flush();
 484     connection->setNetworkOrder((forceNetworkOrder != 0));
 485
 486     if(forceNetworkOrder)
 487     {
 488         SINFO << "Run clustering in network order mode" << std::endl;
 489     }
 490
 491     // inform connection finished
 492     if(_connectionFP != NULL)
 493         _connectionFP("ClusterWindow initialization completed.", "", 1.0);
 494 }
 495
 496 bool ClusterWindow::initAsync(const ConnectionCB &fp)
 497 {
 498     bool result;
 499     ConnectionCB saveFP = _connectionFP;
 500
 501     _connectionFP = fp;
 502
 503     try
 504     {
 505         init();
 506         result = true;
 507     }
 508     catch(AsyncCancel &)
 509     {
 510         result = false;
 511     }
 512     _connectionFP = saveFP;
 513
 514     return result;
 515 }
 516
 517 void ClusterWindow::setConnectionCB(const ConnectionCB &fp)
 518 {
 519     _connectionFP = fp;
 520 }
 521
 522 #ifdef OSG_OLD_RENDER_ACTION
 523 void ClusterWindow::render(DrawActionBase *action)
 524 {
 525     activate();
 526     frameInit();
 527     renderAllViewports(action);
 528     swap();
 529     frameExit();
 530 }
 531 #endif
 532
 533 void ClusterWindow::render(RenderActionBase *action)
 534 {
 535     if(_statistics != NULL)
 536         _statistics->getElem(statActivateTime)->start();
 537
 538     doActivate();
 539
 540     if(_statistics != NULL)
 541         _statistics->getElem(statActivateTime)->stop();
 542
 543
 544     if(_statistics != NULL)
 545         _statistics->getElem(statFrameInitTime)->start();
 546
 547     doFrameInit();
 548
 549     if(_statistics != NULL)
 550         _statistics->getElem(statFrameInitTime)->stop();
 551
 552
 553     if(_statistics != NULL)
 554         _statistics->getElem(statRAVTime)->start();
 555
 556     doRenderAllViewports(action);
 557
 558     if(_statistics != NULL)
 559         _statistics->getElem(statRAVTime)->stop();
 560
 561
 562     if(_statistics != NULL)
 563         _statistics->getElem(statSwapTime)->start();
 564
 565     doSwap();
 566
 567     if(_statistics != NULL)
 568         _statistics->getElem(statSwapTime)->stop();
 569
 570
 571     if(_statistics != NULL)
 572         _statistics->getElem(statFrameExitTime)->start();
 573
 574     doFrameExit();
 575
 576     if(_statistics != NULL)
 577         _statistics->getElem(statFrameExitTime)->stop();
 578 }
 579
 580 void ClusterWindow::activate(void)
 581 {
 582     this->doActivate();
 583 }
 584
 585 void ClusterWindow::deactivate(void)
 586 {
 587     this->doDeactivate();
 588 }
 589
 590 bool ClusterWindow::swap(void)
 591 {
 592     return this->doSwap();
 593 }
 594
 595 void ClusterWindow::terminate (void)
 596 {
 597 }
 598
 599 void ClusterWindow::doActivate(void)
 600 {
 601 }
 602
 603 void ClusterWindow::doDeactivate(void)
 604 {
 605 }
 606
 607 bool ClusterWindow::doSwap(void)
 608 {
 609     if(getNetwork()->getMainConnection() && getNetwork()->getAspect())
 610     {
 611         clientSwap();
 612     }
 613
 614     return true;
 615 }
 616
 617 #ifdef OSG_OLD_RENDER_ACTION
 618 void ClusterWindow::renderAllViewports(DrawActionBase *action)
 619 {
 620     if(getNetwork()->getMainConnection() && getNetwork()->getAspect())
 621     {
 622         clientRender(action);
 623     }
 624 }
 625 #endif
 626
 627 void ClusterWindow::doRenderAllViewports(RenderActionBase *action)
 628 {
 629     if(getNetwork()->getMainConnection() && getNetwork()->getAspect())
 630     {
 631         clientRender(action);
 632     }
 633 }
 634
 635 bool ClusterWindow::hasContext(void)
 636 {
 637     return true;
 638 }
 639
 640 void ClusterWindow::doFrameInit(bool reinitExtFuctions)
 641 {
 642     Connection   *connection   = getNetwork()->getMainConnection();
 643     RemoteAspect *remoteAspect = getNetwork()->getAspect();
 644
 645     if(remoteAspect && connection)
 646     {
 647         if(_firstFrame)
 648         {
 649             setFrameCount(0);
 650
 651             // send sync
 652
 653             commitChanges();
 654             remoteAspect->sendSync(*connection);
 655
 656             ChangeList *cl = ChangeList::create();
 657
 658             cl->clear();
 659             cl->merge(*Thread::getCurrentChangeList());
 660
 661             Thread::getCurrentChangeList()->clear();
 662
 663             // init client window
 664             clientInit();
 665             // last chance to modifie before sync
 666             clientPreSync();
 667             // send sync
 668             commitChanges();
 669             remoteAspect->sendSync(*connection);
 670
 671 //            cl.merge(*Thread::getCurrentChangeList());
 672 //            Thread::getCurrentChangeList()->clear();
 673             Thread::getCurrentChangeList()->merge(*cl);
 674
 675             OSG::subRef(cl);
 676
 677             _firstFrame = false;
 678         }
 679         else
 680         {
 681             setFrameCount(getFrameCount() + 1);
 682             clientPreSync();
 683
 684             commitChanges();
 685             remoteAspect->sendSync(*connection);
 686         }
 687     }
 688 }
 689
 690 void ClusterWindow::doFrameExit(void)
 691 {
 692 }
 693
 694 /*-------------------------------------------------------------------------*/
 695 /*                          statistics                                     */
 696
 697 void ClusterWindow::setStatistics(StatCollector *statistics)
 698 {
 699     _statistics = statistics;
 700     if(getNetwork()->getAspect())
 701         getNetwork()->getAspect()->setStatistics(statistics);
 702 }
 703
 704 /*-------------------------------------------------------------------------*/
 705 /*                          calibration                                    */
 706
 707 /*-------------------------------------------------------------------------*/
 708 /*                          exceptions                                     */
 709
 710 ClusterWindow::AsyncCancel::AsyncCancel()
 711 {
 712 }
 713
 714 /*-------------------------------------------------------------------------*/
 715 /*                         client methods                                  */
 716
 717 /*! init client window. In a derived cluster window this method is called
 718  *  before the first sync with the rendering servers. There is no default
 719  *  action.
 720  */
 721 void ClusterWindow::clientInit(void)
 722 {
 723 }
 724
 725 /** client frame before sync
 726  *
 727  * In a derived cluster window this method is called before
 728  * sync with the rendering servers. Default aciton is to activate
 729  * and init the client window.
 730  **/
 731
 732 void ClusterWindow::clientPreSync( void )
 733 {
 734     if(getClientWindow() != NULL)
 735     {
 736         getClientWindow()->activate ();
 737         getClientWindow()->frameInit();
 738     }
 739 }
 740
 741 /** initiate client rendering
 742  *
 743  * In a derived cluster window this method is called after the
 744  * sync with all rendering servers. Default aciton is to render all
 745  * viewports of the client window.
 746  **/
 747
 748 void ClusterWindow::clientRender(RenderActionBase *action)
 749 {
 750     if(getClientWindow() != NULL)
 751     {
 752         getClientWindow()->renderAllViewports(action);
 753     }
 754 }
 755
 756 /** swap client window
 757  *
 758  * In a derived cluster window this method is called after rendering
 759  * Default aciton is to swap the local client window.
 760  **/
 761
 762 void ClusterWindow::clientSwap( void )
 763 {
 764     if(getClientWindow() != NULL)
 765     {
 766         getClientWindow()->swap     ();
 767         getClientWindow()->frameExit();
 768     }
 769
 770 #if 0
 771     if(getDirty() == true)
 772     {
 773         setDirty(false);
 774     }
 775 #endif
 776 }
 777
 778 /*-------------------------------------------------------------------------*/
 779 /*                         server methods                                  */
 780
 781
 782
 783 /** initialise the cluster window on the server side
 784  *
 785  * This method is called after the first sync.
 786  *
 787  * \param window     server render window
 788  * \param id         server id
 789  **/
 790
 791 void ClusterWindow::serverInit(Window *,
 792                                UInt32  )
 793 {
 794 }
 795
 796 /** render server window
 797  *
 798  * This method is called after synchronisation of all changes with the
 799  * rendering client. Default action is to render all viewports with the
 800  * given action
 801  *
 802  * !param window     server render window
 803  * !param id         server id
 804  * !param action     action
 805  **/
 806
 807 #ifdef OSG_OLD_RENDER_ACTION
 808 void ClusterWindow::serverRender(Window         *window,
 809                                  UInt32          id,
 810                                  DrawActionBase *action )
 811 {
 812 #if 0
 813     window->activate();
 814     window->frameInit();
 815     window->renderAllViewports(action);
 816 #endif
 817
 818     window->renderNoFinish(action);
 819
 820 #if 0
 821     RenderOptionsPtr ro;
 822
 823     RenderAction *ract = dynamic_cast<RenderAction *>(action);
 824     if(ract != NULL)
 825     {
 826         MFViewportPtr::iterator       portIt  = window->getPort().begin();
 827         MFViewportPtr::const_iterator portEnd = window->getPort().end();
 828         // try to find option as an attachment of window
 829         OSG::RenderOptionsPtr winRo = OSG::RenderOptionsPtr::dcast(
 830             window->findAttachment(OSG::RenderOptions::getClassType()));
 831         ract->setWindow(window.getCPtr());
 832         while(portIt != portEnd)
 833         {
 834             // try to find option an attachment at the viewport
 835             OSG::RenderOptionsPtr vpRo = OSG::RenderOptionsPtr::dcast(
 836                 (*portIt)->findAttachment(OSG::RenderOptions::getClassType()));
 837             // try to find option an attachment at the root node
 838             OSG::RenderOptionsPtr rootRo = NULL;
 839             if((*portIt)->getRoot() != NULL)
 840             {
 841                 rootRo = OSG::RenderOptionsPtr::dcast(
 842                     (*portIt)->getRoot()->findAttachment(OSG::RenderOptions::getClassType()));
 843             }
 844             if(rootRo != NULL)
 845                 ro = rootRo;
 846             else
 847                 if(vpRo != NULL)
 848                     ro = vpRo;
 849                 else
 850                     ro = winRo;
 851             if(ro != NULL)
 852                 ro->activateOptions(ract);
 853             (*portIt)->render(ract);
 854             ++portIt;
 855         }
 856     } else {
 857         if(action)
 858             window->renderAllViewports(action);
 859     }
 860 #endif
 861 }
 862 #endif
 863
 864 void ClusterWindow::serverRender(Window           *window,
 865                                  UInt32            id,
 866                                  RenderActionBase *action )
 867 {
 868     window->activate();
 869     window->frameInit();
 870     window->renderAllViewports(action);
 871 }
 872
 873 /** swap server window
 874  *
 875  * <code>serverSwap</code> is called after rendering. Default action is
 876  * to swap the rendering window.
 877  *
 878  * !param window     server render window
 879  * !param id         server id
 880  * !param connection connection to client
 881  **/
 882 void ClusterWindow::serverSwap(Window *window,
 883                                UInt32        )
 884 {
 885     window->swap     ();
 886     window->frameExit();
 887 }
 888
 889 /*-------------------------------------------------------------------------*/
 890 /*                         constructor / destructor                        */
 891
 892 //! Constructor
 893
 894 ClusterWindow::ClusterWindow(void) :
 895      Inherited(),
 896     _firstFrame  (true),
 897     _statistics  (NULL),
 898     _connectionFP(NULL),
 899     _network     (NULL)
 900 {
 901 }
 902
 903 //! Copy Constructor
 904
 905 ClusterWindow::ClusterWindow(const ClusterWindow &source) :
 906      Inherited   (source              ),
 907     _firstFrame  (true                ),
 908     _statistics  (NULL                ),
 909     _connectionFP(source._connectionFP),
 910     _network     (NULL                )
 911 {
 912 }
 913
 914 //! Destructor
 915
 916 ClusterWindow::~ClusterWindow(void)
 917 {
 918     _network = NULL;
 919 }
 920
 921 /*-------------------------------------------------------------------------*/
 922 /*                           connection pool                               */
 923
 924 /*! Get connection pool
 925  */
 926 ClusterNetwork *ClusterWindow::getNetwork(void)
 927 {
 928     if(_network == NULL)
 929     {
 930         _network = ClusterNetwork::getInstance(this->getId());
 931     }
 932
 933     return _network;
 934 }
 935
 936 /*! initialize the static features of the class, e.g. action callbacks
 937  */
 938
 939 void ClusterWindow::initMethod(InitPhase ePhase)
 940 {
 941     Inherited::initMethod(ePhase);
 942 }
 943
 944 void ClusterWindow::exitMethod(InitPhase ePhase)
 945 {
 946     Inherited::exitMethod(ePhase);
 947 }