void QSGWindowsRenderLoop::show(QQuickWindow *window)
{
RLDEBUG("show");
if (windowData(window) != 0)
return;
// This happens before the platform window is shown, but after
// it is created. Creating the GL context takes a lot of time
// (hundreds of milliseconds) and will prevent us from rendering
// the first frame in time for the initial show on screen.
// By preparing the GL context here, it is feasible (if the app
// is quick enough) to have a perfect first frame.
if (!m_gl) {
QSG_RENDER_TIMING_SAMPLE(time_start);
RLDEBUG(" - creating GL context");
m_gl = new QOpenGLContext();
m_gl->setFormat(window->requestedFormat());
if (QSGContext::sharedOpenGLContext())
m_gl->setShareContext(QSGContext::sharedOpenGLContext());
bool created = m_gl->create();
if (!created) {
qWarning("QtQuick: failed to create OpenGL context");
delete m_gl;
m_gl = 0;
return;
}
QSG_RENDER_TIMING_SAMPLE(time_created);
RLDEBUG(" - making current");
bool current = m_gl->makeCurrent(window);
RLDEBUG(" - initializing SG");
QSG_RENDER_TIMING_SAMPLE(time_current);
if (current)
m_rc->initialize(m_gl);
#ifndef QSG_NO_RENDER_TIMING
if (qsg_render_timing) {
qDebug("WindowsRenderLoop: GL=%d ms, makeCurrent=%d ms, SG=%d ms",
int((time_created - time_start)/1000000),
int((time_current - time_created)/1000000),
int((qsg_render_timer.nsecsElapsed() - time_current)/1000000));
}
if (QQmlProfilerService::enabled) {
QQmlProfilerService::sceneGraphFrame(
QQmlProfilerService::SceneGraphWindowsRenderShow,
time_created - time_start,
time_current - time_created,
qsg_render_timer.nsecsElapsed() - time_current);
}
#endif
}
WindowData data;
data.window = window;
data.pendingUpdate = false;
m_windows << data;
RLDEBUG(" - done with show");
}
/*
* Render the contents of this window. First polish, then sync, render
* then finally swap.
*
* Note: This render function does not implement aborting
* the render call when sync step results in no scene graph changes,
* like the threaded renderer does.
*/
void QSGWindowsRenderLoop::renderWindow(QQuickWindow *window)
{
RLDEBUG("renderWindow");
QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
if (!d->isRenderable())
return;
if (!m_gl->makeCurrent(window))
return;
QSG_RENDER_TIMING_SAMPLE(time_start);
RLDEBUG(" - polishing");
d->polishItems();
QSG_RENDER_TIMING_SAMPLE(time_polished);
RLDEBUG(" - syncing");
d->syncSceneGraph();
QSG_RENDER_TIMING_SAMPLE(time_synced);
RLDEBUG(" - rendering");
d->renderSceneGraph(window->size());
QSG_RENDER_TIMING_SAMPLE(time_rendered);
RLDEBUG(" - swapping");
m_gl->swapBuffers(window);
QSG_RENDER_TIMING_SAMPLE(time_swapped);
RLDEBUG(" - frameDone");
d->fireFrameSwapped();
#ifndef QSG_NO_RENDER_TIMING
if (qsg_render_timing) {
qDebug("WindowsRenderLoop(t=%d): window=%p, polish=%d ms, sync=%d ms, render=%d ms, swap=%d ms",
int(qsg_render_timer.elapsed()),
window,
int((time_polished - time_start)/1000000),
int((time_synced - time_polished)/1000000),
int((time_rendered - time_synced)/1000000),
int((time_swapped - time_rendered)/1000000));
}
if (QQmlProfilerService::enabled) {
QQmlProfilerService::sceneGraphFrame(
QQmlProfilerService::SceneGraphWindowsPolishFrame,
time_polished - time_start
);
QQmlProfilerService::sceneGraphFrame(
QQmlProfilerService::SceneGraphRenderLoopFrame,
time_synced - time_polished,
time_rendered - time_synced,
time_swapped - time_rendered
);
}
#endif
}
/*
* Go through all windows we control and render them in turn.
* Then tick animations if active.
*/
void QSGWindowsRenderLoop::render()
{
RLDEBUG("render");
foreach (const WindowData &wd, m_windows) {
if (wd.pendingUpdate) {
const_cast<WindowData &>(wd).pendingUpdate = false;
renderWindow(wd.window);
}
}
if (m_animationDriver->isRunning()) {
RLDEBUG("advancing animations");
QSG_RENDER_TIMING_SAMPLE(time_start);
m_animationDriver->advance();
RLDEBUG("animations advanced");
#ifndef QSG_NO_RENDER_TIMING
if (qsg_render_timing) {
qDebug("WindowsRenderLoop: animations=%d ms",
int((qsg_render_timer.nsecsElapsed() - time_start)/1000000));
}
if (QQmlProfilerService::Enabled) {
QQmlProfilerService::sceneGraphFrame(
QQmlProfilerService::SceneGraphWindowsAnimations,
qsg_render_timer.nsecsElapsed() - time_start);
}
#endif
// It is not given that animations triggered another maybeUpdate()
// and thus another render pass, so to keep things running,
// make sure there is another frame pending.
maybePostUpdateTimer();
emit timeToIncubate();
}
}
/*
* Render the contents of this window. First polish, then sync, render
* then finally swap.
*
* Note: This render function does not implement aborting
* the render call when sync step results in no scene graph changes,
* like the threaded renderer does.
*/
void QSGWindowsRenderLoop::renderWindow(QQuickWindow *window)
{
RLDEBUG("renderWindow");
QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
if (!d->isRenderable())
return;
if (!m_gl->makeCurrent(window)) {
// Check for context loss.
if (!m_gl->isValid()) {
d->cleanupNodesOnShutdown();
m_rc->invalidate();
if (m_gl->create() && m_gl->makeCurrent(window))
m_rc->initialize(m_gl);
else
return;
}
}
d->flushDelayedTouchEvent();
// Event delivery or processing has caused the window to stop rendering.
if (!windowData(window))
return;
QSG_LOG_TIME_SAMPLE(time_start);
Q_QUICK_SG_PROFILE_START(QQuickProfiler::SceneGraphPolishFrame);
RLDEBUG(" - polishing");
d->polishItems();
QSG_LOG_TIME_SAMPLE(time_polished);
Q_QUICK_SG_PROFILE_SWITCH(QQuickProfiler::SceneGraphPolishFrame,
QQuickProfiler::SceneGraphRenderLoopFrame);
emit window->afterAnimating();
RLDEBUG(" - syncing");
d->syncSceneGraph();
QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_synced);
RLDEBUG(" - rendering");
d->renderSceneGraph(window->size());
QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_rendered);
RLDEBUG(" - swapping");
if (!d->customRenderStage || !d->customRenderStage->swap())
m_gl->swapBuffers(window);
QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_swapped);
RLDEBUG(" - frameDone");
d->fireFrameSwapped();
qCDebug(QSG_LOG_TIME_RENDERLOOP()).nospace()
<< "Frame rendered with 'windows' renderloop in: " << (time_swapped - time_start) / 1000000 << "ms"
<< ", polish=" << (time_polished - time_start) / 1000000
<< ", sync=" << (time_synced - time_polished) / 1000000
<< ", render=" << (time_rendered - time_synced) / 1000000
<< ", swap=" << (time_swapped - time_rendered) / 1000000
<< " - " << window;
Q_QUICK_SG_PROFILE_REPORT(QQuickProfiler::SceneGraphRenderLoopFrame);
}