bool Window::_cmdFrameStart( co::ICommand& cmd ) { co::ObjectICommand command( cmd ); LB_TS_THREAD( _pipeThread ); const uint128_t& version = command.read< uint128_t >(); const uint128_t& frameID = command.read< uint128_t >(); const uint32_t frameNumber = command.read< uint32_t >(); LBLOG( LOG_TASKS ) << "TASK frame start " << getName() << " " << command << " frame " << frameNumber << " id " << frameID << std::endl; //_grabFrame( frameNumber ); single-threaded sync( version ); const DrawableConfig& drawableConfig = getDrawableConfig(); if( drawableConfig.doublebuffered ) _renderContexts[FRONT].swap( _renderContexts[BACK] ); _renderContexts[BACK].clear(); makeCurrent(); frameStart( frameID, frameNumber ); return true; }
bool Window::getRenderContext( const int32_t x, const int32_t y, RenderContext& context ) const { LB_TS_THREAD( _pipeThread ); if( !_systemWindow ) return false; const DrawableConfig& drawableConfig = getDrawableConfig(); const unsigned which = drawableConfig.doublebuffered ? FRONT : BACK; std::vector< RenderContext >::const_reverse_iterator i = _renderContexts[which].rbegin(); std::vector< RenderContext >::const_reverse_iterator end = _renderContexts[which].rend(); // invert y to follow GL convention const int32_t glY = getPixelViewport().h - y; for( ; i != end; ++i ) { const RenderContext& candidate = *i; if( candidate.pvp.isInside( x, glY )) { context = candidate; return true; } } return false; }
bool Window::configInitSystemWindow( const eq::uint128_t& initID ) { #ifndef Darwin if( !eq::Window::configInitSystemWindow( initID )) return false; // OpenGL version is less than 2.0. if( !GLEW_EXT_framebuffer_object ) { if( getDrawableConfig().accumBits ) return true; configExitSystemWindow(); #endif // try with 64 bit accum buffer setIAttribute( eq::WindowSettings::IATTR_PLANES_ACCUM, 16 ); if( eq::Window::configInitSystemWindow( initID )) return true; // no anti-aliasing possible setIAttribute( eq::WindowSettings::IATTR_PLANES_ACCUM, eq::AUTO ); return eq::Window::configInitSystemWindow( initID ); #ifndef Darwin } return true; #endif }
Channel::Channel( eq::Window* parent ) : eq::Channel( parent ) { eq::FrameDataPtr frameData = new eq::FrameData; _frame.setFrameData( frameData ); for( unsigned i = 0; i < NUM_IMAGES; ++i ) frameData->newImage( eq::Frame::TYPE_MEMORY, getDrawableConfig( )); }
bool Window::_cmdSwap( co::Command& command ) { const WindowSwapPacket* packet = command.get< WindowSwapPacket >(); LBLOG( LOG_TASKS ) << "TASK swap buffers " << getName() << " " << packet << std::endl; if( getDrawableConfig().doublebuffered ) { // swap WindowStatistics stat( Statistic::WINDOW_SWAP, this ); makeCurrent(); swapBuffers(); } return true; }
bool Window::_cmdSwap( co::ICommand& cmd ) { co::ObjectICommand command( cmd ); LBLOG( LOG_TASKS ) << "TASK swap buffers " << getName() << " " << command << std::endl; if( getDrawableConfig().doublebuffered ) { // swap WindowStatistics stat( Statistic::WINDOW_SWAP, this ); makeCurrent(); swapBuffers(); } return true; }
bool Window::_cmdFrameStart( co::Command& command ) { LB_TS_THREAD( _pipeThread ); const WindowFrameStartPacket* packet = command.get<WindowFrameStartPacket>(); LBLOG( LOG_TASKS ) << "TASK frame start " << getName() << " " << packet << std::endl; //_grabFrame( packet->frameNumber ); single-threaded sync( packet->version ); const DrawableConfig& drawableConfig = getDrawableConfig(); if( drawableConfig.doublebuffered ) _renderContexts[FRONT].swap( _renderContexts[BACK] ); _renderContexts[BACK].clear(); makeCurrent(); frameStart( packet->frameID, packet->frameNumber ); return true; }
bool Window::processEvent( const Event& event ) { // see comment in _updateEvent _updateEvent( const_cast< Event& >( event )); switch( event.type ) { case Event::WINDOW_HIDE: setPixelViewport( PixelViewport( 0, 0, 0, 0 )); break; case Event::WINDOW_SHOW: case Event::WINDOW_RESIZE: setPixelViewport( PixelViewport( event.resize.x, event.resize.y, event.resize.w, event.resize.h )); break; case Event::KEY_PRESS: case Event::KEY_RELEASE: if( event.key.key == KC_VOID ) return true; // ignore // else fall through case Event::WINDOW_EXPOSE: case Event::WINDOW_CLOSE: case Event::STATISTIC: case Event::MAGELLAN_AXIS: case Event::MAGELLAN_BUTTON: break; case Event::WINDOW_POINTER_GRAB: _grabbedChannels = _getEventChannels( event.pointer ); break; case Event::WINDOW_POINTER_UNGRAB: _grabbedChannels.clear(); break; case Event::WINDOW_POINTER_MOTION: case Event::WINDOW_POINTER_BUTTON_PRESS: case Event::WINDOW_POINTER_BUTTON_RELEASE: case Event::WINDOW_POINTER_WHEEL: { const Channels& channels = _getEventChannels( event.pointer ); for( Channels::const_iterator i = channels.begin(); i != channels.end(); ++i ) { Channel* channel = *i; Event channelEvent = event; switch( event.type ) { case Event::WINDOW_POINTER_MOTION: channelEvent.type = Event::CHANNEL_POINTER_MOTION; break; case Event::WINDOW_POINTER_BUTTON_PRESS: channelEvent.type = Event::CHANNEL_POINTER_BUTTON_PRESS; break; case Event::WINDOW_POINTER_BUTTON_RELEASE: channelEvent.type = Event::CHANNEL_POINTER_BUTTON_RELEASE; break; case Event::WINDOW_POINTER_WHEEL: channelEvent.type = Event::CHANNEL_POINTER_WHEEL; break; default: LBWARN << "Unhandled window event of type " << event.type << std::endl; LBUNIMPLEMENTED; } // convert y to GL notation (Channel PVP uses GL coordinates) const PixelViewport& pvp = getPixelViewport(); const int32_t y = pvp.h - event.pointer.y; const PixelViewport& channelPVP = channel->getNativePixelViewport(); channelEvent.originator = channel->getID(); channelEvent.serial = channel->getSerial(); channelEvent.pointer.x -= channelPVP.x; channelEvent.pointer.y = channelPVP.h - y + channelPVP.y; channel->processEvent( channelEvent ); } break; } case Event::WINDOW_SCREENSAVER: switch( getIAttribute( WindowSettings::IATTR_HINT_SCREENSAVER )) { case OFF: return true; // screen saver stays inactive case ON: return false; // screen saver becomes active default: // AUTO if( getDrawableConfig().doublebuffered && getIAttribute( WindowSettings::IATTR_HINT_DRAWABLE ) == WINDOW ) { return true; // screen saver stays inactive } return false; } case Event::UNKNOWN: // unknown window-system native event, which was not handled return false; default: LBWARN << "Unhandled window event of type " << event.type << std::endl; LBUNIMPLEMENTED; } Config* config = getConfig(); ConfigEvent configEvent; configEvent.data = event; config->sendEvent( configEvent ); return true; }
void Channel::frameAssemble( const eq::uint128_t& frameID ) { const bool composeOnly = (_drawRange == eq::Range::ALL); eq::FrameData* data = _frame.getData(); _startAssemble(); const eq::Frames& frames = getInputFrames(); eq::PixelViewport coveredPVP; eq::Frames dbFrames; eq::Zoom zoom( eq::Zoom::NONE ); // Make sure all frames are ready and gather some information on them for( eq::Frames::const_iterator i = frames.begin(); i != frames.end(); ++i ) { eq::Frame* frame = *i; { eq::ChannelStatistics stat( eq::Statistic::CHANNEL_FRAME_WAIT_READY, this ); frame->waitReady( ); } const eq::Range& range = frame->getRange(); if( range == eq::Range::ALL ) // 2D frame, assemble directly eq::Compositor::assembleFrame( frame, this ); else { dbFrames.push_back( frame ); zoom = frame->getZoom(); _expandPVP( coveredPVP, frame->getImages(), frame->getOffset() ); } } coveredPVP.intersect( getPixelViewport( )); if( dbFrames.empty( )) { resetAssemblyState(); return; } // calculate correct frames sequence if( !composeOnly && coveredPVP.hasArea( )) { _frame.clear(); data->setRange( _drawRange ); dbFrames.push_back( &_frame ); } _orderFrames( dbFrames ); // check if current frame is in proper position, read back if not if( !composeOnly ) { if( _bgColor == eq::Vector3f::ZERO && dbFrames.front() == &_frame ) dbFrames.erase( dbFrames.begin( )); else if( coveredPVP.hasArea()) { eq::Window::ObjectManager* glObjects = getObjectManager(); _frame.setOffset( eq::Vector2i( 0, 0 )); _frame.setZoom( zoom ); data->setPixelViewport( coveredPVP ); _frame.readback( glObjects, getDrawableConfig( )); clearViewport( coveredPVP ); // offset for assembly _frame.setOffset( eq::Vector2i( coveredPVP.x, coveredPVP.y )); } } // blend DB frames in order try { eq::Compositor::assembleFramesSorted( dbFrames, this, 0, true /*blendAlpha*/ ); } catch( eq::Exception e ) { EQWARN << e << std::endl; } resetAssemblyState(); // Update range _drawRange = getRange(); }
bool Window::configInitGL( const eq::uint128_t& initID ) { LBINFO << "-----> Window::configInitGL(" << initID << ", " << getPixelViewport( ) << ", " << getViewport( ) << ")" << std::endl; bool init = false; LBASSERT( !_window.valid( )); if( !eq::Window::configInitGL( initID )) goto out; { const eq::PixelViewport& pvp = getPixelViewport( ); const eq::DrawableConfig& dc = getDrawableConfig( ); osg::ref_ptr< osg::GraphicsContext::Traits > traits = new osg::GraphicsContext::Traits( ); traits->x = pvp.x; traits->y = pvp.y; traits->width = pvp.w; traits->height = pvp.h; traits->red = traits->blue = traits->green = dc.colorBits; traits->alpha = dc.alphaBits; traits->stencil = dc.stencilBits; traits->doubleBuffer = dc.doublebuffered; #if 0 traits->pbuffer = ( getIAttribute( IATTR_HINT_DRAWABLE ) == eq::PBUFFER ); #endif std::ostringstream version; version << dc.glVersion; traits->glContextVersion = version.str( ); #if 0 Window* sharedWindow = static_cast< Window* >( getSharedContextWindow( )); if( sharedWindow && ( sharedWindow != this )) traits->sharedContext = sharedWindow->getGraphicsContext( ); #endif _window = new osgViewer::GraphicsWindowEmbedded( traits ); static_cast< Node* >( getNode( ))->addGraphicsContext( _window ); const unsigned int maxTexturePoolSize = osg::DisplaySettings::instance( )->getMaxTexturePoolSize( ); const unsigned int maxBufferObjectPoolSize = osg::DisplaySettings::instance( )->getMaxBufferObjectPoolSize( ); if( maxTexturePoolSize > 0 ) getState( )->setMaxTexturePoolSize( maxTexturePoolSize ); if( maxBufferObjectPoolSize > 0 ) getState( )->setMaxBufferObjectPoolSize( maxBufferObjectPoolSize ); initCapabilities( _window ); } init = true; out: if( !init ) cleanup( ); LBINFO << "<----- Window::configInitGL(" << initID << ")" << std::endl; return init; }