Source/System/Cluster/Window/SortLast/OSGSortLastWindow.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 "OSGViewport.h"
  47 #include "OSGStereoBufferViewport.h"
  48 #include "OSGGeometry.h"
  49 #include "OSGGeoPositionsFields.h"
  50 #include "OSGGroup.h"
  51 #include "OSGCamera.h"
  52 #include "OSGProxyGroup.h"
  53 #include "OSGMaterialGroup.h"
  54 #include "OSGRemoteAspect.h"
  55 #include "OSGImageComposer.h"
  56 #include "OSGStatisticsForeground.h"
  57 #include "OSGClusterNetwork.h"
  58 #include "OSGDrawEnv.h"
  59 #include "OSGRenderActionBase.h"
  60 #include "OSGMaterial.h"
  61
  62 #include "OSGSortLastWindow.h"
  63
  64 OSG_USING_NAMESPACE
  65
  66 /*! \class OSG::SortLastWindow
  67 Cluster rendering configuration for sort first image composition
  68 */
  69
  70 /*----------------------------- static grouping functions -----------------*/
  71
  72 void SortLastWindow::buildGroups(void)
  73 {
  74     UInt32            v          = 0;
  75     DrawableListT     drawables;
  76     UInt32            groupCount = 0;
  77     bool              rebuild    = false;
  78
  79     // check for new nodes.
  80     FieldContainerFactoryBase *fcFactory = FieldContainerFactory::the();
  81
  82     FieldContainer *fcPtr = NULL;
  83
  84     ChangeList::ChangedStoreConstIt createdI;
  85
  86     ChangeList *changeList = OSG::Thread::getCurrentChangeList();
  87
  88     for(createdI  = changeList->beginCreated();
  89         createdI != changeList->endCreated();
  90         createdI++)
  91     {
  92         UInt32 uiId = (*createdI)->uiContainerId;
  93
  94         fcPtr = fcFactory->getContainer(uiId);
  95
  96         if(fcPtr != NULL && dynamic_cast<Node *>(fcPtr) != NULL)
  97             rebuild = true;
  98     }
  99
 100     // is rebuild neccessary ?
 101     if(!rebuild && getMFGroupNodes()->size())
 102         return;
 103
 104     groupCount = getMFServers()->size32();
 105
 106     if(getComposer() != NULL)
 107     {
 108         groupCount = getComposer()->getUsableServers();
 109         if(getComposer()->getClientRendering())
 110             groupCount++;
 111     }
 112
 113     // build groups for all viewports
 114
 115     clearGroupNodes();
 116     editMFGroupLengths()->clear();
 117
 118     for(v = 0; v < getMFPort()->size(); ++v)
 119     {
 120         Viewport *vp         = getPort(v);
 121         Node     *root       = vp->getRoot();
 122
 123         drawables.clear();
 124
 125         collectDrawables(root, drawables);
 126
 127         if(drawables.size())
 128             splitDrawables(drawables, groupCount, false);
 129     }
 130 }
 131
 132 /*----------------------------- server methods ----------------------------*/
 133
 134 /*! init composition
 135  */
 136 void SortLastWindow::serverInit(Window *serverWindow,
 137                                 UInt32  id)
 138 {
 139     // create default composer
 140     if(getComposer() == NULL)
 141     {
 142 /*
 143         FieldContainerPtr fcPtr =
 144             FieldContainerFactory::the()->createFieldContainer("BinarySwapComposer");
 145         setComposer(ImageComposerPtr::dcast(fcPtr));
 146 */
 147     }
 148
 149     if(getComposer() != NULL)
 150     {
 151         // init composer
 152         ClusterWindow *clusterWindow = this;
 153
 154         getComposer()->setup(false,
 155                              id,
 156                              serverWindow,
 157                              clusterWindow);
 158
 159         getComposer()->open();
 160     }
 161 }
 162
 163 /*! update server window
 164  */
 165
 166 #ifdef OSG_OLD_RENDER_ACTION
 167 void SortLastWindow::serverRender(Window         *serverWindow,
 168                                   UInt32          id,
 169                                   DrawActionBase *action      )
 170 {
 171     Viewport *serverPort  = NULL;
 172     Viewport *clientPort  = NULL;
 173     UInt32    sv          = 0;
 174     UInt32    cv          = 0;
 175     UInt32    regionStart = 0;
 176
 177     // duplicate viewports
 178     for(cv = 0, sv = 0; cv < getPort().size(); ++cv)
 179     {
 180         clientPort = getPort()[cv];
 181
 182         if(serverWindow->getPort().size() <= sv)
 183         {
 184             // create new port
 185             serverPort = Viewport::create();
 186
 187             serverWindow->addPort(serverPort);
 188         }
 189         else
 190         {
 191             serverPort = serverWindow->getPort()[sv];
 192         }
 193
 194         // duplicate values
 195
 196         if(getWidth() && getHeight())
 197         {
 198            serverPort->setSize(clientPort->getPixelLeft  (),
 199                                clientPort->getPixelBottom(),
 200                                clientPort->getPixelRight (),
 201                                clientPort->getPixelTop   ());
 202         }
 203         else
 204         {
 205             serverPort->setSize(0,0,0,0);
 206         }
 207
 208         serverPort->setCamera    (clientPort->getCamera    ());
 209         serverPort->setRoot      (clientPort->getRoot      ());
 210         serverPort->setBackground(clientPort->getBackground());
 211
 212         // ignore statistics foreground
 213         serverPort->clearForegrounds();
 214
 215         for(UInt32 f = 0 ; f < serverPort->getForegrounds().size(); ++f)
 216         {
 217             Foreground *fg = clientPort->getForegrounds()[f];
 218
 219             StatisticsForeground *sfg =
 220                 dynamic_cast<StatisticsForeground *>(fg);
 221
 222             if(sfg == NULL)
 223             {
 224                 serverPort->addForeground(fg);
 225             }
 226         }
 227
 228         serverPort->setTravMask(clientPort->getTravMask());
 229
 230         sv++;
 231     }
 232
 233     // remove unused ports
 234     while(serverWindow->getPort().size() > sv)
 235     {
 236         serverWindow->subPort(sv);
 237     }
 238
 239     // setup visible nodes
 240     setupNodes(id);
 241
 242     // render the viewports
 243     serverWindow->activate();
 244     serverWindow->frameInit();
 245
 246     action->setWindow(serverWindow);
 247
 248     if(getComposer() != NULL)
 249         getComposer()->startFrame();
 250
 251     for(sv = 0; sv < serverWindow->getPort().size(); ++sv)
 252     {
 253         Viewport *vp         = serverWindow->getPort()[sv];
 254         Node     *root       = vp->getRoot();
 255
 256         if(getComposer() != NULL)
 257             getComposer()->startViewport(vp);
 258
 259         // render
 260         vp->render(action);
 261
 262         // compose single viewport
 263         if(getComposer() != NULL)
 264             getComposer()->composeViewport(vp);
 265     }
 266
 267     // compose whole window
 268     if(getComposer() != NULL)
 269         getComposer()->composeWindow();
 270 }
 271 #endif
 272
 273 void SortLastWindow::serverRender(Window           *serverWindow,
 274                                   UInt32            id,
 275                                   RenderActionBase *action      )
 276 {
 277     ViewportUnrecPtr  serverPort  = NULL;
 278     Viewport         *clientPort  = NULL;
 279     UInt32            sv          = 0;
 280     UInt32            cv          = 0;
 281
 282     // duplicate viewports
 283     for(cv = 0, sv = 0; cv < getMFPort()->size(); ++cv)
 284     {
 285         clientPort = getPort(cv);
 286
 287         if(serverWindow->getMFPort()->size() <= sv)
 288         {
 289             // create new port
 290             serverPort = Viewport::create();
 291
 292             serverWindow->addPort(serverPort);
 293         }
 294         else
 295         {
 296             serverPort = serverWindow->getPort(sv);
 297         }
 298
 299         // duplicate values
 300
 301         if(getWidth() && getHeight())
 302         {
 303            serverPort->setSize(clientPort->calcPixelLeft  (),
 304                                clientPort->calcPixelBottom(),
 305                                clientPort->calcPixelRight (),
 306                                clientPort->calcPixelTop   ());
 307         }
 308         else
 309         {
 310             serverPort->setSize(0,0,0,0);
 311         }
 312
 313         serverPort->setCamera    (clientPort->getCamera    ());
 314         serverPort->setRoot      (clientPort->getRoot      ());
 315         serverPort->setBackground(clientPort->getBackground());
 316
 317         // ignore statistics foreground
 318         serverPort->clearForegrounds();
 319
 320         for(UInt32 f = 0 ; f < serverPort->getMFForegrounds()->size(); ++f)
 321         {
 322             Foreground *fg = clientPort->getForegrounds(f);
 323
 324             StatisticsForeground *sfg =
 325                 dynamic_cast<StatisticsForeground *>(fg);
 326
 327             if(sfg == NULL)
 328             {
 329                 serverPort->addForeground(fg);
 330             }
 331         }
 332
 333         serverPort->setTravMask(clientPort->getTravMask());
 334
 335         sv++;
 336     }
 337
 338     // remove unused ports
 339     while(serverWindow->getMFPort()->size() > sv)
 340     {
 341         serverWindow->subPort(sv);
 342     }
 343
 344     // setup visible nodes
 345     setupNodes(id);
 346
 347     // render the viewports
 348     serverWindow->activate();
 349     serverWindow->frameInit();
 350
 351     action->setWindow(serverWindow);
 352
 353     if(getComposer() != NULL)
 354         getComposer()->startFrame();
 355
 356     for(sv = 0; sv < serverWindow->getMFPort()->size(); ++sv)
 357     {
 358         Viewport *vp = serverWindow->getPort(sv);
 359
 360         if(getComposer() != NULL)
 361             getComposer()->startViewport(vp);
 362
 363         // render
 364         vp->render(action);
 365
 366         // compose single viewport
 367         if(getComposer() != NULL)
 368             getComposer()->composeViewport(vp);
 369     }
 370
 371     // compose whole window
 372     if(getComposer() != NULL)
 373         getComposer()->composeWindow();
 374 }
 375
 376 /*! swap
 377  */
 378 void SortLastWindow::serverSwap(Window *window,
 379                                 UInt32  id    )
 380 {
 381     if(getComposer() == NULL)
 382     {
 383         Connection *connection = getNetwork()->getMainConnection();
 384         // tell client that we are finish
 385         connection->signal();
 386         // wait for swap
 387         connection->wait();
 388     }
 389     Inherited::serverSwap(window,id);
 390 }
 391
 392 /*----------------------------- client methods ----------------------------*/
 393
 394 /*! read server cababilities
 395  */
 396 void SortLastWindow::clientInit( void )
 397 {
 398     getNetwork()->getAspect()->addFieldFilter(Node::getClassType().getId(),
 399                                               Node::VolumeFieldMask);
 400     getNetwork()->getAspect()->addFieldFilter(Node::getClassType().getId(),
 401                                               Node::TravMaskFieldMask);
 402
 403     // create default composer
 404     if(getComposer() == NULL)
 405     {
 406 /*
 407         FieldContainerPtr fcPtr =
 408             FieldContainerFactory::the()->createFieldContainer("BinarySwapComposer");
 409         setComposer(ImageComposerPtr::dcast(fcPtr));
 410 */
 411     }
 412     if(getComposer() != NULL)
 413     {
 414         SortLastWindow *clusterWindow(this);
 415         getComposer()->setup(true,
 416                              getMFServers()->size32(),
 417                              getClientWindow(),
 418                              clusterWindow);
 419         getComposer()->open();
 420         // build node groups
 421         buildGroups();
 422     }
 423 }
 424
 425 /*! client frame init
 426  */
 427 void SortLastWindow::clientPreSync( void )
 428 {
 429     if(getClientWindow() != NULL)
 430     {
 431         UInt32 width =getClientWindow()->getWidth();
 432         UInt32 height=getClientWindow()->getHeight();
 433         if(width == 0)
 434             width = 2;
 435         if(height == 0)
 436             height = 2;
 437         if(width  != getWidth() ||
 438            height != getHeight())
 439         {
 440            setSize(width,height);
 441         }
 442     }
 443
 444     Inherited::clientPreSync();
 445
 446     // rebuild node groups
 447     buildGroups();
 448 }
 449
 450 #ifdef OSG_OLD_RENDER_ACTION
 451 /*! client rendering
 452  */
 453 void SortLastWindow::clientRender(DrawActionBase *action)
 454 {
 455     UInt32          p;
 456     UInt32          groupId = getServers().size();
 457     UInt32          l,b,r,t;
 458     UInt32          front,back;
 459     SortLastWindow *clusterWindow(this);
 460
 461     if(getServers().size())
 462     {
 463         Connection *srcConnection=
 464             getNetwork()->getConnection(groupId);
 465
 466         if(getClientWindow() != NULL)
 467         {
 468             setupNodes(groupId);
 469 /*
 470             getClientWindow()->activate();
 471             getClientWindow()->frameInit();
 472 */
 473             action->setWindow(getClientWindow());
 474
 475             if(getComposer() != NULL)
 476                 getComposer()->startFrame();
 477
 478             DrawEnv oEnv;
 479
 480             oEnv.setWindow(action->getWindow());
 481
 482             // render all viewports
 483             for(p = 0; p < getPort().size() ; ++p)
 484             {
 485                 Viewport *vp=getPort()[p];
 486                 if(getComposer() != NULL)
 487                 {
 488                     getComposer()->startViewport(vp);
 489
 490                     action->setCamera    (vp->getCamera    ());
 491                     action->setBackground(vp->getBackground());
 492                     action->setViewport  (vp                 );
 493                     action->setTravMask  (vp->getTravMask  ());
 494
 495                     action->apply(vp->getRoot());
 496
 497                     for(UInt16 i=0; i < vp->getForegrounds().size(); i++)
 498                     {
 499                         if(dynamic_cast<StatisticsForeground *>(
 500                                vp->getForegrounds(i)) == NULL)
 501                         {
 502                             vp->getForegrounds(i)->draw(&oEnv, vp);
 503                         }
 504                     }
 505
 506                     getComposer()->composeViewport(vp);
 507
 508                     for(UInt16 i=0; i < vp->getForegrounds().size(); i++)
 509                     {
 510                         if(dynamic_cast<StatisticsForeground *>(
 511                                vp->getForegrounds(i)) != NULL)
 512                         {
 513                             vp->getForegrounds(i)->draw(&oEnv, vp);
 514                         }
 515                     }
 516
 517                 }
 518                 else
 519                 {
 520                     vp->render(action);
 521                 }
 522             }
 523
 524             // compose whole window
 525             if(getComposer() != NULL)
 526                 getComposer()->composeWindow();
 527         }
 528     }
 529 }
 530 #endif
 531
 532 void SortLastWindow::clientRender(RenderActionBase *action)
 533 {
 534     UInt32          p;
 535     UInt32          groupId = getMFServers()->size32();
 536
 537     if(getMFServers()->size())
 538     {
 539         if(getClientWindow() != NULL)
 540         {
 541             setupNodes(groupId);
 542 /*
 543             getClientWindow()->activate();
 544             getClientWindow()->frameInit();
 545 */
 546             action->setWindow(getClientWindow());
 547
 548             if(getComposer() != NULL)
 549                 getComposer()->startFrame();
 550
 551             DrawEnv oEnv;
 552
 553             oEnv.setWindow(action->getWindow());
 554
 555             // render all viewports
 556             for(p = 0; p < getMFPort()->size() ; ++p)
 557             {
 558                 Viewport *vp=getPort(p);
 559
 560                 oEnv.setViewportDimension(vp->calcPixelLeft   (),
 561                                           vp->calcPixelBottom (),
 562                                           vp->calcPixelRight  (),
 563                                           vp->calcPixelTop    (),
 564                                           vp->calcIsFullWindow());
 565                 if(getComposer() != NULL)
 566                 {
 567                     getComposer()->startViewport(vp);
 568
 569                     action->setCamera    (vp->getCamera    ());
 570                     action->setBackground(vp->getBackground());
 571                     action->setViewarea  (vp                 );
 572                     action->setTravMask  (vp->getTravMask  ());
 573
 574                     action->apply(vp->getRoot());
 575
 576                     for(UInt16 i=0; i < vp->getMFForegrounds()->size(); i++)
 577                     {
 578                         if(dynamic_cast<StatisticsForeground *>(
 579                                vp->getForegrounds(i)) == NULL)
 580                         {
 581                             vp->getForegrounds(i)->draw(&oEnv);
 582                         }
 583                     }
 584
 585                     getComposer()->composeViewport(vp);
 586
 587                     for(UInt16 i=0; i < vp->getMFForegrounds()->size(); i++)
 588                     {
 589                         if(dynamic_cast<StatisticsForeground *>(
 590                                vp->getForegrounds(i)) != NULL)
 591                         {
 592                             vp->getForegrounds(i)->draw(&oEnv);
 593                         }
 594                     }
 595
 596                 }
 597                 else
 598                 {
 599                     vp->render(action);
 600                 }
 601             }
 602
 603             // compose whole window
 604             if(getComposer() != NULL)
 605                 getComposer()->composeWindow();
 606         }
 607     }
 608 }
 609
 610 /*! swap
 611  */
 612 void SortLastWindow::clientSwap( void )
 613 {
 614     if(getComposer() == NULL)
 615     {
 616         Connection *connection=getNetwork()->getMainConnection();
 617         // wait for all servers to finish
 618         connection->wait();
 619         // initiate swap
 620         connection->signal();
 621     }
 622     Inherited::clientSwap();
 623 }
 624
 625 /*----------------------- constructors & destructors ----------------------*/
 626
 627 SortLastWindow::SortLastWindow(void) :
 628     Inherited()
 629 {
 630 }
 631
 632 SortLastWindow::SortLastWindow(const SortLastWindow &source) :
 633     Inherited(source)
 634 {
 635 }
 636
 637 /*! close composer if there is any
 638  */
 639 SortLastWindow::~SortLastWindow(void)
 640 {
 641 }
 642
 643 /*----------------------------- class specific ----------------------------*/
 644
 645 void SortLastWindow::initMethod(InitPhase ePhase)
 646 {
 647     Inherited::initMethod(ePhase);
 648 }
 649
 650 /*! changed field. Handle new groups
 651  */
 652
 653 void SortLastWindow::changed(ConstFieldMaskArg whichField,
 654                              UInt32            origin,
 655                              BitVector         details)
 656 {
 657     if(whichField & GroupNodesFieldMask)
 658         setGroupsChanged(true);
 659
 660     Inherited::changed(whichField, origin, details);
 661 }
 662
 663 void SortLastWindow::dump(      UInt32    ,
 664                           const BitVector ) const
 665 {
 666     SLOG << "Dump SortLastWindow NI" << std::endl;
 667 }
 668
 669 /*! Collext all drawable nodes
 670  */
 671
 672 void SortLastWindow::collectDrawables(Node * const   node,
 673                                       DrawableListT &drawables)
 674 {
 675     Material *mat  = NULL;
 676     NodeCore *core = node->getCore();
 677
 678     if(core != NULL)
 679     {
 680         // handle material groups
 681         MaterialGroup *matGrp = dynamic_cast<MaterialGroup *>(core);
 682
 683         if(matGrp != NULL)
 684         {
 685             mat = matGrp->getMaterial();
 686
 687             // ignore transparent material groups
 688             if(mat != NULL && mat->isTransparent())
 689                 return;
 690         }
 691
 692         // handle geometries
 693         Geometry *geo = dynamic_cast<Geometry *>(core);
 694
 695         if(geo != NULL)
 696         {
 697             mat = geo->getMaterial();
 698             // ignore transparent materials
 699
 700             if(mat == NULL || mat->isTransparent() == false)
 701             {
 702                 DrawableInfo drawableInfo;
 703
 704                 drawableInfo.node = node;
 705
 706                 // get transformed volume
 707                 node->updateVolume();
 708
 709                 BoxVolume volume;
 710                 node->getWorldVolume(volume);
 711
 712                 // get min,max
 713                 volume.getBounds(drawableInfo.bMin, drawableInfo.bMax);
 714
 715                 // num of indices
 716                 drawableInfo.load = 0;
 717
 718                 GeoIntegralProperty *indicesPtr =
 719                     geo->getIndex(Geometry::PositionsIndex);
 720
 721                 if(indicesPtr != NULL)
 722                     drawableInfo.load = indicesPtr->size();
 723
 724                 // put to list
 725                 drawables.push_back(drawableInfo);
 726             }
 727         }
 728
 729         // handle poxy groups
 730         ProxyGroup *proxy = dynamic_cast<ProxyGroup *>(core);
 731
 732         if(proxy != NULL)
 733         {
 734             DrawableInfo drawableInfo;
 735
 736             drawableInfo.node = node;
 737
 738             // get transformed volume
 739             node->updateVolume();
 740
 741             BoxVolume volume;
 742             node->getWorldVolume(volume);
 743
 744             // get min,max
 745             volume.getBounds(drawableInfo.bMin, drawableInfo.bMax);
 746
 747             // num of indices
 748             drawableInfo.load = proxy->getIndices();
 749
 750             // put to list
 751             drawables.push_back(drawableInfo);
 752         }
 753     }
 754
 755     MFUnrecChildNodePtr::const_iterator nI;
 756
 757     for(  nI  = node->getMFChildren()->begin();
 758           nI != node->getMFChildren()->end();
 759         ++nI)
 760     {
 761         collectDrawables(*nI, drawables);
 762     }
 763 }
 764
 765 /*! Split drawables in as many groups as we have servers
 766  *  Try to get clustered nodes
 767  */
 768
 769 void SortLastWindow::splitDrawables(DrawableListT &src,
 770                                     UInt32         groups,
 771                                     bool           cut)
 772 {
 773     BoxVolume                vol;
 774 //    Real32                   srcLoad=0;
 775     Real32                   dst1Load = 0;
 776     Real32                   dst2Load = 0;
 777     DrawableListT::iterator  dI;
 778     UInt32                   dIFront  = 0;
 779     UInt32                   dIBack   = 0;
 780     UInt32                   axis     = 0;
 781     Vec3f                    size;
 782     DrawableListT            dst1;
 783     DrawableListT            dst2;
 784     UInt32                   groups1  = 0;
 785     UInt32                   groups2  = 0;
 786
 787     // no group
 788     if(groups == 0)
 789         return;
 790
 791     // only one group
 792     if(groups == 1)
 793     {
 794         editMFGroupLengths()->push_back(UInt32(src.size()));
 795
 796         for(dI = src.begin() ; dI != src.end() ; ++dI)
 797         {
 798             pushToGroupNodes(dI->node);
 799 //            srcLoad+=dI->load;
 800         }
 801 //        printf("load:%f\n",srcLoad);
 802         return;
 803     }
 804
 805     groups1 = groups / 2;
 806     groups2 = groups - groups1;
 807
 808     // collect all load and get summed volume
 809     for(dI = src.begin() ; dI != src.end() ; ++dI)
 810     {
 811         vol.extendBy(dI->bMin);
 812         vol.extendBy(dI->bMax);
 813     }
 814
 815     // get longes axis
 816     vol.getSize(size);
 817
 818     if(size[0] > size[1])
 819     {
 820         if(size[0] > size[2])
 821             axis=0;
 822         else
 823             axis=2;
 824     }
 825     else
 826     {
 827         if(size[1] > size[2])
 828             axis=1;
 829         else
 830             axis=2;
 831     }
 832
 833     // sort by volume
 834     if(axis == 0)
 835     {
 836         std::sort(src.begin(),src.end(), DrawableInfo::MaxXOrder());
 837     }
 838     else
 839     {
 840         if(axis == 1)
 841             std::sort(src.begin(),src.end(), DrawableInfo::MaxYOrder());
 842         else
 843             std::sort(src.begin(),src.end(), DrawableInfo::MaxZOrder());
 844     }
 845
 846     // split group
 847     if(src.size())
 848     {
 849         dIFront  = 0;
 850         dIBack   = UInt32(src.size()) - 1;
 851         do
 852         {
 853 //            printf("f %d  b %d\n",dIFront,dIBack);
 854             if(dst2Load < dst1Load)
 855             {
 856                 dst2.push_back(src[dIBack]);
 857
 858                 dst2Load += src[dIBack].load*groups/Real32(groups2);
 859
 860                 dIBack--;
 861             }
 862             else
 863             {
 864                 dst1.push_back(src[dIFront]);
 865
 866                 dst1Load += src[dIFront].load*groups/Real32(groups1);
 867
 868                 dIFront++;
 869             }
 870         } while(dIFront <= dIBack);
 871     }
 872     // recourse
 873     splitDrawables(dst1, groups1, cut);
 874     splitDrawables(dst2, groups2, cut);
 875 }
 876
 877 void SortLastWindow::setupNodes(UInt32 groupId)
 878 {
 879     UInt32  v             = 0;
 880     Node   *root          = NULL;
 881     UInt32  nI            = 0;
 882     UInt32  gnI           = 0;
 883     UInt32  gI            = 0;
 884     UInt32  group         = 0;
 885     UInt32  groupCount    = 0;
 886     UInt32  usableServers = getMFServers()->size32();
 887
 888     if(!getGroupsChanged())
 889         return;
 890
 891     // client and no client rendering
 892     if(getMFServers()->size() == groupId &&
 893        (getComposer() == NULL ||
 894         !getComposer()->getClientRendering()))
 895     {
 896         for(nI = 0 ; nI < getMFGroupNodes()->size() ; ++nI)
 897         {
 898             if(getGroupNodes(nI)->getTravMask())
 899             {
 900                 getGroupNodes(nI)->setTravMask(0);
 901                 getGroupNodes(nI)->invalidateVolume();
 902             }
 903         }
 904
 905         return;
 906     }
 907
 908     if(getComposer() != NULL)
 909         usableServers = getComposer()->getUsableServers();
 910
 911     // server but not usable, then invalidate all nodes
 912     if((getMFServers()->size() > groupId && usableServers <= groupId))
 913     {
 914         for(v = 0; v < getMFPort()->size(); ++v)
 915         {
 916             root = getPort(v)->getRoot();
 917
 918             root->setTravMask(0);
 919             root->invalidateVolume();
 920         }
 921
 922         setGroupsChanged(false);
 923         return;
 924     }
 925
 926     groupCount = usableServers;
 927
 928     if(getComposer() != NULL)
 929     {
 930         groupCount = getComposer()->getUsableServers();
 931
 932         if(getComposer()->getClientRendering())
 933         {
 934             groupCount++;
 935         }
 936     }
 937
 938     if(getMFServers()->size() == groupId)
 939         groupId = usableServers;
 940
 941     // setup nodes
 942     for(nI = 0,gnI = 0,gI = 0,group = 0 ; nI < getMFGroupNodes()->size() ; ++nI)
 943     {
 944         while(nI >= gnI)
 945         {
 946             gnI += getGroupLengths(group);
 947             gI++;
 948             group = gI % groupCount;
 949         }
 950         if(group == groupId)
 951         {
 952             if(getGroupNodes(nI)->getTravMask() !=
 953                TypeTraits<UInt32>::getMax())
 954             {
 955                 getGroupNodes(nI)->setTravMask(TypeTraits<UInt32>::getMax());
 956                 getGroupNodes(nI)->invalidateVolume();
 957             }
 958         }
 959         else
 960         {
 961             if(getGroupNodes(nI)->getTravMask())
 962             {
 963                 getGroupNodes(nI)->setTravMask(0);
 964                 getGroupNodes(nI)->invalidateVolume();
 965             }
 966         }
 967
 968         getGroupNodes(nI)->updateVolume();
 969     }
 970
 971     setGroupsChanged(false);
 972 }
 973
 974 /*------------------------------------------------------------------------*/
 975 /*                           constructor / destructor                     */
 976
 977 /*! constructor
 978  */
 979 SortLastWindow::DrawableInfo::DrawableInfo():
 980     node(NULL),
 981     bMin(    ),
 982     bMax(    ),
 983     load(0.f )
 984 {
 985 }
 986
 987 /*! copy constructor
 988  */
 989
 990 SortLastWindow::DrawableInfo::DrawableInfo(const DrawableInfo &source) :
 991     node(source.node),
 992     bMin(source.bMin),
 993     bMax(source.bMax),
 994     load(source.load)
 995 {
 996 }
 997
 998 /*! assignment
 999  */
1000 const SortLastWindow::DrawableInfo &SortLastWindow::DrawableInfo::operator =(
1001     const DrawableInfo &source)
1002 {
1003     node = source.node;
1004     bMin = source.bMin;
1005     bMax = source.bMax;
1006     load = source.load;
1007
1008     return *this;
1009 }
1010
1011 /*! compare max x in bounding volume
1012  */
1013
1014 bool SortLastWindow::DrawableInfo::MaxXOrder::operator()
1015     (const DrawableInfo &a, const DrawableInfo &b)
1016 {
1017     return a.bMax[0] < b.bMax[0];
1018 }
1019
1020 /*! compare max y in bounding volume
1021  */
1022
1023 bool SortLastWindow::DrawableInfo::MaxYOrder::operator()
1024     (const DrawableInfo &a, const DrawableInfo &b)
1025 {
1026     return a.bMax[1] < b.bMax[1];
1027 }
1028
1029 /*! compare max z in bounding volume
1030  */
1031
1032 bool SortLastWindow::DrawableInfo::MaxZOrder::operator()
1033     (const DrawableInfo &a, const DrawableInfo &b)
1034 {
1035     return a.bMax[2] < b.bMax[2];
1036 }
1037
1038