The same old issue surfaces in the windows render loop too.
The basic render loop is already fixed, apply a similar patch
to the windows one too.

Task-number: QTBUG-42213
Change-Id: I07068315f5164014e329b8ce061947c97ae9da61
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com>
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

Having a retina and non-retina screen connected resulted in getting
no output from QQuickRenderControl and QQuickWidget on the
non-retina screen.

This is caused by the fact that Quick is blindly calling
QWindow::devicePixelRatio(). This approach is wrong when using
QQuickRenderControl since the QQuickWindow does not have an actual
native window and so devicePixelRatio() merely returns some default value
which will definitely be wrong for one of the screens.

The patch fixes the problem by introducing
QQuickWindow::effectiveDevicePixelRatio(), which, via
QQuickRenderControl::renderWindowFor, supports the redirected case too.

Task-number: QTBUG-42114
Change-Id: I057e01f0a00758dde438fc9b10af3a435b06bb0b
Reviewed-by: Paul Olav Tvete <paul.tvete@digia.com>

They would unconditionally call cleanupNodesOnShutdown on hide(), but
QQuickWindow::sceneGraphInvalidated would only be emitted if this was
the last window being hidden, leading to an inconsistent state in the
application.

Since the non-threaded render loops do not support releasing resources
(there is one OpenGL context and one QSGRenderContext shared between
all windows) we delay cleanup until the window is destroyed.

This change also make the render loops track the windows until they
are destroyed, similar to what the threaded one does. The purpose of
this is to, in the case of dangling windows, only trigger invalidation
of the scene graph when the last QQuickWindow is destroyed through
QSGRenderLoop::cleanup().

Task-number: QTBUG-41210
Change-Id: I7e12a4f726ebb3e7935c822b6046abb3590c583a
Reviewed-by: Ulf Hermann <ulf.hermann@digia.com>
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

Some features, like the memory profiler, create huge amounts of data.
Often enough, we're not actually interested in all the data available
from the profiler and collecting it all can lead to excessive memory
consumption. This change enables us to optionally turn various aspects
of QML profiling off.

Task-number: QTBUG-41118
Change-Id: I7bb223414e24eb903124ffa6e0896af6ce974e49
Reviewed-by: Gunnar Sletta <gunnar@sletta.org>

- Renamed LICENSE.LGPL to LICENSE.LGPLv21
- Added LICENSE.LGPLv3 & LICENSE.GPLv2
- Removed LICENSE.GPL

Change-Id: I84a565e2e0caa3b76bf291a7d188a57a4b00e1b0
Reviewed-by: Jani Heikkinen <jani.heikkinen@digia.com>

Change-Id: I438c33a1dc83fd0cd1ec08bb4e4a1257a3216ca2
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

Previously the polish timings were collected incorrectly from the
windows render loop and not at all from the basic render loop. By
collecting the polish times at the right places we can get rid of
the 2-argument profile macro as well.

Task-number: QTBUG-39876
Change-Id: I0b4aaf87162c652b8dcea6cd4f54db053f8312fe
Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>

Change-Id: I865ee838b0fd6c257b7189f24130012b98206fd1
Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>

Instead of sending multiple touch updates per frame, we
store the last one and flush the pending events just before
we enter into the scene graph sync phase.

[ChangeLog][QtQuick] QQuickWindow will compresses touch events
and delivers at most one touch event per frame.

Done-with: Robin Burchell <robin.burchell@jollamobile.com>
Change-Id: Ia0169bc4a3f0da67709b91ca65c326934b55d372
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>

Task-number: QTBUG-38564
Change-Id: Ice1170339f7d650fcb6accfccf325471629343d6
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

This removes QSGContext::sharedOpenGLContext and replace its uses
with QOpenGLContextPrivate::globalShareContext, which is also going
to be used by QOpenGLWidget and QQuickWidget.

Change-Id: I1e296c3e6832f717caaf31ba7d7b27c06249219b
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

Multiply by window->devicePixelRatio() at all
qt_gl_read_framebuffer() call sites.

