Source/System/Cluster/Window/SortFirst/OSGSortFirstWindow.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 #include "OSGConfig.h"
  46 #include "OSGGL.h"
  47 #include "OSGTileCameraDecorator.h"
  48 #include "OSGViewport.h"
  49 #include "OSGGeometry.h"
  50 #include "OSGStereoBufferViewport.h"
  51 #include "OSGSortFirstWindow.h"
  52 #include "OSGClusterViewBuffer.h"
  53 #include "OSGConnection.h"
  54 #include "OSGRenderNode.h"
  55 #include "OSGTileGeometryLoad.h"
  56 #include "OSGClusterNetwork.h"
  57 #include "OSGRenderActionBase.h"
  58
  59 OSG_USING_NAMESPACE
  60
  61 ClusterViewBuffer SortFirstWindow::_bufferHandler;
  62
  63 // #define USE_VPORT_SLICES
  64
  65 /*! \class OSG::SortFirstWindow
  66     \ingroup GrpSystemCluster
  67     Cluster rendering configuration for sort first image composition
  68 */
  69
  70 /*----------------------- constructors & destructors ----------------------*/
  71
  72 //! Constructor
  73
  74 SortFirstWindow::SortFirstWindow(void) :
  75     Inherited(),
  76     _tileLoadBalancer(NULL),
  77     _renderNode(NULL)
  78 {
  79 }
  80
  81 //! Copy Constructor
  82
  83 SortFirstWindow::SortFirstWindow(const SortFirstWindow &source) :
  84     Inherited(source),
  85     _tileLoadBalancer(NULL),
  86     _renderNode(NULL)
  87 {
  88 }
  89
  90 //! Destructor
  91
  92 SortFirstWindow::~SortFirstWindow(void)
  93 {
  94     if(_tileLoadBalancer)
  95         delete _tileLoadBalancer;
  96     if(_renderNode)
  97         delete _renderNode;
  98 }
  99
 100 /*----------------------------- class specific ----------------------------*/
 101
 102 //! initialize the static features of the class, e.g. action callbacks
 103
 104 void SortFirstWindow::initMethod(InitPhase ePhase)
 105 {
 106     Inherited::initMethod(ePhase);
 107 }
 108
 109 //! react to field changes
 110
 111 void SortFirstWindow::changed(ConstFieldMaskArg whichField,
 112                               UInt32            origin,
 113                               BitVector         details)
 114 {
 115     Inherited::changed(whichField, origin, details);
 116 }
 117
 118 //! output the instance for debug purposes
 119
 120 void SortFirstWindow::dump(      UInt32    ,
 121                            const BitVector ) const
 122 {
 123     SLOG << "Dump SortFirstWindow NI" << std::endl;
 124 }
 125
 126 /*----------------------------- server methods ----------------------------*/
 127
 128 /** transfer server cababilities to the client
 129  *
 130  **/
 131 void SortFirstWindow::serverInit(Window *serverWindow,
 132                                  UInt32   id)
 133 {
 134 #if USE_VPORT_SLICES
 135
 136 #else
 137     UInt32 sync;
 138     RenderNode renderNode;
 139     Connection *connection=getNetwork()->getMainConnection();
 140
 141     // create cluster node information
 142     // get performance
 143     renderNode.determinePerformance(serverWindow);
 144     renderNode.dump();
 145     // transfer to client for load balancing
 146     connection->putValue(id);
 147     renderNode.copyToBin(*connection);
 148     connection->flush();
 149     connection->selectChannel();
 150     connection->getValue(sync);
 151 #endif
 152 }
 153
 154 #ifdef OSG_OLD_RENDER_ACTION
 155 /** update server window
 156  *
 157  * todo: enamble frustum culling if error is removed
 158  **/
 159 void SortFirstWindow::serverRender( Window *serverWindow,
 160                                     UInt32 id,
 161                                     DrawActionBase *action )
 162 {
 163     TileCameraDecoratorPtr deco;
 164     ViewportPtr serverPort;
 165     ViewportPtr clientPort;
 166     UInt32 sv,cv,regionStart;
 167     UInt32 vpWidth;
 168     UInt32 vpHeight;
 169
 170     // duplicate viewports
 171     for(cv=0,sv=0;cv<getPort().size();cv++)
 172     {
 173         clientPort = getPort()[cv];
 174         if(serverWindow->getPort().size() <= sv)
 175         {
 176             // create new port
 177             //serverPort = StereoBufferViewport::create();
 178             serverPort = dynamic_cast<ViewportPtr>(clientPort->shallowCopy());
 179             deco=TileCameraDecorator::create();
 180
 181             serverWindow->addPort(serverPort);
 182             serverPort->setCamera(deco);
 183         }
 184         else
 185         {
 186             serverPort = serverWindow->getPort()[sv];
 187             deco=dynamic_cast<TileCameraDecoratorPtr>(serverPort->getCamera());
 188             if(serverWindow->getPort()[sv]->getType() !=
 189                clientPort->getType())
 190             {
 191                 // there is a viewport with the wrong type
 192                 serverPort = dynamic_cast<ViewportPtr>(clientPort->shallowCopy());
 193                 serverWindow->replacePort(sv, serverPort);//[sv] = serverPort;
 194                 serverPort->setCamera(deco);
 195             }
 196             else
 197             {
 198                 deco=dynamic_cast<TileCameraDecoratorPtr>(serverPort->getCamera());
 199             }
 200             //serverPort = serverWindow->getPort()[sv];
 201             //deco=TileCameraDecoratorPtr::dcast(serverPort->getCamera());
 202         }
 203
 204         // duplicate values
 205         regionStart=cv * getServers().size() * 4 + id * 4;
 206         serverPort->setSize(
 207             Real32(getRegion()[regionStart+0] + clientPort->getPixelLeft()),
 208             Real32(getRegion()[regionStart+1] + clientPort->getPixelBottom()),
 209             Real32(getRegion()[regionStart+2] + clientPort->getPixelLeft()),
 210             Real32(getRegion()[regionStart+3] + clientPort->getPixelBottom()));
 211
 212         serverPort->setRoot      ( clientPort->getRoot()       );
 213         serverPort->setBackground( clientPort->getBackground() );
 214
 215         serverPort->assignForegrounds(clientPort->getForegrounds());
 216
 217         serverPort->setTravMask  ( clientPort->getTravMask()   );
 218
 219         // calculate tile parameters
 220         vpWidth =clientPort->getPixelWidth();
 221         vpHeight=clientPort->getPixelHeight();
 222
 223         deco->setFullWidth ( vpWidth );
 224         deco->setFullHeight( vpHeight );
 225         deco->setSize( getRegion()[ regionStart+0 ]/(float)vpWidth,
 226                        getRegion()[ regionStart+1 ]/(float)vpHeight,
 227                        getRegion()[ regionStart+2 ]/(float)vpWidth,
 228                        getRegion()[ regionStart+3 ]/(float)vpHeight );
 229         deco->setDecoratee( clientPort->getCamera() );
 230
 231         sv++;
 232     }
 233     // remove unused ports
 234     while(serverWindow->getPort().size()>sv)
 235     {
 236         serverWindow->subPort(sv);
 237     }
 238
 239     Inherited::serverRender(serverWindow,id,action);
 240
 241     // compression type
 242     if(getCompose())
 243     {
 244         if(getCompression().empty())
 245         {
 246             _bufferHandler.setImgTransType(NULL);
 247         }
 248         else
 249         {
 250             _bufferHandler.setImgTransType(getCompression().c_str());
 251         }
 252         if(getSubtileSize())
 253         {
 254             _bufferHandler.setSubtileSize(getSubtileSize());
 255         }
 256     }
 257
 258 #if 1
 259     glDisable(GL_SCISSOR_TEST);
 260     glClearColor(0,0,0,0);
 261     glClear(GL_COLOR_BUFFER_BIT);
 262 #endif
 263
 264     // render the viewports
 265     serverWindow->activate();
 266     serverWindow->frameInit();
 267     action->setWindow( serverWindow );
 268     for(sv=0;sv<serverWindow->getPort().size();++sv)
 269     {
 270         ViewportPtr vp=serverWindow->getPort()[sv];
 271         vp->render( action );
 272
 273         // send resulting image
 274         if(getCompose())
 275         {
 276             // activate the appropriate viewport to retrieve image
 277             vp->activate();
 278
 279             // send image
 280             _bufferHandler.send(
 281                 *getNetwork()->getMainPointConnection(),
 282                 ClusterViewBuffer::RGB,
 283                 vp->getPixelLeft(),
 284                 vp->getPixelBottom(),
 285                 vp->getPixelRight(),
 286                 vp->getPixelTop(),
 287                 0,0);
 288
 289             // deactivate the viewport
 290             vp->deactivate();
 291         }
 292     }
 293 }
 294 #endif
 295
 296 void SortFirstWindow::serverRender( Window           *serverWindow,
 297                                     UInt32            id,
 298                                     RenderActionBase *action )
 299 {
 300     TileCameraDecoratorUnrecPtr deco;
 301     ViewportUnrecPtr serverPort;
 302     Viewport *clientPort;
 303     UInt32 sv,cv,regionStart;
 304     UInt32 vpWidth;
 305     UInt32 vpHeight;
 306
 307     // duplicate viewports
 308     for(cv=0,sv=0;cv<getMFPort()->size();cv++)
 309     {
 310         clientPort = getPort(cv);
 311         if(serverWindow->getMFPort()->size() <= sv)
 312         {
 313             // create new port
 314             //serverPort = StereoBufferViewport::create();
 315             serverPort =
 316                 dynamic_pointer_cast<Viewport>(clientPort->shallowCopy());
 317             deco=TileCameraDecorator::create();
 318
 319             serverWindow->addPort(serverPort);
 320             serverPort->setCamera(deco);
 321         }
 322         else
 323         {
 324             serverPort = serverWindow->getPort(sv);
 325             deco=dynamic_cast<TileCameraDecorator *>(serverPort->getCamera());
 326             if(serverWindow->getPort(sv)->getType() !=
 327                clientPort->getType())
 328             {
 329                 // there is a viewport with the wrong type
 330                 serverPort = dynamic_pointer_cast<Viewport>(
 331                     clientPort->shallowCopy());
 332
 333                 serverWindow->replacePort(sv,
 334                                           serverPort);//[sv] = serverPort;
 335                 serverPort->setCamera(deco);
 336             }
 337             else
 338             {
 339                 deco=dynamic_cast<TileCameraDecorator *>(
 340                     serverPort->getCamera());
 341             }
 342             //serverPort = serverWindow->getPort()[sv];
 343             //deco=TileCameraDecoratorPtr::dcast(serverPort->getCamera());
 344         }
 345
 346         // duplicate values
 347         regionStart=cv * getMFServers()->size32() * 4 + id * 4;
 348         serverPort->setSize(
 349             Real32(getRegion(regionStart+0) + clientPort->calcPixelLeft()),
 350             Real32(getRegion(regionStart+1) + clientPort->calcPixelBottom()),
 351             Real32(getRegion(regionStart+2) + clientPort->calcPixelLeft()),
 352             Real32(getRegion(regionStart+3) + clientPort->calcPixelBottom()));
 353
 354         serverPort->setRoot      ( clientPort->getRoot()       );
 355         serverPort->setBackground( clientPort->getBackground() );
 356
 357         serverPort->assignForegrounds(*(clientPort->getMFForegrounds()));
 358
 359         serverPort->setTravMask  ( clientPort->getTravMask()   );
 360
 361         // calculate tile parameters
 362         vpWidth =clientPort->calcPixelWidth();
 363         vpHeight=clientPort->calcPixelHeight();
 364
 365         deco->setFullWidth ( vpWidth );
 366         deco->setFullHeight( vpHeight );
 367         deco->setSize( getRegion( regionStart+0 )/Real32(vpWidth),
 368                        getRegion( regionStart+1 )/Real32(vpHeight),
 369                        getRegion( regionStart+2 )/Real32(vpWidth),
 370                        getRegion( regionStart+3 )/Real32(vpHeight) );
 371         deco->setDecoratee( clientPort->getCamera() );
 372
 373         sv++;
 374     }
 375     // remove unused ports
 376     while(serverWindow->getMFPort()->size()>sv)
 377     {
 378         serverWindow->subPort(sv);
 379     }
 380
 381     Inherited::serverRender(serverWindow,id,action);
 382
 383     // compression type
 384     if(getCompose())
 385     {
 386         if(getCompression().empty())
 387         {
 388             _bufferHandler.setImgTransType(NULL);
 389         }
 390         else
 391         {
 392             _bufferHandler.setImgTransType(getCompression().c_str());
 393         }
 394         if(getSubtileSize())
 395         {
 396             _bufferHandler.setSubtileSize(getSubtileSize());
 397         }
 398     }
 399
 400 #if 1
 401     glDisable(GL_SCISSOR_TEST);
 402     glClearColor(0,0,0,0);
 403     glClear(GL_COLOR_BUFFER_BIT);
 404 #endif
 405
 406     // render the viewports
 407     serverWindow->activate();
 408     serverWindow->frameInit();
 409     action->setWindow( serverWindow );
 410     for(sv=0;sv<serverWindow->getMFPort()->size();++sv)
 411     {
 412         Viewport *vp=serverWindow->getPort(sv);
 413         vp->render( action );
 414
 415         // send resulting image
 416         if(getCompose())
 417         {
 418             // activate the appropriate viewport to retrieve image
 419             vp->activate();
 420
 421             // send image
 422             _bufferHandler.send(
 423                 *getNetwork()->getMainPointConnection(),
 424                 ClusterViewBuffer::RGB,
 425                 vp->calcPixelLeft(),
 426                 vp->calcPixelBottom(),
 427                 vp->calcPixelRight(),
 428                 vp->calcPixelTop(),
 429                 0,0);
 430
 431             // deactivate the viewport
 432             vp->deactivate();
 433         }
 434     }
 435 }
 436
 437 /*! send image to client
 438  */
 439 void SortFirstWindow::serverSwap( Window *window,
 440                                   UInt32 )
 441 {
 442     if(!getCompose())
 443     {
 444         Connection *connection=getNetwork()->getMainConnection();
 445         connection->signal();
 446         connection->wait();
 447     }
 448     window->swap();
 449 }
 450
 451 /*----------------------------- client methods ----------------------------*/
 452
 453 /*! read server cababilities
 454  */
 455
 456 void SortFirstWindow::clientInit( void )
 457 {
 458 #if USE_VPORT_SLICES
 459
 460 #else
 461     UInt32               id;
 462     RenderNode           renderNode;
 463     GroupConnection     *connection = getNetwork()->getMainGroupConnection();
 464     Connection::Channel  channel;
 465
 466     _tileLoadBalancer=new TileLoadBalancer(getUseFaceDistribution());
 467     // read all node infos
 468     for(UInt32 i=0;i<connection->getChannelCount();++i)
 469     {
 470         printf("%d\n",i);
 471         channel = connection->selectChannel();
 472         connection->subSelection(channel);
 473         connection->getValue(id);
 474         renderNode.copyFromBin(*connection);
 475         renderNode.dump();
 476         _tileLoadBalancer->addRenderNode(renderNode,id);
 477     }
 478     connection->resetSelection();
 479     printf("end\n");
 480     // sync servers
 481     connection->putValue(id);
 482     connection->flush();
 483 #endif
 484
 485     Inherited::clientInit();
 486 }
 487
 488 /*! client frame init
 489  */
 490
 491 void SortFirstWindow::clientPreSync( void )
 492 {
 493     if(getCompose())
 494     {
 495         // get window size from client window
 496         if(getClientWindow() != NULL)
 497         {
 498             if(getWidth()  != getClientWindow()->getWidth() ||
 499                getHeight() != getClientWindow()->getHeight())
 500             {
 501                 setSize(getClientWindow()->getWidth(),
 502                         getClientWindow()->getHeight());
 503             }
 504         }
 505     }
 506 #if 0
 507     else
 508     {
 509         setSize(1280,
 510                 1024);
 511     }
 512 #endif
 513     UInt32 i;
 514     UInt32 cv;
 515     TileLoadBalancer::ResultT region;
 516
 517     editMFRegion()->clear();
 518 #if USE_VPORT_SLICES
 519     for(cv=0;cv<getPort().size();cv++)
 520     {
 521         int s=getServers().size();
 522         for(i=0;i<s;i++)
 523         {
 524             editRegion().push_back(i/float(s)*getWidth());
 525             editRegion().push_back(0);
 526             editRegion().push_back((i+1)/float(s)*getWidth());
 527             editRegion().push_back(1*getHeight());
 528         }
 529     }
 530 #else
 531     for(cv=0;cv<getMFPort()->size();cv++)
 532     {
 533         _tileLoadBalancer->update( getPort(cv)->getRoot() );
 534         _tileLoadBalancer->balance(getPort(cv),
 535                               false,
 536                               region);
 537         for(i=0;i<getMFServers()->size();i++)
 538         {
 539             editMFRegion()->push_back(region[i].x1);
 540             editMFRegion()->push_back(region[i].y1);
 541             editMFRegion()->push_back(region[i].x2);
 542             editMFRegion()->push_back(region[i].y2);
 543         }
 544     }
 545 #endif
 546
 547     Inherited::clientPreSync();
 548 }
 549
 550 #ifdef OSG_OLD_RENDER_ACTION
 551 /*! client rendering
 552  *
 553  *  one tile is rendered by the client
 554  */
 555
 556 void SortFirstWindow::clientRender( RenderActionBase *  /* action */ )
 557 {
 558 //    Inherited::clientRender(action);
 559 }
 560 #endif
 561
 562 void SortFirstWindow::clientRender(RenderActionBase *  /* action */)
 563 {
 564 //    Inherited::clientRender(action);
 565 }
 566
 567 /*! show data
 568  */
 569
 570 void SortFirstWindow::clientSwap( void )
 571 {
 572     UInt32 cv;
 573     GroupConnection *connection=getNetwork()->getMainGroupConnection();
 574     if(getCompose())
 575     {
 576         if(getClientWindow()!=NULL)
 577         {
 578             // receive all viewports
 579             for(cv=0;cv<getMFPort()->size();++cv)
 580             {
 581                 Viewport *vp=getPort(cv);
 582
 583                 // activate the appropriate viewport to receive image
 584                 vp->activate();
 585
 586                 // receive image
 587                 _bufferHandler.recv(*connection);
 588
 589                 // deactivate the viewport
 590                 vp->deactivate();
 591             }
 592             Inherited::clientSwap();
 593         }
 594     }
 595     else
 596     {
 597         connection->wait();
 598         connection->signal();
 599     }
 600 }
 601