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;
}
