OSG::BinarySwapComposer Class Reference

00097     {
00098         ShortFieldId = Inherited::NextFieldId,
00099         AlphaFieldId = ShortFieldId + 1,
00100         TileSizeFieldId = AlphaFieldId + 1,
00101         NextFieldId = TileSizeFieldId + 1
00102     };

00096     {
00097         EnabledFieldId = Inherited::NextFieldId,
00098         StatisticsFieldId = EnabledFieldId + 1,
00099         NextFieldId = StatisticsFieldId + 1
00100     };

00066                                            :
00067     Inherited(),
00068     _writer(NULL),
00069     _barrier(NULL),
00070     _stopWriter(false),
00071     _intDepthMax(0xffffffff),
00072     _shortDepthMax(0xffff)
00073 {
00074 }

00076                                                                        :
00077     Inherited(source),
00078     _writer(NULL),
00079     _barrier(NULL),
00080     _stopWriter(false),
00081     _intDepthMax(0xffffffff),
00082     _shortDepthMax(0xffff)
00083 {
00084 }

00087 {
00088 }

00095 {
00096     Inherited::changed(whichField, origin, details);
00097 }

00101 {
00102     SLOG << "Dump BinarySwapComposer NI" << std::endl;
00103 }

00110 {
00111     return false;
00112 }

00117 {
00118     // determine usable servers
00119     if(osgIsPower2(serverCount()))
00120         _usableServers = serverCount();
00121     else
00122         _usableServers = osgNextPower2(serverCount()) / 2;
00123 
00124 //    _usableServers = 1;
00125 
00126     // create server cross connection
00127     _clusterWindow->getNetwork()->connectAllPointToPoint(clusterId(),
00128                                                          "StreamSock");
00129     // do not buffer any data
00130     for(UInt32 i=0 ; i <= serverCount() ; ++i)
00131         clusterWindow()->getNetwork()->getConnection(i)->forceDirectIO();
00132 
00133 /*
00134     // create barrier
00135     _barrier = Barrier::get(NULL);
00136     // create writer thread
00137     _writer = BaseThread::get(NULL);
00138 */
00139 
00140     // read whole buffer
00141     if(!_isClient && clusterId() < _usableServers)
00142     {
00143         // create barrier
00144         _barrier = Barrier::get(NULL);
00145         // create writer thread
00146         _writer = BaseThread::get(NULL);
00147         // start writer thread
00148         _writer->runFunction( writeProc, this );
00149     }
00150     else
00151     {
00152         _writer = NULL;
00153     }
00154 }

00157 {
00158     // setup viewport
00159     GLint 
00160         pl=port->getPixelLeft(), 
00161         pr=port->getPixelRight(),
00162         pb=port->getPixelBottom(), 
00163         pt=port->getPixelTop();
00164     GLint pw=pr-pl+1,ph=pt-pb+1;
00165     bool full = port->isFullWindow();
00166     glViewport(pl, pb, pw, ph);
00167     glScissor(pl, pb, pw, ph);
00168     if(! full)
00169         glEnable(GL_SCISSOR_TEST);
00170 
00171     GLboolean depth = glIsEnabled(GL_DEPTH_TEST);
00172     GLboolean blend = glIsEnabled(GL_BLEND);
00173 
00174     glDisable(GL_DEPTH_TEST);
00175     glPushMatrix();
00176     glLoadIdentity();
00177     glMatrixMode(GL_PROJECTION);
00178     glPushMatrix();
00179     glLoadIdentity();
00180     glOrtho(0, port->getPixelWidth(),
00181             0, port->getPixelHeight(),-1,1);
00182 
00183 //    printf("max %x,%x\n",_intDepthMax,_shortDepthMax);
00184 
00185     if(getAlpha())
00186     {
00187         glEnable(GL_BLEND);
00188         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00189     }
00190     _tilesX = port->getPixelWidth()  / getTileSize() + 1;
00191     _tilesY = port->getPixelHeight() / getTileSize() + 1;
00192 
00193     _tileBufferSize = getTileSize()*getTileSize()*8+sizeof(TileBuffer);
00194     _readTile.resize(_tileBufferSize);
00195 
00196     _statistics.bytesIn  = 0;
00197     _statistics.bytesOut = 0;
00198 
00199     if(isClient())
00200     {
00201         if(getShort())
00202         {
00203             UInt16 colorDummy;
00204             UInt32 depthDummy;
00205             recvFromServers(depthDummy,colorDummy,
00206                             GL_RGB,
00207                             GL_UNSIGNED_SHORT_5_6_5,
00208                             port);
00209         }
00210         else
00211         {
00212             if(getAlpha())
00213             {
00214                 UInt32 colorDummy;
00215                 UInt32 depthDummy;
00216                 recvFromServers(depthDummy,colorDummy,
00217                                 GL_RGBA,
00218                                 GL_UNSIGNED_BYTE,
00219                                 port);
00220             }
00221             else
00222             {
00223                 RGBValue colorDummy;
00224                 UInt32   depthDummy;
00225                 recvFromServers(depthDummy,colorDummy,
00226                                 GL_RGB,
00227                                 GL_UNSIGNED_BYTE,
00228                                 port);
00229             }
00230         }
00231         if(getStatistics())
00232         {
00233             UInt32      maxIn   = _statistics.bytesIn;
00234             UInt32      maxOut  = _statistics.bytesOut;
00235             UInt32      maxIO   = maxIn + maxOut;
00236             UInt32      sumOut  = _statistics.bytesOut;
00237             UInt32      missing = _usableServers;
00238             double      composeTime = 1e32;
00239             
00240             Connection *server;
00241             Statistics  statistics;
00242             for</