The renderer binds same buffer both for vertex and index data.
This is allowed on desktop & ES but is forbidden in WebGL.
Add a compile-time flag to disable this optimization(?) and
force using a separate buffer for the index data.

Change-Id: I57c17c883a55e02513a8e4427efb202cafaaf37e
Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>

The basic approach is to have the batched renderer create and bind a
vertex array object if it detects we are using an OpenGL Core profile
context. The VAO is bound for the duration of the QQ2 renderer's
work cycle and unbound at the end so as to not interfere with any
other VAO's a user may wish to use.

All shaders have been copied and ported to be compliant with the
GLSL 150 core specification which is the minimum for a Core profile
context (OpenGL 3.2 Core). We are not using any newer features as
yet so this will work anywhere we can get a Core profile context.

The QSGShaderSourceBuilder class has been extended to resolve any
requests for shaders to the same basefilename with "_core"
appended prior to any file extension. This could be extended in
the future to allow version, or GPU or platform specific shaders.

The QSGShaderSourceBuilder has also been extended to allow it to
insert #define definitions in the prologue of a shader. Any such
definition is inserted:

* After the last #extension directive (if any are found)
* Otherwise after the #version directive (if found)
* Otherwise at the start of the shader source

This is required by the custom particle shaders which make
extensive use of such #defines.

In addition the mechanism used by the distance field glyph cache to
extend the cache with new glyphs has been modified to work (and
work more efficiently) when using a Core profile context.

Rather than using a shader program and a buffer filling quad to
blit the old texture into the new cache texture, we instead use
the technique of framebuffer blitting. The existing fallback
implementation using glTexSubImage2D() is still available if
needed.

The DECLARATIVE_EXAMPLE_MAIN macro has been extended to allow easy
testing of any of the QtDeclarative examples with a core profile
context. Just run the example with

QT_QUICK_CORE_PROFILE=1 ./text

for e.g. The only ones that may not work out of the box are those
that provide GLSL shader source e.g. the customparticles or
shader effect examples. These work fine if the shader source is
adapted to GLSL 150 core.

In the future it may be a good idea to expose some context property
to QML that the user can use to determine what shader source
variation to provide to Qt Quick. Along these lines it would also
be very nice to allow the provision of shader source to
ShaderEffect or CustomParticle from a separate source file just as
we now do within Qt Quick.

Task-number: QTBUG-32050
Change-Id: Ia6e9f06dbb8508af9ae03c6b60fb418b4cc9e41f
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

The default implementation of QSGShaderMaterial::vertexShader() and
fragmentShader() now loads the GLSL source from a list of source files
that can be specified via the setShaderSourceFile() or
setShaderSourceFiles() functions.

Multiple shader source files for each shader stage are supported. Each
source file will be read in the order specified and concatenated
together before being compiled.

The other places where Qt Quick 2 loads shader source code have
been adapted to use the new QSGShaderSourceBuilder, which is also
used internally by QSGMaterial.

This puts Qt Quick 2 into a better state ready to support OpenGL
core profile and to load different shaders based upon OpenGL version,
profile, GPU vendor, platform, etc.

Change-Id: I1a66213c2ce788413168eb48c7bc5317e61988a2
Reviewed-by: Gunnar Sletta <gunnar.sletta@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>

The renderer tries to batch primitives together where possible, isolate
non-changing subparts of the scene from changing subparts and retain
vertexdata on the GPU as much as possible. Atlas textures are crucial
in enabling batching.

The renderer and atlas texture are described in detail in the doc page
"Qt Quick Scene Graph Renderer".

Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>

Change-Id: I35f07a1725af104952f822274763dd7a96a9d560

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>

Convert the private void *m_reserved to a d_ptr so as to make QSGNode
inherited classes extensible without breaking binary compatibility.
QSGNode and subclasses do not create a private instance by default.

This is required by a follow-up commit where a new member needs to be
added to QSGSimpleTextureNode. Protected ctors have been added to the
superclasses of QSGSimpleTextureNode in the usual fashion.

Change-Id: I30c5f5d057654145d87f18c34c5d13a6ff5f7b11
Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>

This change starts using the superior implementation of the scene graph
render loop which has been worked on in the scenegraph-playground
project for a while. It uses a far more straightforward locking/sync
paradigm compared to the existing one and is less deadlock and error
prone. It also enables the scene graph thread to run on its own when
the GUI thread is blocked, enabling threaded animations.

This changes also introduces a naming change inside Qt Quick from
"Window Manager" -> "Render Loop" as that fits better to what the
code does.

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

Change-Id: I769eb68a1703a2cc7379af702fb888d3e9697300
Reviewed-by: Geir Vattekar <geir.vattekar@nokia.com>