Task-number: QTBUG-35962
Change-Id: If58e4f97fc5d931ba2e222f8cb1a0641d52c3257
Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>

The cleanup() function would deregister the render loop from all
windows the render loop had seen, but the render loop doesn't see
windows until the window gets a showEvent and for some implementations
it was removed as a result of hideEvent. So add explicit tracking to
QSGRenderLoop which is managed by QQuickWindow's constructor and
destructor. With this, we no longer need the lists from the
subclasses, so these functions are removed again.

Change-Id: I05e5507ad57e23c80bacd99752654cc7d0890dc1
Reviewed-by: Paul Olav Tvete <paul.tvete@digia.com>

e13547c5

 used a global static to clean
up QSGRenderLoop which is triggered very late, potentially after
SG backend API plugins have been unloaded. This results in crashes
when used in combination with scenegraph-playgrounds's customcontext.

Partially revert the change and instead clean up at the time of
QApp::aboutToQuit and make sure we also disconnect cleanly from
all QQuickWindows.

This change also ensures that QSGRenderLoop::windowDestroyed() gets
called for all QQuickWindows registered with the render loop. This
ensures that rendering stops and that scene graph nodes and resources
will be cleaned up regardless of whether the application has
remembered to delete the window or not. This is a good thing as it
makes the scene graph shutdown a bit cleaner.

Change-Id: I9cb9093979f8eac05542f118a6ff9cfe5c84f745
Reviewed-by: Paul Olav Tvete <paul.tvete@digia.com>

Add QQuickWidget::sceneGraphError() equivalent to
QQuickWindow::sceneGraphError(), move message formatting code
to QQuickWindowPrivate.

Change-Id: I18cd4d7e0f6ee1011c29375218dc6a044b0d2cf2
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

The error signal patch added some usages of QOpenGLFunctions::isES().
These need to be temporarily removed.

Change-Id: Ibd1d8094059020708aefe4b3502ba56d624928b3
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
Reviewed-by: Jørgen Lind <jorgen.lind@digia.com>

Also marked the new afterAnimation() signal as \since 5.3 and
introduced proper revisioning on the new signals.

[Changelog][QtQuick] Added QQuickWindow::afterSynchronizing(),
openglContextCreated(), sceneGraphAboutToStop(). Useful for
deeper integration with the rendering.

Change-Id: I5532b310506c2432325595e55ef9307b8934abee
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

When nothing is connected to this signal, an error will be printed or,
in case of Windows, a message box will be shown. If there is something
connected, it is up to the application to handle the error.

[ChangeLog] Added a new sceneGraphError() signal to QQuickWindow
which applications can use to detect errors like OpenGL context creation
failures and react in their own custom ways.

Task-number: QTBUG-36138
Change-Id: I33b1e5e0e3f25872af67c5bb5ae937e3470b25f3
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>

[ChangeLog] QQuickWindow will now emit the afterAnimating() signal
from the gui thread before each scenegraph sync request.

Change-Id: I4897c82f75066238e781455d4fce4fb6bbe2558e
Reviewed-by: Pasi Keränen <pasi.keranen@digia.com>
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

The QtQuick parts of the QML profiler service thus become a proper
global profiler which can be independently enabled and disabled.

Change-Id: Ifad03801cab2be66a264fc46fdebdae582fcc99b
Reviewed-by: Kai Koehne <kai.koehne@digia.com>

Without this change, it is not possible to implement a custom context
without also implementing a renderloop.

Change-Id: Iac2aa732251cdf7221b28f665394cdd336a3d846
Reviewed-by: Michael Brasser <michael.brasser@live.com>

Allow multiple detailTypes in each packet and extend the profiling code
to make use of that. Note that this changes the usual order of
pixmapSizeKnown and PixmapLoadingFinished events. As far as I can see
this doesn't affect the QML profiler frontend and the order of these
events isn't specified anywhere.

Change-Id: Id39ad98594ccf35add4415e08daf9e92ab561237
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

