void Channel::frameViewFinish( const eq::uint128_t& frameID )
{
if( stopRendering( ))
return;
applyBuffer();
const FrameData& frameData = _getFrameData();
Accum& accum = _accum[ lunchbox::getIndexOfLastBit( getEye()) ];
if( accum.buffer )
{
const eq::PixelViewport& pvp = getPixelViewport();
const bool isResized = accum.buffer->resize( pvp );
if( isResized )
{
const View* view = static_cast< const View* >( getView( ));
accum.buffer->clear();
accum.step = view->getIdleSteps();
accum.stepsDone = 0;
}
else if( frameData.isIdle( ))
{
setupAssemblyState();
if( !_isDone() && accum.transfer )
accum.buffer->accum();
accum.buffer->display();
resetAssemblyState();
}
}
applyViewport();
_drawOverlay();
_drawHelp();
if( frameData.useStatistics())
drawStatistics();
int32_t steps = 0;
if( frameData.isIdle( ))
{
for( size_t i = 0; i < eq::NUM_EYES; ++i )
steps = LB_MAX( steps, _accum[i].step );
}
else
{
const View* view = static_cast< const View* >( getView( ));
steps = view ? view->getIdleSteps() : 0;
}
// if _jitterStep == 0 and no user redraw event happened, the app will exit
// FSAA idle mode and block on the next redraw event.
eq::Config* config = getConfig();
config->sendEvent( IDLE_AA_LEFT ) << steps;
eq::Channel::frameViewFinish( frameID );
}
/////////////////////////////////////////////////////////
// renderMess
//
/////////////////////////////////////////////////////////
void GemBase :: gem_renderMess(GemCache* cache, GemState*state)
{
m_cache=cache;
if(m_cache && m_cache->m_magic!=GEMCACHE_MAGIC) {
m_cache=NULL;
}
if(INIT==m_state) {
if(isRunnable()) {
m_state=ENABLED;
} else {
m_state=DISABLED;
}
}
if(MODIFIED==m_state) {
stopRendering();
m_state=ENABLED;
}
if(ENABLED==m_state) {
startRendering();
m_state=RENDERING;
}
if(RENDERING==m_state) {
gem_amRendering=true;
if(state) {
render(state);
}
continueRender(state);
if(state) {
postrender(state);
}
}
m_modified=false;
}
void RenderThread::render(RenderRequest* req)
{
logFiner(QString("RenderThread::render : req 0x%1").arg((long)req,0,16));
if (req->type() == RenderRequest::Preview)
{
preview_request = req;
// rendering a preview preempts everything except files and previews
if (isRendering())
switch (current_request->type())
{
case RenderRequest::Image:
case RenderRequest::Queued:
stopRendering();
default:
;
}
}
else if (req->type() == RenderRequest::Image)
image_request = req;
else if (request_queue.contains(req))
logWarn(QString("RenderThread::render : req 0x%1 already queued")
.arg((long)req,0,16));
else
{
logFine("RenderThread::render : queueing req %#x", (long)req);
req->setFinished(false);
rqueue_mutex.lock();
request_queue.enqueue(req);
rqueue_mutex.unlock();
}
}
/////////////////////////////////////////////////////////
// gem_cacheMess
//
/////////////////////////////////////////////////////////
void GemBase :: gem_startstopMess(int state)
{
// for now, this is important, as it is the only way to call the stopRendering
#if 1
if (state && !gem_amRendering) {
m_enabled = isRunnable();
if(m_enabled) {
startRendering();
m_state=RENDERING;
}
} else if (!state && gem_amRendering) {
if(m_enabled) {
stopRendering();
m_state=ENABLED;
}
}
gem_amRendering=(state!=0);
// continue sending out the cache message
t_atom ap[1];
SETFLOAT(ap, state);
outlet_anything(this->m_out1, gensym("gem_state"), 1, ap);
#else
post("gem_startstopMess(%d) called...please report this to the upstream developers",
state);
#endif
}
void Channel::frameClear( const eq::uint128_t& /*frameID*/ )
{
if( stopRendering( ))
return;
_initJitter();
resetRegions();
const FrameData& frameData = _getFrameData();
const int32_t eyeIndex = lunchbox::getIndexOfLastBit( getEye() );
if( _isDone() && !_accum[ eyeIndex ].transfer )
return;
applyBuffer();
applyViewport();
const eq::View* view = getView();
if( view && frameData.getCurrentViewID() == view->getID( ))
glClearColor( 1.f, 1.f, 1.f, 0.f );
#ifndef NDEBUG
else if( getenv( "EQ_TAINT_CHANNELS" ))
{
const eq::Vector3ub color = getUniqueColor();
glClearColor( color.r()/255.f, color.g()/255.f, color.b()/255.f, 0.f );
}
#endif // NDEBUG
else
glClearColor( 0.f, 0.f, 0.f, 0.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
}
void Channel::frameReadback( const eq::uint128_t& frameID,
const eq::Frames& frames )
{
if( stopRendering() || _isDone( ))
return;
const FrameData& frameData = _getFrameData();
for( eq::FramesCIter i = frames.begin(); i != frames.end(); ++i )
{
eq::Frame* frame = *i;
// OPT: Drop alpha channel from all frames during network transport
frame->setAlphaUsage( false );
if( frameData.isIdle( ))
frame->setQuality( eq::Frame::BUFFER_COLOR, 1.f );
else
frame->setQuality( eq::Frame::BUFFER_COLOR, frameData.getQuality());
if( frameData.useCompression( ))
frame->useCompressor( eq::Frame::BUFFER_COLOR, EQ_COMPRESSOR_AUTO );
else
frame->useCompressor( eq::Frame::BUFFER_COLOR, EQ_COMPRESSOR_NONE );
}
eq::Channel::frameReadback( frameID, frames );
}
void GemMan :: destroyWindow()
{
GemMan::pleaseDestroy=false;
// don't want to get rid of this
// if (s_singleContext) return;
// nothing to destroy...
if (!m_windowState) return;
stopRendering();
clock_unset(s_windowClock);
s_windowClock = NULL;
glFlush();
glFinish();
destroyGemWindow(gfxInfo);
m_windowState = 0;
windowCleanup();
// this should really go into the GemWinCreate<OS> files::
// reestablish the const glxContext
/* this crashes on linux with intel cards */
gemWinMakeCurrent(constInfo);
s_windowRun = 0;
}
SWGISBrowser::SWGISBrowser(QWidget *parent, const Qt::WindowFlags& flags)
: QMainWindow(parent)
, m_DirtyAttributes(true)
, m_DirtyMetadata(true)
, m_DirtyPreview(true)
, m_ParamWidget(nullptr)
, ui(new Ui::SWGISBrowser)
{
ui->setupUi(this);
ui->tabWidget->setTabEnabled(ui->tabWidget->indexOf(ui->paramTab),false);
ui->tabWidget->setTabEnabled(ui->tabWidget->indexOf(ui->metaDataTab),false);
ui->tabWidget->setTabEnabled(ui->tabWidget->indexOf(ui->PreviewTab),false);
ui->tabWidget->setTabEnabled(ui->tabWidget->indexOf(ui->attributesTab),false);
this->m_Model = new QgsBrowserModel(ui->treeView);
ui->treeView->setModel(this->m_Model);
connect(ui->treeView, SIGNAL(clicked(const QModelIndex&)), this, SLOT(itemClicked(const QModelIndex&)));
ui->treeView->setExpandsOnDoubleClick(false);
connect(ui->treeView, SIGNAL(doubleClicked(const QModelIndex&)), this, SLOT(itemDoubleClicked(const QModelIndex&)));
connect(ui->treeView, SIGNAL(expanded( const QModelIndex&)), this, SLOT(itemExpanded(const QModelIndex&)));
connect(ui->tabWidget, SIGNAL(currentChanged( int )), this, SLOT(tabChanged()));
// connect( mActionNewVectorLayer, SIGNAL( triggered() ), this, SLOT( newVectorLayer() ) );
connect( ui->stopRenderingButton, SIGNAL( clicked() ), this, SLOT( stopRendering() ) );
ui->mapCanvas->setCanvasColor(Qt::white);
new QgsCredentialDialog(this);
}
void SWGISBrowser::keyPressEvent(QKeyEvent *e)
{
QgsDebugMsg(tr("Entered"));
if(e->key() == Qt::Key_Escape)
stopRendering();
else
e->ignore();
}
OSGViewerWidget::~OSGViewerWidget()
{
osgViewer::View::EventHandlers handlers = getEventHandlers();
for (osgViewer::View::EventHandlers::iterator it = handlers.begin(); it != handlers.end(); ++ it)
this->removeEventHandler(*it);
stopRendering();
}
void MandelbrotWidget::setThreadCount(int threadCount)
{
Q_ASSERT(threadCount > 0);
stopRendering();
m_threadCount = threadCount;
initThreads();
}
/////////////////////////////////////////////////////////
// realStopRendering
//
/////////////////////////////////////////////////////////
void GemBase :: realStopRendering(void)
{
/* no idea what this function is for; ask the user when it appears */
post("realStopRendering() called...please report this to the upstream developers");
stopRendering();
m_cache = NULL;
m_state=ENABLED;
}
void Channel::frameViewStart( const eq::uint128_t& frameID )
{
if( stopRendering( ))
return;
_currentPVP = getPixelViewport();
_initJitter();
eq::Channel::frameViewStart( frameID );
}
void Channel::frameAssemble( const eq::uint128_t& frameID )
{
if( stopRendering( ))
return;
if( _isDone( ))
return;
Accum& accum = _accum[ lunchbox::getIndexOfLastBit( getEye()) ];
if( getPixelViewport() != _currentPVP )
{
accum.transfer = true;
if( accum.buffer && !accum.buffer->usesFBO( ))
{
LBWARN << "Current viewport different from view viewport, "
<< "idle anti-aliasing not implemented." << std::endl;
accum.step = 0;
}
eq::Channel::frameAssemble( frameID );
return;
}
// else
accum.transfer = true;
const eq::Frames& frames = getInputFrames();
for( eq::Frames::const_iterator i = frames.begin(); i != frames.end(); ++i )
{
eq::Frame* frame = *i;
const eq::SubPixel& curSubPixel = frame->getSubPixel();
if( curSubPixel != eq::SubPixel::ALL )
accum.transfer = false;
accum.stepsDone = LB_MAX( accum.stepsDone,
frame->getSubPixel().size*frame->getPeriod( ));
}
applyBuffer();
applyViewport();
setupAssemblyState();
try
{
eq::Compositor::assembleFrames( getInputFrames(), this, accum.buffer );
}
catch( const co::Exception& e )
{
LBWARN << e.what() << std::endl;
}
resetAssemblyState();
}
/////////////////////////////////////////////////////////
// Destructor
//
/////////////////////////////////////////////////////////
gemhead :: ~gemhead()
{
if (m_cache) {
stopRendering();
}
if(m_cache) {
delete m_cache;
}
m_cache=NULL;
}
/////////////////////////////////////////////////////////
// Destructor
//
/////////////////////////////////////////////////////////
GemBase :: ~GemBase()
{
if (gem_amRendering){
stopRendering();
gem_amRendering=false;
}
if (m_out1)
outlet_free(m_out1);
}
void RenderThread::stop()
{
running = false;
preview_request = 0;
image_request = 0;
rqueue_mutex.lock();
request_queue.clear();
rqueue_mutex.unlock();
stopRendering();
}
void MandelbrotWidget::setRenderingSize(int width, int height)
{
Q_ASSERT(width > 0);
Q_ASSERT(height > 0);
stopRendering();
m_img = QImage(width, height, QImage::Format_RGB32);
m_renderingSize = QSize(width, height);
setMinimumSize(width, height);
}
QgsBrowser::QgsBrowser( QWidget *parent, Qt::WFlags flags )
: QMainWindow( parent, flags )
, mDirtyMetadata( true )
, mDirtyPreview( true )
, mDirtyAttributes( true )
, mLayer( 0 )
, mParamWidget( 0 )
, mAttributeTableFilterModel( 0 )
{
setupUi( this );
// Disable tabs by default
tabWidget->setTabEnabled( tabWidget->indexOf( paramTab ), false );
tabWidget->setTabEnabled( tabWidget->indexOf( metaTab ), false );
tabWidget->setTabEnabled( tabWidget->indexOf( previewTab ), false );
tabWidget->setTabEnabled( tabWidget->indexOf( attributesTab ), false );
mModel = new QgsBrowserModel( treeView );
treeView->setModel( mModel );
// Last expanded is stored, don't cover whole height with file system
//treeView->expand( mModel->index(0,0) );
connect( treeView, SIGNAL( clicked( const QModelIndex& ) ), this, SLOT( itemClicked( const QModelIndex& ) ) );
treeView->setExpandsOnDoubleClick( false );
connect( treeView, SIGNAL( doubleClicked( const QModelIndex& ) ), this, SLOT( itemDoubleClicked( const QModelIndex& ) ) );
connect( treeView, SIGNAL( expanded( const QModelIndex& ) ), this, SLOT( itemExpanded( const QModelIndex& ) ) );
connect( tabWidget, SIGNAL( currentChanged( int ) ), this, SLOT( tabChanged() ) );
connect( mActionNewVectorLayer, SIGNAL( triggered() ), this, SLOT( newVectorLayer() ) );
connect( stopRenderingButton, SIGNAL( clicked() ), this, SLOT( stopRendering() ) );
mapCanvas->setCanvasColor( Qt::white );
QSettings settings;
QString lastPath = settings.value( "/Browser/lastExpanded" ).toString();
QgsDebugMsg( "lastPath = " + lastPath );
if ( !lastPath.isEmpty() )
{
expandPath( lastPath );
}
//Set the icon size of for all the toolbars created in the future.
int size = settings.value( "/IconSize", QGIS_ICON_SIZE ).toInt();
setIconSize( QSize( size, size ) );
//Change all current icon sizes.
QList<QToolBar *> toolbars = findChildren<QToolBar *>();
foreach ( QToolBar * toolbar, toolbars )
{
toolbar->setIconSize( QSize( size, size ) );
}
void Channel::frameAssemble( const eq::uint128_t& frameID,
const eq::Frames& frames )
{
if( stopRendering( ))
return;
if( _isDone( ))
return;
Accum& accum = _accum[ lunchbox::getIndexOfLastBit( getEye()) ];
if( getPixelViewport() != _currentPVP )
{
accum.transfer = true;
if( accum.buffer && !accum.buffer->usesFBO( ))
{
LBWARN << "Current viewport different from view viewport, "
<< "idle anti-aliasing not implemented." << std::endl;
accum.step = 0;
}
eq::Channel::frameAssemble( frameID, frames );
return;
}
// else
accum.transfer = true;
for( eq::Frame* frame : frames )
{
const eq::SubPixel& subPixel =
frame->getFrameData()->getContext().subPixel;
if( subPixel != eq::SubPixel::ALL )
accum.transfer = false;
accum.stepsDone = LB_MAX( accum.stepsDone, subPixel.size *
frame->getFrameData()->getContext().period );
}
applyBuffer();
applyViewport();
setupAssemblyState();
try
{
eq::Compositor::assembleFrames( frames, this, accum.buffer.get( ));
}
catch( const co::Exception& e )
{
LBWARN << e.what() << std::endl;
}
resetAssemblyState();
}
void QgsMapCanvas::setRenderFlag( bool theFlag )
{
mRenderFlag = theFlag;
if ( mRenderFlag )
{
refresh();
}
else
stopRendering();
}
void Channel::frameStart( const eq::uint128_t& frameID,
const uint32_t frameNumber )
{
if( stopRendering( ))
return;
for( size_t i = 0; i < eq::NUM_EYES; ++i )
_accum[ i ].stepsDone = 0;
eq::Channel::frameStart( frameID, frameNumber );
}
void Renderer::render()
{
if (!_camera || !_scene) {
return ;
}
stopRendering();
_image.fill(Qt::black);
_stopThread = false;
_isRendering = true;
_isPaused = false;
_raytracerThread = new std::thread(&Renderer::_computeImage, this);
}
////////////////////////////////////////////////////////
// startRendering
//
////////////////////////////////////////////////////////
void world_light :: startRendering()
{
#ifdef GEM_HAVE_GLU
if (m_thing) {
stopRendering();
}
m_thing = gluNewQuadric();
gluQuadricTexture(m_thing, GL_FALSE);
gluQuadricDrawStyle(m_thing, static_cast<GLenum>(GLU_FILL));
#endif
m_change = 1;
}
////////////////////////////////////////////////////////
// Destructor
//
////////////////////////////////////////////////////////
world_light :: ~world_light()
{
if(gem_amRendering) {
// this should be handled in ~GemBase
stopRendering();
}
if (m_light) {
GemMan::freeLight(m_light);
}
}
/////////////////////////////////////////////////////////
// Destructor
//
/////////////////////////////////////////////////////////
GemBase :: ~GemBase(void)
{
if (gem_amRendering) {
stopRendering();
gem_amRendering=false;
}
if (m_out1) {
outlet_free(m_out1);
}
pd_unbind(&this->x_obj->ob_pd, gensym("__gemBase"));
}
/////////////////////////////////////////////////////////
// startRendering
//
/////////////////////////////////////////////////////////
void pix_clearblock :: startRendering()
{
stopRendering();
if (m_cache && m_cache->m_magic!=GEMCACHE_MAGIC)
m_cache=NULL;
m_oldcache = m_cache;
if(m_oldcache)
m_cache = new GemCache(m_oldcache->m_parent);
}
void QgsMapCanvas::refreshMap()
{
Q_ASSERT( mRefreshScheduled );
QgsDebugMsg( "CANVAS refresh!" );
stopRendering(); // if any...
// from now on we can accept refresh requests again
mRefreshScheduled = false;
//build the expression context
QgsExpressionContext expressionContext;
expressionContext << QgsExpressionContextUtils::globalScope()
<< QgsExpressionContextUtils::projectScope()
<< QgsExpressionContextUtils::mapSettingsScope( mSettings )
<< new QgsExpressionContextScope( mExpressionContextScope );
mSettings.setExpressionContext( expressionContext );
// create the renderer job
Q_ASSERT( mJob == 0 );
mJobCancelled = false;
if ( mUseParallelRendering )
mJob = new QgsMapRendererParallelJob( mSettings );
else
mJob = new QgsMapRendererSequentialJob( mSettings );
connect( mJob, SIGNAL( finished() ), SLOT( rendererJobFinished() ) );
mJob->setCache( mCache );
QStringList layersForGeometryCache;
Q_FOREACH ( const QString& id, mSettings.layers() )
{
if ( QgsVectorLayer* vl = qobject_cast<QgsVectorLayer*>( QgsMapLayerRegistry::instance()->mapLayer( id ) ) )
{
if ( vl->isEditable() )
layersForGeometryCache << id;
}
}
mJob->setRequestedGeometryCacheForLayers( layersForGeometryCache );
mJob->start();
mMapUpdateTimer.start();
emit renderStarting();
}
bool Window3D::event(QEvent *event)
{
switch (event->type())
{
case QEvent::UpdateRequest:
m_updatePending = false;
render();
return true;
case QEvent::Close:
if (m_canRender)
{
stopRendering();
}
return QWindow::event(event);
default:
return QWindow::event(event);
}
}
void AudioContext::resolvePromisesForSuspendOnMainThread()
{
ASSERT(isMainThread());
AutoLocker locker(this);
// We can stop rendering now.
if (m_destinationNode)
stopRendering();
for (auto& resolver : m_suspendResolvers) {
if (m_contextState == Closed) {
resolver->reject(
DOMException::create(InvalidStateError, "Cannot suspend a context that has been closed"));
} else {
resolver->resolve();
}
}
m_suspendResolvers.clear();
}
