operation. First rasterize the surface, then draw the surface. Using
scene graph API directly is always significantly faster.
+\section1 Logging Support
+The scene graph has support for a number of logging categories. These
+can be useful in tracking down both performance issues and bugs in
+addition to being helpful to Qt contributors.
+
+\list
+
+\li \c {qt.scenegraph.time.texture} - logs the time spent doing texture uploads
+
+\li \c {qt.scenegraph.time.compilation} - logs the time spent doing shader compilation
+
+\li \c {qt.scenegraph.time.renderer} - logs the time spent in the various steps of the renderer
+
+\li \c {qt.scenegraph.time.renderloop} - logs the time spent in the various steps of the render loop
+
+\li \c {qt.scenegraph.time.glyph} - logs the time spent preparing distance field glyphs
+
+\li \c {qt.scenegraph.info} - logs general information about various parts of the scene graph and the graphics stack
+
+\li \c {qt.scenegraph.renderloop} - creates a detailed log of the various stages involved in rendering. This log mode is primarily useful for developers working on Qt.
+
+\endlist
\section1 Scene Graph Backend
const bool debug_noopaque = qgetenv("QSG_RENDERER_DEBUG").contains("noopaque");
const bool debug_noclip = qgetenv("QSG_RENDERER_DEBUG").contains("noclip");
-#ifndef QSG_NO_RENDER_TIMING
-static bool qsg_render_timing = !qgetenv("QSG_RENDER_TIMING").isEmpty();
static QElapsedTimer qsg_renderer_timer;
-#endif
#define QSGNODE_TRAVERSE(NODE) for (QSGNode *child = NODE->firstChild(); child; child = child->nextSibling())
#define SHADOWNODE_TRAVERSE(NODE) for (QList<Node *>::const_iterator child = NODE->children.constBegin(); child != NODE->children.constEnd(); ++child)
if (shader)
return shader;
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing || QQuickProfiler::enabled)
+ if (QSG_LOG_TIME_COMPILATION().isDebugEnabled() || QQuickProfiler::enabled)
qsg_renderer_timer.start();
-#endif
QSGMaterialShader *s = material->createShader();
QOpenGLContext *ctx = QOpenGLContext::currentContext();
Q_ASSERT(shader->pos_order >= 0);
Q_ASSERT(shader->id_zRange >= 0);
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing)
- qDebug(" - compiling material: %dms", (int) qsg_renderer_timer.elapsed());
+ qCDebug(QSG_LOG_TIME_COMPILATION, "shader compiled in %dms", (int) qsg_renderer_timer.elapsed());
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphContextFrame, (
qsg_renderer_timer.nsecsElapsed()));
-#endif
rewrittenShaders[type] = shader;
return shader;
if (shader)
return shader;
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing || QQuickProfiler::enabled)
+ if (QSG_LOG_TIME_COMPILATION().isDebugEnabled() || QQuickProfiler::enabled)
qsg_renderer_timer.start();
-#endif
QSGMaterialShader *s = static_cast<QSGMaterialShader *>(material->createShader());
context->compile(s, material);
stockShaders[type] = shader;
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing)
- qDebug(" - compiling material: %dms", (int) qsg_renderer_timer.elapsed());
+ qCDebug(QSG_LOG_TIME_COMPILATION, "shader compiled in %dms (no rewrite)", (int) qsg_renderer_timer.elapsed());
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphContextFrame, (
qsg_renderer_timer.nsecsElapsed()));
-#endif
-
return shader;
}
static bool qsg_sanity_check = qgetenv("QSG_SANITY_CHECK").toInt();
-#ifndef QSG_NO_RENDER_TIMING
-static bool qsg_render_timing = !qgetenv("QSG_RENDER_TIMING").isEmpty();
static QElapsedTimer frameTimer;
static qint64 preprocessTime;
static qint64 updatePassTime;
-#endif
void QSGBindable::clear(QSGRenderer::ClearMode mode) const
{
m_is_rendering = true;
-#ifndef QSG_NO_RENDER_TIMING
- bool profileFrames = qsg_render_timing || QQuickProfiler::enabled;
+ bool profileFrames = QSG_LOG_TIME_RENDERER().isDebugEnabled() || QQuickProfiler::enabled;
if (profileFrames)
frameTimer.start();
qint64 bindTime = 0;
qint64 renderTime = 0;
-#endif
m_bindable = &bindable;
preprocess();
bindable.bind();
-#ifndef QSG_NO_RENDER_TIMING
if (profileFrames)
bindTime = frameTimer.nsecsElapsed();
-#endif
// Sanity check that attribute registers are disabled
if (qsg_sanity_check) {
}
render();
-#ifndef QSG_NO_RENDER_TIMING
if (profileFrames)
renderTime = frameTimer.nsecsElapsed();
-#endif
glDisable(GL_SCISSOR_TEST);
m_is_rendering = false;
m_index_buffer_bound = false;
}
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing) {
- qDebug(" - Breakdown of render time: preprocess=%d, updates=%d, binding=%d, render=%d, total=%d",
- int(preprocessTime / 1000000),
- int((updatePassTime - preprocessTime) / 1000000),
- int((bindTime - updatePassTime) / 1000000),
- int((renderTime - bindTime) / 1000000),
- int(renderTime / 1000000));
- }
+ qCDebug(QSG_LOG_TIME_RENDERER,
+ "time in renderer: total=%dms, preprocess=%d, updates=%d, binding=%d, rendering=%d",
+ int(renderTime / 1000000),
+ int(preprocessTime / 1000000),
+ int((updatePassTime - preprocessTime) / 1000000),
+ int((bindTime - updatePassTime) / 1000000),
+ int((renderTime - bindTime) / 1000000));
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphRendererFrame, (
preprocessTime,
bindTime - updatePassTime,
renderTime - bindTime));
-#endif
}
void QSGRenderer::setProjectionMatrixToDeviceRect()
}
}
-#ifndef QSG_NO_RENDER_TIMING
- bool profileFrames = qsg_render_timing || QQuickProfiler::enabled;
+ bool profileFrames = QSG_LOG_TIME_RENDERER().isDebugEnabled()|| QQuickProfiler::enabled;
if (profileFrames)
preprocessTime = frameTimer.nsecsElapsed();
-#endif
nodeUpdater()->updateStates(m_root_node);
-#ifndef QSG_NO_RENDER_TIMING
if (profileFrames)
updatePassTime = frameTimer.nsecsElapsed();
-#endif
-
}
void QSGRenderer::addNodesToPreprocess(QSGNode *node)
#include <qmath.h>
#include <QtQuick/private/qsgdistancefieldutil_p.h>
#include <QtQuick/private/qsgdistancefieldglyphnode_p.h>
+#include <QtQuick/private/qsgcontext_p.h>
#include <private/qrawfont_p.h>
#include <QtGui/qguiapplication.h>
#include <qdir.h>
QT_BEGIN_NAMESPACE
-#ifndef QSG_NO_RENDER_TIMING
-static bool qsg_render_timing = !qgetenv("QSG_RENDER_TIMING").isEmpty();
static QElapsedTimer qsg_render_timer;
-#endif
QSGDistanceFieldGlyphCache::Texture QSGDistanceFieldGlyphCache::s_emptyTexture;
if (m_pendingGlyphs.isEmpty())
return;
-#ifndef QSG_NO_RENDER_TIMING
- bool profileFrames = qsg_render_timing || QQuickProfiler::enabled;
+ bool profileFrames = QSG_LOG_TIME_GLYPH().isDebugEnabled() || QQuickProfiler::enabled;
if (profileFrames)
qsg_render_timer.start();
-#endif
QList<QDistanceField> distanceFields;
for (int i = 0; i < m_pendingGlyphs.size(); ++i) {
m_doubleGlyphResolution));
}
-#ifndef QSG_NO_RENDER_TIMING
qint64 renderTime = 0;
int count = m_pendingGlyphs.size();
if (profileFrames)
renderTime = qsg_render_timer.nsecsElapsed();
-#endif
m_pendingGlyphs.reset();
storeGlyphs(distanceFields);
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing) {
- qDebug(" - glyphs: count=%d, render=%d, store=%d, total=%d",
- count,
- int(renderTime/1000000),
- (int) qsg_render_timer.elapsed() - int(renderTime/1000000),
- (int) qsg_render_timer.elapsed());
-
+ if (QSG_LOG_TIME_GLYPH().isDebugEnabled()) {
+ quint64 now = qsg_render_timer.elapsed();
+ qCDebug(QSG_LOG_TIME_GLYPH,
+ "distancefield: %d glyphs prepared in %dms, rendering=%d, upload=%d",
+ count,
+ (int) now,
+ int(renderTime / 1000000),
+ int((now - (renderTime / 1000000))));
}
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphAdaptationLayerFrame, (
count,
renderTime,
qsg_render_timer.nsecsElapsed() - renderTime));
-#endif
}
void QSGDistanceFieldGlyphCache::setGlyphsPosition(const QList<GlyphPosition> &glyphs)
#include <QtQuick/private/qsgdistancefieldglyphnode_p_p.h>
#include <QtQuick/private/qsgshareddistancefieldglyphcache_p.h>
#include <QtQuick/private/qsgatlastexture_p.h>
+#include <QtQuick/private/qsgrenderloop_p.h>
#include <QtQuick/private/qsgtexture_p.h>
#include <QtQuick/private/qquickpixmapcache_p.h>
QT_BEGIN_NAMESPACE
+// Used for very high-level info about the renderering and gl context
+// Includes GL_VERSION, type of render loop, atlas size, etc.
+Q_LOGGING_CATEGORY(QSG_LOG_INFO, "qt.scenegraph.info")
+
+// Used to debug the renderloop logic. Primarily useful for platform integrators
+// and when investigating the render loop logic.
+Q_LOGGING_CATEGORY(QSG_LOG_RENDERLOOP, "qt.scenegraph.renderloop")
+
+
+// GLSL shader compilation
+Q_LOGGING_CATEGORY(QSG_LOG_TIME_COMPILATION, "qt.scenegraph.time.compilation")
+
+// polish, animations, sync, render and swap in the render loop
+Q_LOGGING_CATEGORY(QSG_LOG_TIME_RENDERLOOP, "qt.scenegraph.time.renderloop")
+
+// Texture uploads and swizzling
+Q_LOGGING_CATEGORY(QSG_LOG_TIME_TEXTURE, "qt.scenegraph.time.texture")
+
+// Glyph preparation (only for distance fields atm)
+Q_LOGGING_CATEGORY(QSG_LOG_TIME_GLYPH, "qt.scenegraph.time.glyph")
+
+// Timing inside the renderer base class
+Q_LOGGING_CATEGORY(QSG_LOG_TIME_RENDERER, "qt.scenegraph.time.renderer")
+
class QSGContextPrivate : public QObjectPrivate
{
public:
d->distanceFieldAntialiasing = QSGGlyphNode::LowQualitySubPixelAntialiasing;
else if (mode == "gray")
d->distanceFieldAntialiasing = QSGGlyphNode::GrayAntialiasing;
+
+ // Adds compatibility with Qt 5.3 and earlier's QSG_RENDER_TIMING
+ if (qEnvironmentVariableIsSet("QSG_RENDER_TIMING")) {
+ ((QLoggingCategory &) QSG_LOG_TIME_GLYPH()).setEnabled(QtDebugMsg, true);
+ ((QLoggingCategory &) QSG_LOG_TIME_TEXTURE()).setEnabled(QtDebugMsg, true);
+ ((QLoggingCategory &) QSG_LOG_TIME_RENDERER()).setEnabled(QtDebugMsg, true);
+ ((QLoggingCategory &) QSG_LOG_TIME_RENDERLOOP()).setEnabled(QtDebugMsg, true);
+ ((QLoggingCategory &) QSG_LOG_TIME_COMPILATION()).setEnabled(QtDebugMsg, true);
+ }
}
}
static bool dumped = false;
- if (!dumped && qEnvironmentVariableIsSet("QSG_INFO")) {
+ if (!dumped && QSG_LOG_INFO().isDebugEnabled()) {
dumped = true;
QSurfaceFormat format = renderContext->openglContext()->format();
QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions();
- qDebug() << "R/G/B/A Buffers: " << format.redBufferSize() << format.greenBufferSize() << format.blueBufferSize() << format.alphaBufferSize();
- qDebug() << "Depth Buffer: " << format.depthBufferSize();
- qDebug() << "Stencil Buffer: " << format.stencilBufferSize();
- qDebug() << "Samples: " << format.samples();
- qDebug() << "GL_VENDOR: " << (const char *) funcs->glGetString(GL_VENDOR);
- qDebug() << "GL_RENDERER: " << (const char *) funcs->glGetString(GL_RENDERER);
- qDebug() << "GL_VERSION: " << (const char *) funcs->glGetString(GL_VERSION);
+ qCDebug(QSG_LOG_INFO) << "R/G/B/A Buffers: " << format.redBufferSize() << format.greenBufferSize() << format.blueBufferSize() << format.alphaBufferSize();
+ qCDebug(QSG_LOG_INFO) << "Depth Buffer: " << format.depthBufferSize();
+ qCDebug(QSG_LOG_INFO) << "Stencil Buffer: " << format.stencilBufferSize();
+ qCDebug(QSG_LOG_INFO) << "Samples: " << format.samples();
+ qCDebug(QSG_LOG_INFO) << "GL_VENDOR: " << (const char *) funcs->glGetString(GL_VENDOR);
+ qCDebug(QSG_LOG_INFO) << "GL_RENDERER: " << (const char *) funcs->glGetString(GL_RENDERER);
+ qCDebug(QSG_LOG_INFO) << "GL_VERSION: " << (const char *) funcs->glGetString(GL_VERSION);
QSet<QByteArray> exts = renderContext->openglContext()->extensions();
QByteArray all; foreach (const QByteArray &e, exts) all += ' ' + e;
- qDebug() << "GL_EXTENSIONS: " << all.constData();
+ qCDebug(QSG_LOG_INFO) << "GL_EXTENSIONS: " << all.constData();
}
d->mutex.unlock();
class QSGDistanceFieldGlyphCacheManager;
class QSGContext;
+Q_DECLARE_LOGGING_CATEGORY(QSG_LOG_TIME_RENDERLOOP)
+Q_DECLARE_LOGGING_CATEGORY(QSG_LOG_TIME_COMPILATION)
+Q_DECLARE_LOGGING_CATEGORY(QSG_LOG_TIME_TEXTURE)
+Q_DECLARE_LOGGING_CATEGORY(QSG_LOG_TIME_GLYPH)
+Q_DECLARE_LOGGING_CATEGORY(QSG_LOG_TIME_RENDERER)
+
+Q_DECLARE_LOGGING_CATEGORY(QSG_LOG_INFO)
+Q_DECLARE_LOGGING_CATEGORY(QSG_LOG_RENDERLOOP)
class Q_QUICK_PRIVATE_EXPORT QSGRenderContext : public QObject
{
QT_BEGIN_NAMESPACE
-DEFINE_BOOL_CONFIG_OPTION(qsg_render_timing, QSG_RENDER_TIMING)
extern Q_GUI_EXPORT QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include_alpha);
QSGRenderLoop *QSGRenderLoop::instance()
{
if (!s_instance) {
- s_instance = QSGContext::createWindowManager();
- bool info = qEnvironmentVariableIsSet("QSG_INFO");
+ // For compatibility with 5.3 and earlier's QSG_INFO environment variables
+ if (qEnvironmentVariableIsSet("QSG_INFO"))
+ ((QLoggingCategory &) QSG_LOG_INFO()).setEnabled(QtDebugMsg, true);
+
+ s_instance = QSGContext::createWindowManager();
if (useConsistentTiming()) {
QUnifiedTimer::instance(true)->setConsistentTiming(true);
- if (info)
- qDebug() << "QSG: using fixed animation steps";
+ qCDebug(QSG_LOG_INFO, "using fixed animation steps");
}
if (!s_instance) {
switch (loopType) {
case ThreadedRenderLoop:
- if (info) qDebug() << "QSG: threaded render loop";
+ qCDebug(QSG_LOG_INFO, "threaded render loop");
s_instance = new QSGThreadedRenderLoop();
break;
case WindowsRenderLoop:
- if (info) qDebug() << "QSG: windows render loop";
+ qCDebug(QSG_LOG_INFO, "windows render loop");
s_instance = new QSGWindowsRenderLoop();
break;
default:
- if (info) qDebug() << "QSG: basic render loop";
+ qCDebug(QSG_LOG_INFO, "QSG: basic render loop");
s_instance = new QSGGuiThreadRenderLoop();
break;
}
if (!m_windows.contains(window))
return;
}
- cd->polishItems();
-
- emit window->afterAnimating();
-
- qint64 renderTime = 0, syncTime = 0;
QElapsedTimer renderTimer;
- bool profileFrames = qsg_render_timing() || QQuickProfiler::enabled;
+ qint64 renderTime = 0, syncTime = 0, polishTime = 0;
+ bool profileFrames = QSG_LOG_TIME_RENDERLOOP().isDebugEnabled() || QQuickProfiler::enabled;
if (profileFrames)
renderTimer.start();
+ cd->polishItems();
+
+ if (profileFrames)
+ polishTime = renderTimer.nsecsElapsed();
+
+ emit window->afterAnimating();
+
cd->syncSceneGraph();
if (profileFrames)
cd->renderSceneGraph(window->size());
if (profileFrames)
- renderTime = renderTimer.nsecsElapsed() - syncTime;
+ renderTime = renderTimer.nsecsElapsed();
if (data.grabOnly) {
grabContent = qt_gl_read_framebuffer(window->size() * window->devicePixelRatio(), false, false);
}
qint64 swapTime = 0;
- if (profileFrames) {
- swapTime = renderTimer.nsecsElapsed() - renderTime - syncTime;
- }
+ if (profileFrames)
+ swapTime = renderTimer.nsecsElapsed() - renderTime;
- if (qsg_render_timing()) {
+ if (QSG_LOG_TIME_RENDERLOOP().isDebugEnabled()) {
static QTime lastFrameTime = QTime::currentTime();
- qDebug() << "- Breakdown of frame time; sync:" << syncTime/1000000
- << "ms render:" << renderTime/1000000 << "ms swap:" << swapTime/1000000
- << "ms total:" << (swapTime + renderTime + syncTime)/1000000
- << "ms time since last frame:" << (lastFrameTime.msecsTo(QTime::currentTime()))
- << "ms";
+ qCDebug(QSG_LOG_TIME_RENDERLOOP,
+ "Frame rendered with 'basic' renderloop in %dms, polish=%d, sync=%d, render=%d, swap=%d, frameDelta=%d",
+ int(swapTime / 1000000),
+ int(polishTime / 1000000),
+ int((syncTime - polishTime) / 1000000),
+ int((renderTime - syncTime) / 1000000),
+ int((swapTime - renderTime) / 10000000),
+ int(lastFrameTime.msecsTo(QTime::currentTime())));
lastFrameTime = QTime::currentTime();
}
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphRenderLoopFrame, (
syncTime,
- renderTime,
+ renderTime - syncTime,
swapTime));
// Might have been set during syncSceneGraph()
QT_BEGIN_NAMESPACE
-
-// #define QSG_RENDER_LOOP_DEBUG
-
-#if defined (QSG_RENDER_LOOP_DEBUG)
-QElapsedTimer qsgrl_timer;
-# define QSG_RT_DEBUG(MSG) qDebug("(%6d) line=%4d - win=%10p): Render: %s", (int) qsgrl_timer.elapsed(), __LINE__, window, MSG);
-# define QSG_GUI_DEBUG(WIN, MSG) qDebug("(%6d) line=%4d - win=%10p): Gui: %s", (int) qsgrl_timer.elapsed(), __LINE__, WIN, MSG);
-#else
-# define QSG_RT_DEBUG(MSG)
-# define QSG_GUI_DEBUG(WIN,MSG)
-#endif
-
+#define QSG_RT_PAD " (RT)"
static int get_env_int(const char *name, int defaultValue)
{
}
-#ifndef QSG_NO_RENDER_TIMING
-static bool qsg_render_timing = !qgetenv("QSG_RENDER_TIMING").isEmpty();
static QElapsedTimer threadTimer;
static qint64 syncTime;
static qint64 renderTime;
static qint64 sinceLastTime;
-#endif
extern Q_GUI_EXPORT QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include_alpha);
public slots:
void sceneGraphChanged() {
- QSG_RT_DEBUG("sceneGraphChanged()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "sceneGraphChanged";
syncResultedInChanges = true;
}
switch ((int) e->type()) {
case WM_Obscure: {
- QSG_RT_DEBUG("WM_Obscure");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "WM_Obscure";
Q_ASSERT(!window || window == static_cast<WMWindowEvent *>(e)->window);
mutex.lock();
if (window) {
QQuickWindowPrivate::get(window)->fireAboutToStop();
- QSG_RT_DEBUG(" - removed window...");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- window removed";
gl->doneCurrent();
window = 0;
}
return true; }
case WM_RequestSync: {
- QSG_RT_DEBUG("WM_RequestSync");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "WM_RequestSync";
WMSyncEvent *se = static_cast<WMSyncEvent *>(e);
if (sleeping)
stopEventProcessing = true;
pendingUpdate |= SyncRequest;
if (se->syncInExpose) {
- QSG_RT_DEBUG(" - triggered from expose");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- triggered from expose";
pendingUpdate |= ExposeRequest;
}
return true; }
case WM_TryRelease: {
- QSG_RT_DEBUG("WM_TryRelease");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "WM_TryRelease";
mutex.lock();
wm->m_lockedForSync = true;
WMTryReleaseEvent *wme = static_cast<WMTryReleaseEvent *>(e);
if (!window || wme->inDestructor) {
- QSG_RT_DEBUG(" - setting exit flag and invalidating GL");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- setting exit flag and invalidating OpenGL";
invalidateOpenGL(wme->window, wme->inDestructor, wme->fallbackSurface);
active = gl;
Q_ASSERT_X(!wme->inDestructor || !active, "QSGRenderThread::invalidateOpenGL()", "Thread's active state is not set to false when shutting down");
if (sleeping)
stopEventProcessing = true;
} else {
- QSG_RT_DEBUG(" - not releasing anything because we have active windows...");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- not releasing because window is still active";
}
waitCondition.wakeOne();
wm->m_lockedForSync = false;
}
case WM_Grab: {
- QSG_RT_DEBUG("WM_Grab");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "WM_Grab";
WMGrabEvent *ce = static_cast<WMGrabEvent *>(e);
Q_ASSERT(ce->window == window);
mutex.lock();
if (window) {
gl->makeCurrent(window);
- QSG_RT_DEBUG(" - syncing scene graph");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- sync scene graph";
QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
d->syncSceneGraph();
- QSG_RT_DEBUG(" - rendering scene graph");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- rendering scene graph";
QQuickWindowPrivate::get(window)->renderSceneGraph(windowSize);
- QSG_RT_DEBUG(" - grabbing result...");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- grabbing result";
*ce->image = qt_gl_read_framebuffer(windowSize * window->devicePixelRatio(), false, false);
}
- QSG_RT_DEBUG(" - waking gui to handle grab result");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- waking gui to handle result";
waitCondition.wakeOne();
mutex.unlock();
return true;
}
case WM_RequestRepaint:
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "WM_RequestPaint";
// When GUI posts this event, it is followed by a polishAndSync, so we mustn't
// exit the event loop yet.
pendingUpdate |= RepaintRequest;
void QSGRenderThread::invalidateOpenGL(QQuickWindow *window, bool inDestructor, QOffscreenSurface *fallback)
{
- QSG_RT_DEBUG("invalidateOpenGL()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "invalidateOpenGL()";
if (!gl)
return;
if (!window) {
- qWarning("QSGThreadedRenderLoop:QSGRenderThread: no window to make current...");
+ qCWarning(QSG_LOG_RENDERLOOP()) << "QSGThreadedRenderLoop:QSGRenderThread: no window to make current...";
return;
}
bool current = gl->makeCurrent(fallback ? static_cast<QSurface *>(fallback) : static_cast<QSurface *>(window));
if (Q_UNLIKELY(!current)) {
- QSG_RT_DEBUG(" - cleanup without an OpenGL context");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- cleanup without an OpenGL context";
}
// The canvas nodes must be cleaned up regardless if we are in the destructor..
QQuickWindowPrivate *dd = QQuickWindowPrivate::get(window);
dd->cleanupNodesOnShutdown();
} else {
- QSG_RT_DEBUG(" - persistent SG, avoiding cleanup");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- persistent SG, avoiding cleanup";
if (current)
gl->doneCurrent();
return;
QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
if (current)
gl->doneCurrent();
- QSG_RT_DEBUG(" - invalidated scenegraph..");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- invalidating scene graph";
if (wipeGL) {
delete gl;
gl = 0;
- QSG_RT_DEBUG(" - invalidated OpenGL");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- invalidated OpenGL";
} else {
- QSG_RT_DEBUG(" - persistent GL, avoiding cleanup");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- persistent GL, avoiding cleanup";
}
}
*/
void QSGRenderThread::sync(bool inExpose)
{
- QSG_RT_DEBUG("sync()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "sync()";
mutex.lock();
Q_ASSERT_X(wm->m_lockedForSync, "QSGRenderThread::sync()", "sync triggered on bad terms as gui is not already locked...");
d->renderer->clearChangedFlag();
d->syncSceneGraph();
if (!hadRenderer && d->renderer) {
- QSG_RT_DEBUG(" - renderer was created, hooking up changed signal");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- renderer was created";
syncResultedInChanges = true;
connect(d->renderer, SIGNAL(sceneGraphChanged()), this, SLOT(sceneGraphChanged()), Qt::DirectConnection);
}
// and the delete is a safe operation.
QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
} else {
- QSG_RT_DEBUG(" - window has bad size, waiting...");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- window has bad size, sync aborted";
}
if (!inExpose) {
- QSG_RT_DEBUG(" - sync complete, waking GUI");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- sync complete, waking Gui";
waitCondition.wakeOne();
mutex.unlock();
}
void QSGRenderThread::syncAndRender()
{
-#ifndef QSG_NO_RENDER_TIMING
- bool profileFrames = qsg_render_timing || QQuickProfiler::enabled;
+ bool profileFrames = QSG_LOG_TIME_RENDERLOOP().isDebugEnabled() || QQuickProfiler::enabled;
if (profileFrames) {
sinceLastTime = threadTimer.nsecsElapsed();
threadTimer.start();
}
-#endif
+
QElapsedTimer waitTimer;
waitTimer.start();
- QSG_RT_DEBUG("syncAndRender()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "syncAndRender()";
syncResultedInChanges = false;
pendingUpdate = 0;
if (pending & SyncRequest) {
- QSG_RT_DEBUG(" - update pending, doing sync");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- updatePending, doing sync";
sync(pending == ExposeRequest);
}
if (!syncResultedInChanges && ((pending & RepaintRequest) == 0)) {
- QSG_RT_DEBUG(" - no changes, rendering aborted");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- no changes, render aborted";
int waitTime = vsyncDelta - (int) waitTimer.elapsed();
if (waitTime > 0)
msleep(waitTime);
return;
}
-#ifndef QSG_NO_RENDER_TIMING
if (profileFrames)
syncTime = threadTimer.nsecsElapsed();
-#endif
- QSG_RT_DEBUG(" - rendering starting");
+
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- rendering started";
QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
current = gl->makeCurrent(window);
if (current) {
d->renderSceneGraph(windowSize);
-#ifndef QSG_NO_RENDER_TIMING
if (profileFrames)
renderTime = threadTimer.nsecsElapsed();
-#endif
gl->swapBuffers(window);
d->fireFrameSwapped();
} else {
- QSG_RT_DEBUG(" - Window not yet ready, skipping render...");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- window not ready, skipping render";
}
- QSG_RT_DEBUG(" - rendering done");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- rendering done";
// Though it would be more correct to put this block directly after
// fireFrameSwapped in the if (current) branch above, we don't do
// has started rendering with a bad window, causing makeCurrent to
// fail or if the window has a bad size.
if (pending == ExposeRequest) {
- QSG_RT_DEBUG(" - waking GUI after expose");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- wake Gui after initial expose";
waitCondition.wakeOne();
mutex.unlock();
}
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing)
- qDebug("Render Thread: window=%p, framedelta=%d, sync=%d, first render=%d, after final swap=%d",
- window,
- int(sinceLastTime/1000000),
- int(syncTime/1000000),
- int((renderTime - syncTime)/1000000),
- int(threadTimer.elapsed() - renderTime/1000000));
+ qCDebug(QSG_LOG_TIME_RENDERLOOP,
+ "Frame rendered with 'threaded' renderloop in %dms, sync=%d, render=%d, swap=%d - (on render thread)",
+ int(threadTimer.elapsed()),
+ int((syncTime/1000000)),
+ int((renderTime - syncTime) / 1000000),
+ int(threadTimer.elapsed() - renderTime / 1000000));
+
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphRenderLoopFrame, (
syncTime,
renderTime - syncTime,
threadTimer.nsecsElapsed() - renderTime));
-#endif
}
void QSGRenderThread::processEvents()
{
- QSG_RT_DEBUG("processEvents()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "--- begin processEvents()";
while (eventQueue.hasMoreEvents()) {
QEvent *e = eventQueue.takeEvent(false);
event(e);
delete e;
}
- QSG_RT_DEBUG(" - done with processEvents()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "--- done processEvents()";
}
void QSGRenderThread::processEventsAndWaitForMore()
{
- QSG_RT_DEBUG("processEventsAndWaitForMore()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "--- begin processEventsAndWaitForMore()";
stopEventProcessing = false;
while (!stopEventProcessing) {
QEvent *e = eventQueue.takeEvent(true);
event(e);
delete e;
}
- QSG_RT_DEBUG(" - done with processEventsAndWaitForMore()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "--- done processEventsAndWaitForMore()";
}
void QSGRenderThread::run()
{
- QSG_RT_DEBUG("run()");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "run()";
animatorDriver = sgrc->sceneGraphContext()->createAnimationDriver(0);
animatorDriver->install();
QUnifiedTimer::instance(true)->setConsistentTiming(QSGRenderLoop::useConsistentTiming());
QCoreApplication::processEvents();
if (active && (pendingUpdate == 0 || !window)) {
- QSG_RT_DEBUG("enter event loop (going to sleep)");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "done drawing, sleep...";
sleeping = true;
processEventsAndWaitForMore();
sleeping = false;
Q_ASSERT_X(!gl, "QSGRenderThread::run()", "The OpenGL context should be cleaned up before exiting the render thread...");
- QSG_RT_DEBUG("run() completed...");
+ qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "run() completed";
delete animatorDriver;
animatorDriver = 0;
connect(m_animation_driver, SIGNAL(stopped()), this, SLOT(animationStopped()));
m_animation_driver->install();
- QSG_GUI_DEBUG((void *) 0, "QSGThreadedRenderLoop() created");
}
QSGRenderContext *QSGThreadedRenderLoop::createRenderContext(QSGContext *sg) const
void QSGThreadedRenderLoop::maybePostPolishRequest(Window *w)
{
if (w->timerId == 0) {
- QSG_GUI_DEBUG(w->window, " - posting update");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- posting update";
w->timerId = startTimer(m_exhaust_delay, Qt::PreciseTimer);
}
}
void QSGThreadedRenderLoop::animationStarted()
{
- QSG_GUI_DEBUG((void *) 0, "animationStarted()");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- animationStarted()";
startOrStopAnimationTimer();
for (int i=0; i<m_windows.size(); ++i)
void QSGThreadedRenderLoop::animationStopped()
{
- QSG_GUI_DEBUG((void *) 0, "animationStopped()");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- animationStopped()";
startOrStopAnimationTimer();
}
void QSGThreadedRenderLoop::hide(QQuickWindow *window)
{
- QSG_GUI_DEBUG(window, "hide()");
+ qCDebug(QSG_LOG_RENDERLOOP) << "hide()" << window;
if (window->isExposed())
handleObscurity(windowFor(m_windows, window));
*/
void QSGThreadedRenderLoop::windowDestroyed(QQuickWindow *window)
{
- QSG_GUI_DEBUG(window, "windowDestroyed()");
+ qCDebug(QSG_LOG_RENDERLOOP) << "begin windowDestroyed()" << window;
Window *w = windowFor(m_windows, window);
if (!w)
}
}
- QSG_GUI_DEBUG(window, " - done with windowDestroyed()");
+ qCDebug(QSG_LOG_RENDERLOOP) << "done windowDestroyed()" << window;
}
void QSGThreadedRenderLoop::exposureChanged(QQuickWindow *window)
{
- QSG_GUI_DEBUG(window, "exposureChanged()");
+ qCDebug(QSG_LOG_RENDERLOOP) << "exposureChanged()" << window;
if (window->isExposed()) {
handleExposure(window);
} else {
*/
void QSGThreadedRenderLoop::handleExposure(QQuickWindow *window)
{
- QSG_GUI_DEBUG(window, "handleExposure");
+ qCDebug(QSG_LOG_RENDERLOOP) << "handleExposure()" << window;
Window *w = windowFor(m_windows, window);
if (!w) {
- QSG_GUI_DEBUG(window, " - adding window to list");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- adding window to list";
Window win;
win.window = window;
win.actualWindowFormat = window->format();
// Start render thread if it is not running
if (!w->thread->isRunning()) {
- QSG_GUI_DEBUG(w->window, " - starting render thread...");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- starting render thread";
if (!w->thread->gl) {
w->thread->gl = new QOpenGLContext();
QQuickWindowPrivate::get(w->window)->fireOpenGLContextCreated(w->thread->gl);
w->thread->gl->moveToThread(w->thread);
- QSG_GUI_DEBUG(w->window, " - OpenGL context created...");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- OpenGL context created";
}
QQuickAnimatorController *controller = QQuickWindowPrivate::get(w->window)->animationController;
w->thread->start();
} else {
- QSG_GUI_DEBUG(w->window, " - render thread already running");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- render thread already running";
}
polishAndSync(w, true);
- QSG_GUI_DEBUG(w->window, " - handleExposure completed...");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- done with handleExposure()";
startOrStopAnimationTimer();
}
*/
void QSGThreadedRenderLoop::handleObscurity(Window *w)
{
- QSG_GUI_DEBUG(w->window, "handleObscurity");
+ qCDebug(QSG_LOG_RENDERLOOP) << "handleObscurity()" << w->window;
if (w->thread->isRunning()) {
w->thread->mutex.lock();
w->thread->postEvent(new WMWindowEvent(w->window, WM_Obscure));
return;
}
- QSG_GUI_DEBUG(w->window, "maybeUpdate...");
if (!w || !w->thread->isRunning()) {
return;
}
+ qCDebug(QSG_LOG_RENDERLOOP) << "update from item" << w->window;
// Call this function from the Gui thread later as startTimer cannot be
// called from the render thread.
if (QThread::currentThread() == w->thread) {
- QSG_GUI_DEBUG(w->window, " - on render thread, will update later..");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- on render thread";
w->updateDuringSync = true;
return;
}
return;
if (w->thread == QThread::currentThread()) {
- QSG_RT_DEBUG("QQuickWindow::update called on render thread");
+ qCDebug(QSG_LOG_RENDERLOOP) << "update on window - on render thread" << w->window;
w->thread->requestRepaint();
return;
}
- QSG_GUI_DEBUG(w->window, "update called");
+ qCDebug(QSG_LOG_RENDERLOOP) << "update on window" << w->window;
w->thread->postEvent(new QEvent(WM_RequestRepaint));
maybeUpdate(w);
}
*/
void QSGThreadedRenderLoop::releaseResources(Window *w, bool inDestructor)
{
- QSG_GUI_DEBUG(w->window, "releaseResources requested...");
+ qCDebug(QSG_LOG_RENDERLOOP) << "releaseResources()" << (inDestructor ? "in destructor" : "in api-call") << w->window;
w->thread->mutex.lock();
if (w->thread->isRunning() && w->thread->active) {
// create it here and pass it on to QSGRenderThread::invalidateGL()
QOffscreenSurface *fallback = 0;
if (!window->handle()) {
- QSG_GUI_DEBUG(window, " - using fallback surface");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- using fallback surface";
fallback = new QOffscreenSurface();
fallback->setFormat(w->actualWindowFormat);
fallback->create();
}
- QSG_GUI_DEBUG(window, " - posting release request to render thread");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- posting release request to render thread";
w->thread->postEvent(new WMTryReleaseEvent(window, inDestructor, fallback));
w->thread->waitCondition.wait(&w->thread->mutex);
delete fallback;
*/
void QSGThreadedRenderLoop::polishAndSync(Window *w, bool inExpose)
{
- QSG_GUI_DEBUG(w->window, "polishAndSync()");
+ qCDebug(QSG_LOG_RENDERLOOP) << "polishAndSync" << (inExpose ? "(in expose)" : "(normal)") << w->window;
QQuickWindow *window = w->window;
if (!w->thread || !w->thread->window) {
- QSG_GUI_DEBUG(w->window, " - not exposed, aborting...");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- not exposed, abort";
killTimer(w->timerId);
w->timerId = 0;
return;
w = windowFor(m_windows, window);
}
if (!w || !w->thread || !w->thread->window) {
- QSG_GUI_DEBUG(w->window, " - removed after event flushing..");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- removed after event flushing, abort";
killTimer(w->timerId);
w->timerId = 0;
return;
}
-#ifndef QSG_NO_RENDER_TIMING
QElapsedTimer timer;
qint64 polishTime = 0;
qint64 waitTime = 0;
qint64 syncTime = 0;
- bool profileFrames = qsg_render_timing || QQuickProfiler::enabled;
+ bool profileFrames = QSG_LOG_TIME_RENDERLOOP().isDebugEnabled() || QQuickProfiler::enabled;
if (profileFrames)
timer.start();
-#endif
QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
d->polishItems();
-#ifndef QSG_NO_RENDER_TIMING
if (profileFrames)
polishTime = timer.nsecsElapsed();
-#endif
w->updateDuringSync = false;
emit window->afterAnimating();
- QSG_GUI_DEBUG(window, " - lock for sync...");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- lock for sync";
w->thread->mutex.lock();
m_lockedForSync = true;
w->thread->postEvent(new WMSyncEvent(window, inExpose));
- QSG_GUI_DEBUG(window, " - wait for sync...");
-#ifndef QSG_NO_RENDER_TIMING
+ qCDebug(QSG_LOG_RENDERLOOP) << "- wait for sync";
if (profileFrames)
waitTime = timer.nsecsElapsed();
-#endif
w->thread->waitCondition.wait(&w->thread->mutex);
m_lockedForSync = false;
w->thread->mutex.unlock();
- QSG_GUI_DEBUG(window, " - unlocked after sync...");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- unlock after sync";
-#ifndef QSG_NO_RENDER_TIMING
if (profileFrames)
syncTime = timer.nsecsElapsed();
-#endif
killTimer(w->timerId);
w->timerId = 0;
if (m_animation_timer == 0 && m_animation_driver->isRunning()) {
- QSG_GUI_DEBUG(window, " - animations advancing");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- advancing animations";
m_animation_driver->advance();
- QSG_GUI_DEBUG(window, " - animations done");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- animations done..";
// We need to trigger another sync to keep animations running...
maybePostPolishRequest(w);
emit timeToIncubate();
maybePostPolishRequest(w);
}
-
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing)
- qDebug(" - Gui Thread: window=%p, polish=%d, lock=%d, block/sync=%d -- animations=%d",
- window,
- int(polishTime/1000000),
- int((waitTime - polishTime)/1000000),
- int((syncTime - waitTime)/1000000),
- int((timer.nsecsElapsed() - syncTime)/1000000));
+ qCDebug(QSG_LOG_TIME_RENDERLOOP()).nospace()
+ << "Frame prepared with 'threaded' renderloop"
+ << ", polish=" << (polishTime / 1000000)
+ << ", lock=" << (waitTime - polishTime) / 1000000
+ << ", blockedForSync=" << (syncTime - waitTime) / 1000000
+ << ", animations=" << (timer.nsecsElapsed() - syncTime) / 1000000
+ << " - (on Gui thread) " << window;
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphPolishAndSync, (
polishTime,
waitTime - polishTime,
syncTime - waitTime,
timer.nsecsElapsed() - syncTime));
-#endif
}
QSGThreadedRenderLoop::Window *QSGThreadedRenderLoop::windowForTimer(int timerId) const
case QEvent::Timer: {
QTimerEvent *te = static_cast<QTimerEvent *>(e);
if (te->timerId() == m_animation_timer) {
- QSG_GUI_DEBUG((void *) 0, "QEvent::Timer -> non-visual animation");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- ticking non-visual timer";
m_animation_driver->advance();
emit timeToIncubate();
} else {
- QSG_GUI_DEBUG((void *) 0, "QEvent::Timer -> Polish & Sync");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- polish and sync timer";
Window *w = windowForTimer(te->timerId());
if (w)
polishAndSync(w);
QImage QSGThreadedRenderLoop::grab(QQuickWindow *window)
{
- QSG_GUI_DEBUG(window, "grab");
+ qCDebug(QSG_LOG_RENDERLOOP) << "grab()" << window;
Window *w = windowFor(m_windows, window);
Q_ASSERT(w);
if (!window->handle())
window->create();
- QSG_GUI_DEBUG(w->window, " - polishing items...");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- polishing items";
QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
d->polishItems();
QImage result;
w->thread->mutex.lock();
- QSG_GUI_DEBUG(w->window, " - locking, posting grab event");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- posting grab event";
w->thread->postEvent(new WMGrabEvent(window, &result));
w->thread->waitCondition.wait(&w->thread->mutex);
- QSG_GUI_DEBUG(w->window, " - locking, grab done, unlocking");
w->thread->mutex.unlock();
- QSG_GUI_DEBUG(w->window, " - grab complete");
+ qCDebug(QSG_LOG_RENDERLOOP) << "- grab complete";
return result;
}
extern Q_GUI_EXPORT QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include_alpha);
-// #define QSG_RENDER_LOOP_DEBUG
+#define RLDEBUG(x) qCDebug(QSG_LOG_RENDERLOOP) << x;
-#ifdef QSG_RENDER_LOOP_DEBUG
-static QElapsedTimer qsg_debug_timer;
-# define RLDEBUG(x) qDebug("(%6d) %s : %4d - %s", (int) qsg_debug_timer.elapsed(), __FILE__, __LINE__, x)
-#else
-# define RLDEBUG(x)
-#endif
-
-#ifndef QSG_NO_RENDER_TIMING
-static bool qsg_render_timing = !qgetenv("QSG_RENDER_TIMING").isEmpty();
static QElapsedTimer qsg_render_timer;
-#define QSG_RENDER_TIMING_SAMPLE(sampleName) qint64 sampleName = 0; if (qsg_render_timing || QQuickProfiler::enabled) sampleName = qsg_render_timer.nsecsElapsed()
-#else
-#define QSG_RENDER_TIMING_SAMPLE(sampleName)
-#endif
+#define QSG_RENDER_TIMING_SAMPLE(sampleName) \
+ qint64 sampleName = 0; \
+ if (QSG_LOG_TIME_RENDERLOOP().isDebugEnabled() || QQuickProfiler::enabled) \
+ sampleName = qsg_render_timer.nsecsElapsed()
QSGWindowsRenderLoop::QSGWindowsRenderLoop()
, m_updateTimer(0)
, m_animationTimer(0)
{
-#ifdef QSG_RENDER_LOOP_DEBUG
- qsg_debug_timer.start();
-#endif
-
m_rc = m_sg->createRenderContext();
m_animationDriver = m_sg->createAnimationDriver(m_sg);
RLDEBUG("Windows Render Loop created");
-#ifndef QSG_NO_RENDER_TIMIMG
qsg_render_timer.start();
-#endif
}
QSGWindowsRenderLoop::~QSGWindowsRenderLoop()
// 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());
QQuickWindowPrivate::get(window)->fireOpenGLContextCreated(m_gl);
- 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));
- }
- Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphWindowsRenderShow, (
- time_created - time_start,
- time_current - time_created,
- qsg_render_timer.nsecsElapsed() - time_current));
-#endif
-
}
WindowData data;
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));
- }
+ qCDebug(QSG_LOG_TIME_RENDERLOOP,
+ "animations ticked in %dms",
+ int((qsg_render_timer.nsecsElapsed() - time_start)/1000000));
+
Q_QUICK_SG_PROFILE1(QQuickProfiler::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,
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));
- }
+ qCDebug(QSG_LOG_TIME_RENDERLOOP()).nospace()
+ << "Frame rendered with 'windows' renderloop in: " << time_swapped << "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_PROFILE2(QQuickProfiler::SceneGraphWindowsPolishFrame,
QQuickProfiler::SceneGraphRenderLoopFrame, (
time_rendered - time_synced,
time_swapped - time_rendered,
time_polished - time_start));
-#endif
}
QT_END_NAMESPACE
#endif
-#ifndef QSG_NO_RENDER_TIMING
-static bool qsg_render_timing = !qgetenv("QSG_RENDER_TIMING").isEmpty();
static QElapsedTimer qsg_renderer_timer;
-#endif
namespace QSGAtlasTexture
{
m_atlas_size_limit = qsg_envInt("QSG_ATLAS_SIZE_LIMIT", qMax(w, h) / 2);
m_atlas_size = QSize(w, h);
- if (qEnvironmentVariableIsSet("QSG_INFO"))
- qDebug() << "QSG: texture atlas dimensions:" << w << "x" << h;
+ qCDebug(QSG_LOG_INFO, "texture atlas dimensions: %dx%d", w, h);
}
// Upload all pending images..
for (int i=0; i<m_pending_uploads.size(); ++i) {
-#ifndef QSG_NO_RENDER_TIMING
- bool profileFrames = qsg_render_timing || QQuickProfiler::enabled;
+ bool profileFrames = QSG_LOG_TIME_TEXTURE().isDebugEnabled() || QQuickProfiler::enabled;
if (profileFrames)
qsg_renderer_timer.start();
-#endif
if (m_externalFormat == GL_BGRA &&
!m_use_bgra_fallback) {
upload(m_pending_uploads.at(i));
}
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing) {
- qDebug(" - AtlasTexture(%dx%d), uploaded in %d ms",
- m_pending_uploads.at(i)->image().width(),
- m_pending_uploads.at(i)->image().height(),
- (int) (qsg_renderer_timer.elapsed()));
- }
+ qCDebug(QSG_LOG_TIME_TEXTURE).nospace() << "atlastexture uploaded in: " << qsg_renderer_timer.elapsed()
+ << "ms (" << m_pending_uploads.at(i)->image().width() << "x"
+ << m_pending_uploads.at(i)->image().height() << ")";
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphTexturePrepare, (
0, // bind (not relevant)
0, // swizzle (not relevant)
qsg_renderer_timer.nsecsElapsed(), // (upload all of the above)
0)); // mipmap (not used ever...)
-#endif
}
GLenum f = filtering == QSGTexture::Nearest ? GL_NEAREST : GL_LINEAR;
#include <QHash>
#endif
+static QElapsedTimer qsg_renderer_timer;
+
#ifndef QT_NO_DEBUG
static bool qsg_leak_check = !qgetenv("QML_LEAK_CHECK").isEmpty();
#endif
-#ifndef QSG_NO_RENDER_TIMING
-static bool qsg_render_timing = !qgetenv("QSG_RENDER_TIMING").isEmpty();
-static QElapsedTimer qsg_renderer_timer;
-#endif
#ifndef GL_BGRA
#define GL_BGRA 0x80E1
m_dirty_texture = false;
-#ifndef QSG_NO_RENDER_TIMING
- bool profileFrames = qsg_render_timing || QQuickProfiler::enabled;
+ bool profileFrames = QSG_LOG_TIME_TEXTURE().isDebugEnabled() || QQuickProfiler::enabled;
if (profileFrames)
qsg_renderer_timer.start();
-#endif
if (m_image.isNull()) {
if (m_texture_id && m_owns_texture) {
funcs->glDeleteTextures(1, &m_texture_id);
-#ifndef QSG_NO_RENDER_TIMING
- if (qsg_render_timing) {
- qDebug(" - texture deleted in %dms (size: %dx%d)",
- (int) qsg_renderer_timer.elapsed(),
- m_texture_size.width(),
- m_texture_size.height());
- }
+ qCDebug(QSG_LOG_TIME_TEXTURE, "plain texture deleted in %dms - %dx%d",
+ (int) qsg_renderer_timer.elapsed(),
+ m_texture_size.width(),
+ m_texture_size.height());
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphTextureDeletion, (
qsg_renderer_timer.nsecsElapsed()));
-#endif
}
m_texture_id = 0;
m_texture_size = QSize();
funcs->glGenTextures(1, &m_texture_id);
funcs->glBindTexture(GL_TEXTURE_2D, m_texture_id);
-#ifndef QSG_NO_RENDER_TIMING
qint64 bindTime = 0;
if (profileFrames)
bindTime = qsg_renderer_timer.nsecsElapsed();
-#endif
// ### TODO: check for out-of-memory situations...
int w = m_image.width();
if (tmp.width() * 4 != tmp.bytesPerLine())
tmp = tmp.copy();
-#ifndef QSG_NO_RENDER_TIMING
qint64 convertTime = 0;
if (profileFrames)
convertTime = qsg_renderer_timer.nsecsElapsed();
-#endif
updateBindOptions(m_dirty_bind_options);
qsg_swizzleBGRAToRGBA(&tmp);
}
-#ifndef QSG_NO_RENDER_TIMING
qint64 swizzleTime = 0;
if (profileFrames)
swizzleTime = qsg_renderer_timer.nsecsElapsed();
-#endif
+
funcs->glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, w, h, 0, externalFormat, GL_UNSIGNED_BYTE, tmp.constBits());
-#ifndef QSG_NO_RENDER_TIMING
qint64 uploadTime = 0;
if (profileFrames)
uploadTime = qsg_renderer_timer.nsecsElapsed();
-#endif
-
if (mipmapFiltering() != QSGTexture::None) {
funcs->glGenerateMipmap(GL_TEXTURE_2D);
m_mipmaps_generated = true;
}
-#ifndef QSG_NO_RENDER_TIMING
qint64 mipmapTime = 0;
- if (qsg_render_timing) {
+ if (profileFrames) {
mipmapTime = qsg_renderer_timer.nsecsElapsed();
-
- qDebug(" - plaintexture(%dx%d) bind=%d, convert=%d, swizzle=%d (%s->%s), upload=%d, mipmap=%d, total=%d",
- m_texture_size.width(), m_texture_size.height(),
- int(bindTime/1000000),
- int((convertTime - bindTime)/1000000),
- int((swizzleTime - convertTime)/1000000),
- externalFormat == GL_BGRA ? "BGRA" : "RGBA",
- internalFormat == GL_BGRA ? "BGRA" : "RGBA",
- int((uploadTime - swizzleTime)/1000000),
- int((mipmapTime - uploadTime)/1000000),
- (int) qsg_renderer_timer.elapsed());
-
+ qCDebug(QSG_LOG_TIME_TEXTURE,
+ "plain texture uploaded in: %dms (%dx%d), bind=%d, convert=%d, swizzle=%d (%s->%s), upload=%d, mipmap=%d",
+ int(mipmapTime / 1000000),
+ m_texture_size.width(), m_texture_size.height(),
+ int(bindTime / 1000000),
+ int((convertTime - bindTime)/1000000),
+ int((swizzleTime - convertTime)/1000000),
+ (externalFormat == GL_BGRA ? "BGRA" : "RGBA"),
+ (internalFormat == GL_BGRA ? "BGRA" : "RGBA"),
+ int((uploadTime - swizzleTime)/1000000),
+ int((mipmapTime - uploadTime)/1000000));
}
Q_QUICK_SG_PROFILE1(QQuickProfiler::SceneGraphTexturePrepare, (
uploadTime - swizzleTime,
qsg_renderer_timer.nsecsElapsed() - uploadTime));
-#endif
-
-
m_texture_size = QSize(w, h);
m_texture_rect = QRectF(0, 0, 1, 1);
projects / platform / upstream / qtdeclarative.git / commitdiff