Don't needlessly duplicate information about the profiler being available
and allow inlining. Use macros to check availability of the profiler
in calling code and generally simplify the code.

Task-number: QTBUG-35315
Change-Id: I0a9daec4a95f74b9db795ef2918a01fb772ea107
Reviewed-by: Michael Brasser <michael.brasser@live.com>
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
Reviewed-by: Kai Koehne <kai.koehne@digia.com>

Mixing printf and qDebug can make the output come out of sync.

Change-Id: Ia71e71b09cb3bf651010eb2eb652db7899b07f0d
Reviewed-by: Robin Burchell <robin+qt@viroteck.net>

If another GL context is bound to another surface on the GUI
thread, we can run into issues while cleaning up the SG nodes.

Task-number: QTBUG-34898
Change-Id: Ifa02b7cdbc7ab38b3a149a21452cc5071498a7d1
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

Task-number: QTBUG-33363
(cherry-picked from commit 12eab916

)

Change-Id: Ia2b0c329157786cb4ec703989f12d2fdb1ce6bc8
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

Task-number: QTBUG-33363

Change-Id: Ia2b0c329157786cb4ec703989f12d2fdb1ce6bc8
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

Task-number: QTBUG-34806
Change-Id: I5013baaff0ca86357292474976944c1a3056f219
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

This API is primarily a hook which is needed by the Qt WebEngine to
set up sharing with the scene graph's OpenGL contexts.

Change-Id: I5bb03abd9ab99f502db8e413fe838a8b30365b8d
Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@digia.com>

See the task for the full reasoning behind this patch.

The threaded renderloop has been refactored to have one window per
thread. This is mostly a simplification of the current code path where
for loops over multiple windows are turned into if (window).

The QSGContext has been split into two classes, QSGRenderContext
for which there is one per OpenGLContext.

The rest of the patch is name changes and a couple of cleanups
in the hopes of simplifying this change.

Task-number: QTBUG-33993

Change-Id: I31c81f9694d7da7474a72333169be38de62613c4
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

Change-Id: I3750c47640bf21c3567c5fa1c4667e3e2552942e
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

This was the one convenience that was lost when transitioning templates
from QQuickView + Item{} to QQmlApplicationEngine + Window{}.

As the default window incubation controller was tied to the first
window's frameSwapped, we could easily run into a situation where
a secondary window required incubation while the first window
was idle. This would then starve the incubation controller. Instead
make it so that the renderloop emits "timeToIncubate" once it
is done with a renderpass over all windows, so the incubator
gets to run once and exactly once per vsync when animating.

The incubator logic was also flawed in that it could post
a lot of events to itself as a result of incubatingObjectCountChanged
and thus starve system events while processing incubation requests.
Now we start a timer and don't start it again until we have
completed an incubation pass.

Task-number: QTBUG-31203
Change-Id: Iea9e2c81efb46bb7875c70ccda0cdc4b3b3e58e7
Reviewed-by: Alan Alpert <aalpert@blackberry.com>
Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>

Change-Id: Ide71b330b13fc3816ed191bd9af84e0fce0d9587
Reviewed-by: Kai Koehne <kai.koehne@digia.com>

The normal GUI thread render loop has several problems on windows.
It does not do vsync animations and on some hardware, where the
vsync delta is higher than the time it takes to fire a 16ms timer,
the eventloop will always contain at least one event and we never
return to processing non-client area events, like resize.

Also, threaded OpenGL seems rather unstable, so the threaded renderer
is not a stable option.

So we introduce a windows based renderloop. It is fully cross platform
but written to make the most out of the limitations which exist.

The overall goal is:
  - vsync animations when allowed by the system. We get this by
    using an animation driver and advancing in sync with rendering
  - Keep system load low and allow for NC processing. The maybeUpdate
    function will start a short timer which will let the renderloop
    idle for few ms, allowing the eventloop to pick up system events.
    (this is similar to what the threaded renderer also does, btw)

Change-Id: Ic192fd0ed7d5ecdaa2c887c08cbeb42c5de6b8a8
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>