Updated picking-qml example

handle device pixel ratio and none full-window Scene3D

Change-Id: Iadc504a00816d9363847bf9ec1e09d4b7c631666
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

16 files changed, 351 insertions, 122 deletions

diff --git a/examples/qt3d/picking-qml/PickableEntity.qml b/examples/qt3d/picking-qml/PickableEntity.qml
new file mode 100644
index 000000000..f9f7f7e9e
--- /dev/null
+++ b/examples/qt3d/picking-qml/PickableEntity.qml
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import Qt3D.Core 2.0
+import Qt3D.Render 2.0
+
+Entity {
+    id: root
+    signal pressed(var event)
+    signal clicked(var event)
+    signal released(var event)
+    signal entered()
+    signal exited()
+
+    property real x: 0
+    property real y: 0
+    property real z: 0
+    property alias scale: transform.scale
+    property alias hoverEnabled: objectPicker.hoverEnabled
+    property alias recursive: debugVolume.recursive
+    property alias diffuseColor: material.diffuse
+    property alias ambientColor: material.ambient
+    readonly property bool containsMouse: objectPicker.containsMouse
+    readonly property bool isPressed: objectPicker.pressed
+
+    property GeometryRenderer mesh;
+
+    ObjectPicker {
+        id: objectPicker
+        onClicked: root.clicked(event)
+        onPressed: root.pressed(event)
+        onReleased: root.released(event)
+        onEntered: root.entered()
+        onExited: root.exited();
+    }
+
+    BoundingVolumeDebug { id: debugVolume }
+    PhongMaterial { id: material }
+
+    Transform {
+        id: transform
+        translation: Qt.vector3d(x, y, z)
+    }
+
+    Layer {
+        id: layer
+        names: "content"
+    }
+
+    components: [mesh, material, transform, debugVolume, objectPicker, layer]
+}
+
diff --git a/examples/qt3d/picking-qml/main.qml b/examples/qt3d/picking-qml/main.qml
index 2c9e7a955..8b7111b4d 100644
--- a/examples/qt3d/picking-qml/main.qml
+++ b/examples/qt3d/picking-qml/main.qml
@@ -37,117 +37,183 @@
 import Qt3D.Core 2.0
 import Qt3D.Render 2.0
 import Qt3D.Input 2.0
-import QtQuick 2.0 as QQ2
-
-Entity {
-    id: sceneRoot
-
-    Camera {
-        id: camera
-        projectionType: CameraLens.PerspectiveProjection
-        fieldOfView: 45
-        aspectRatio: _view.width / _view.height
-        nearPlane : 0.1
-        farPlane : 1000.0
-        position: Qt.vector3d( 0.0, 0.0, 40.0 )
-        upVector: Qt.vector3d( 0.0, 1.0, 0.0 )
-        viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 )
-    }
-
-    FirstPersonCameraController { camera: camera }
-
-    components: FrameGraph {
-        ForwardRenderer {
-            camera: camera
-            clearColor: "black"
-        }
-    }
-
-    SphereMesh {
-        id: sphereMesh
-    }
-
-    Entity {
-        id: sphere1
-
-        property real scaleFactor: objectPicker.pressed ? 3.0 : 1.0
-        QQ2.Behavior on scaleFactor { QQ2.NumberAnimation { duration: 150; easing.type: QQ2.Easing.InQuad } }
-
-        property Transform transform: Transform {
-            scale: sphere1.scaleFactor
-            translation: Qt.vector3d(-8, 0, 0)
-        }
-
-        property Material material: PhongMaterial {
-            ambient: "green"
-            diffuse: "green"
-        }
-
-        property ObjectPicker objectPicker: ObjectPicker {
-            hoverEnabled: true
-
-            onPressed: sphere1.material.diffuse = "orange"
-            onReleased:  sphere1.material.diffuse = "green"
-
-            onEntered: sphere1.material.ambient = "blue"
-            onExited: sphere1.material.ambient = "green"
-
-            onClicked: console.log("Clicked Sphere 1")
-        }
-
-        components: [sphereMesh, material, transform, objectPicker]
-    }
 
-    Entity {
-        id: sphere2
-
-        property Material material: PhongMaterial {
-            ambient: sphere2.objectPicker.containsMouse ? "blue" : "red"
-        }
-
-        property Transform transform: Transform {
-            scale: 1.5
-        }
-
-        property ObjectPicker objectPicker: ObjectPicker {
-            hoverEnabled: true
-
-            onPressed: sphere2.material.diffuse = "white"
-            onReleased: sphere2.material.diffuse = "red"
-
-            onClicked: console.log("Clicked Sphere 2")
-        }
-
-        components: [sphereMesh, material, transform, objectPicker]
-    }
-
-    Entity {
-        id: sphere3
-
-        property Material material: PhongMaterial {
-            diffuse: "yellow"
-        }
-
-        property bool toggled: false
-        property real scaleFactor: toggled ? 5.0 : 0.5
-        QQ2.Behavior on scaleFactor { QQ2.NumberAnimation { duration: 200; easing.type: QQ2.Easing.InQuad } }
-
-        property Transform transform: Transform {
-            scale: sphere3.scaleFactor
-            translation: Qt.vector3d(8, 0, 0)
-        }
-
-        property ObjectPicker objectPicker: ObjectPicker {
-            hoverEnabled: false
-
-            onPressed: sphere3.toggled = !sphere3.toggled
-
-            onEntered: sphere3.material.ambient = "black"
-            onExited: sphere3.material.ambient = "white"
-
-            onClicked: console.log("Clicked Sphere 3")
+import QtQuick 2.0 as QQ2
+import QtQuick.Window 2.2 as W
+import QtQuick.Scene3D 2.0
+
+W.Window
+{
+    id: _view
+    visible: true
+    width: 1024
+    height: 768
+
+    Scene3D {
+//        anchors.fill: parent
+        id: sceneItem
+        x: parent.width / 2 - width / 2
+        y: parent.height / 2 - height / 2
+        width: parent.width / 2
+        height: parent.height / 2
+        focus: true
+        aspects: "input"
+
+        Entity {
+            id: sceneRoot
+
+            Camera {
+                id: camera
+                projectionType: CameraLens.PerspectiveProjection
+                fieldOfView: 45
+                aspectRatio: _view.width * 0.5 / _view.height
+                nearPlane : 0.1
+                farPlane : 1000.0
+                position: Qt.vector3d( 0.0, 0.0, -40.0 )
+                upVector: Qt.vector3d( 0.0, 1.0, 0.0 )
+                viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 )
+            }
+
+            Camera {
+                id: camera2
+                projectionType: CameraLens.PerspectiveProjection
+                fieldOfView: 45
+                aspectRatio: _view.width * 0.5 / _view.height
+                nearPlane : 0.1
+                farPlane : 1000.0
+                position: Qt.vector3d( 40.0, 5.0, -20.0 )
+                upVector: Qt.vector3d( 0.0, 1.0, 0.0 )
+                viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 )
+            }
+
+            FirstPersonCameraController {
+                camera: camera
+            }
+
+            // Draw 2 viewports
+            // one with the content, the other with content + debug volumes
+            components: FrameGraph {
+                Viewport {
+                    ClearBuffer {
+                        buffers : ClearBuffer.ColorDepthBuffer
+                        NoDraw {}
+                    }
+                    Viewport {
+                        rect: Qt.rect(0.0, 0.0, 0.5, 1.0)
+                        CameraSelector {
+                            camera: camera
+                            LayerFilter { layers: "content"}
+                        }
+                    }
+                    Viewport {
+                        rect: Qt.rect(0.5, 0.0, 0.5, 1.0)
+                        CameraSelector {
+                            camera: camera2
+                            LayerFilter {
+                                // To show Debug volumes
+                                layers: ["content", "debug"]
+                            }
+                        }
+                    }
+                }
+            }
+
+            CuboidMesh { id: cubeMesh }
+
+            PickableEntity {
+                id: cube1
+                property real scaleFactor: isPressed ? 3.0 : 1.0
+                QQ2.Behavior on scaleFactor { QQ2.NumberAnimation { duration: 150; easing.type: QQ2.Easing.InQuad } }
+
+                mesh: cubeMesh
+                scale: cube1.scaleFactor
+                x: -8
+
+                ambientColor: "green"
+                diffuseColor: "green"
+
+                hoverEnabled: true
+                onPressed: cube1.diffuseColor = "orange"
+                onReleased:  cube1.diffuseColor = "green"
+                onEntered: cube1.ambientColor = "blue"
+                onExited: cube1.ambientColor = "green"
+                onClicked: console.log("Clicked cube 1")
+            }
+
+            PickableEntity {
+                id: cube2
+                mesh: cubeMesh
+
+                ambientColor: cube2.containsMouse ? "blue" : "red"
+                scale: 1.5
+                hoverEnabled: true
+
+                onPressed: cube2.diffuseColor = "white"
+                onReleased: cube2.diffuseColor = "red"
+
+                property bool toggled: false
+                onClicked: {
+                    console.log("Clicked cube 2")
+                    toggled = !toggled
+                    sceneItem.width = _view.width * (toggled ? .7 : .5)
+                    sceneItem.height = _view.height * (toggled ? .7 : .5)
+                    console.log(sceneItem.width, sceneItem.height)
+                }
+            }
+            PickableEntity {
+                id: cube3
+                mesh: cubeMesh
+
+                diffuseColor: "yellow"
+
+                property bool toggled: false
+                property real scaleFactor: toggled ? 5.0 : 0.5
+                QQ2.Behavior on scaleFactor { QQ2.NumberAnimation { duration: 200; easing.type: QQ2.Easing.InQuad } }
+
+                scale: cube3.scaleFactor
+                x: 8
+
+                onPressed: cube3.toggled = !cube3.toggled
+                onEntered: cube3.ambientColor = "black"
+                onExited: cube3.ambientColor = "white"
+                onClicked: console.log("Clicked cube 3")
+            }
+
+            Entity {
+                readonly property ObjectPicker objectPicker: ObjectPicker {
+                    hoverEnabled: true
+                    onPressed: cube4.toggled = !cube4.toggled
+                    onClicked: console.log("Clicked cube 4's parent Entity")
+                    onEntered: cube4.material.diffuse = "white"
+                    onExited: cube4.material.diffuse = "blue"
+                }
+
+                readonly property BoundingVolumeDebug debugVolume: BoundingVolumeDebug {
+                    recursive: true
+                }
+
+                components: [objectPicker, debugVolume]
+
+                Entity {
+                    id: cube4
+                    property bool toggled: false
+                    property real scaleFactor: toggled ? 2.0 : 1.0
+                    QQ2.Behavior on scaleFactor { QQ2.NumberAnimation { duration: 200; easing.type: QQ2.Easing.InQuad } }
+
+                    readonly property Transform transform: Transform {
+                        scale: cube4.scaleFactor
+                        translation: Qt.vector3d(3, 4, 0)
+                    }
+                    readonly property Layer layer: Layer { names: "content" }
+                    readonly property BoundingVolumeDebug debugVolume: BoundingVolumeDebug {}
+                    readonly property PhongMaterial material: PhongMaterial { diffuse: "red" }
+
+                    components: [cubeMesh, transform, material, debugVolume, layer]
+                }
+            }
         }
 
-        components: [sphereMesh, material, transform, objectPicker]
+        QQ2.Behavior on width { QQ2.NumberAnimation { duration: 200 } }
+        QQ2.Behavior on height { QQ2.NumberAnimation { duration: 200 } }
     }
 }
diff --git a/examples/qt3d/picking-qml/picking-qml.qrc b/examples/qt3d/picking-qml/picking-qml.qrc
index 5f6483ac3..15bdbb178 100644
--- a/examples/qt3d/picking-qml/picking-qml.qrc
+++ b/examples/qt3d/picking-qml/picking-qml.qrc
@@ -1,5 +1,6 @@
 <RCC>
     <qresource prefix="/">
         <file>main.qml</file>
+        <file>PickableEntity.qml</file>
     </qresource>
 </RCC>
diff --git a/src/render/backend/abstractrenderer_p.h b/src/render/backend/abstractrenderer_p.h
index 39dadbbf8..109fa5c16 100644
--- a/src/render/backend/abstractrenderer_p.h
+++ b/src/render/backend/abstractrenderer_p.h
@@ -54,6 +54,7 @@
 QT_BEGIN_NAMESPACE
 
 class QSurface;
+class QSize;
 
 namespace Qt3DCore {
 class QAbstractFrameAdvanceService;
@@ -89,11 +90,15 @@ public:
     virtual void setTime(qint64 time) = 0;
 
     virtual void setSurface(QSurface *surface) = 0;
+    virtual void setSurfaceSize(const QSize& s) = 0;
+    virtual void setDevicePixelRatio(qreal r) = 0;
     virtual void setNodeManagers(NodeManagers *managers) = 0;
     virtual void setServices(Qt3DCore::QServiceLocator *services) = 0;
     virtual void setSurfaceExposed(bool exposed) = 0;
 
     virtual QSurface *surface() const = 0;
+    virtual const QSize &surfaceSize() const = 0;
+    virtual qreal devicePixelRatio() const = 0;
     virtual NodeManagers *nodeManagers() const = 0;
     virtual Qt3DCore::QServiceLocator *services() const = 0;
 
diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index c9a5b5b0f..94760bda5 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -136,6 +136,7 @@ Renderer::Renderer(QRenderAspect::RenderType type)
     , m_nodesManager(Q_NULLPTR)
     , m_graphicsContext(Q_NULLPTR)
     , m_surface(Q_NULLPTR)
+    , m_devicePixelRatio(1.)
     , m_renderQueue(new RenderQueue())
     , m_renderThread(type == QRenderAspect::Threaded ? new RenderThread(this) : Q_NULLPTR)
     , m_vsyncFrameAdvanceService(new VSyncFrameAdvanceService())
@@ -508,6 +509,16 @@ void Renderer::setSurface(QSurface* surface)
     }
 }
 
+void Renderer::setSurfaceSize(const QSize &s)
+{
+    m_surfaceSize = s;
+}
+
+void Renderer::setDevicePixelRatio(qreal s)
+{
+    m_devicePixelRatio = s;
+}
+
 void Renderer::registerEventFilter(QEventFilterService *service)
 {
     qCDebug(Backend) << Q_FUNC_INFO << QThread::currentThread();
@@ -742,7 +753,7 @@ bool Renderer::submitRenderViews()
         m_graphicsContext->clearBackBuffer(renderView->clearBuffer());
 
         // Set the Viewport
-        m_graphicsContext->setViewport(renderView->viewport());
+        m_graphicsContext->setViewport(renderView->viewport(), renderView->surfaceSize() * renderView->devicePixelRatio());
 
         // Execute the render commands
         executeCommands(renderView);
@@ -810,7 +821,8 @@ Qt3DCore::QAspectJobPtr Renderer::createRenderViewJob(FrameGraphNode *node, int
     RenderViewJobPtr job(new RenderViewJob);
     job->setRenderer(this);
     if (m_surface)
-        job->setSurfaceSize(m_surface->size());
+        job->setSurfaceSize(m_surfaceSize.isValid() ? m_surfaceSize : m_surface->size());
+    job->setDevicePixelRatio(m_devicePixelRatio);
     job->setFrameGraphLeafNode(node);
     job->setSubmitOrderIndex(submitOrderIndex);
     return job;
diff --git a/src/render/backend/renderer_p.h b/src/render/backend/renderer_p.h
index c3d2587ed..7d7eb944a 100644
--- a/src/render/backend/renderer_p.h
+++ b/src/render/backend/renderer_p.h
@@ -128,11 +128,15 @@ public:
     void setTime(qint64 time) Q_DECL_OVERRIDE;
 
     void setSurface(QSurface *s) Q_DECL_OVERRIDE;
+    void setSurfaceSize(const QSize& s) Q_DECL_OVERRIDE;
+    void setDevicePixelRatio(qreal s) Q_DECL_OVERRIDE;
     void setNodeManagers(NodeManagers *managers) Q_DECL_OVERRIDE { m_nodesManager = managers; }
     void setServices(Qt3DCore::QServiceLocator *services) Q_DECL_OVERRIDE { m_services = services; }
     void setSurfaceExposed(bool exposed) Q_DECL_OVERRIDE;
 
     QSurface *surface() const Q_DECL_OVERRIDE { return m_surface; }
+    const QSize &surfaceSize() const Q_DECL_OVERRIDE { return m_surfaceSize; }
+    qreal devicePixelRatio() const Q_DECL_OVERRIDE { return m_devicePixelRatio; }
     NodeManagers *nodeManagers() const Q_DECL_OVERRIDE;
     Qt3DCore::QServiceLocator *services() const Q_DECL_OVERRIDE { return m_services; }
 
@@ -227,6 +231,8 @@ private:
 
     QScopedPointer<GraphicsContext> m_graphicsContext;
     QSurface *m_surface;
+    QSize m_surfaceSize;
+    qreal m_devicePixelRatio;
 
 
     RenderQueue *m_renderQueue;
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index 24e9d9c10..de7d0e5e8 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -270,6 +270,7 @@ QUniformValue *RenderView::eyePosition(const QMatrix4x4 &model) const
 
 RenderView::RenderView()
     : m_renderer(Q_NULLPTR)
+    , m_devicePixelRatio(1.)
     , m_allocator(Q_NULLPTR)
     , m_data(Q_NULLPTR)
     , m_clearColor(Q_NULLPTR)
@@ -393,6 +394,7 @@ void RenderView::setRenderer(Renderer *renderer)
 {
     m_renderer = renderer;
     m_manager = renderer->nodeManagers();
+    m_surface = renderer->surface();
     m_data->m_uniformBlockBuilder.shaderDataManager = m_manager->shaderDataManager();
 }
 
diff --git a/src/render/backend/renderview_p.h b/src/render/backend/renderview_p.h
index ccb0554f3..057a5ebed 100644
--- a/src/render/backend/renderview_p.h
+++ b/src/render/backend/renderview_p.h
@@ -118,6 +118,9 @@ public:
     inline void setSurfaceSize(const QSize &size) Q_DECL_NOEXCEPT { m_surfaceSize = size; }
     inline Renderer *renderer() const Q_DECL_NOEXCEPT { return m_renderer; }
     inline NodeManagers *nodeManagers() const Q_DECL_NOEXCEPT { return m_manager; }
+    inline const QSize &surfaceSize() const { return m_surfaceSize; }
+    inline void setDevicePixelRatio(qreal r) { m_devicePixelRatio = r; }
+    inline qreal devicePixelRatio() const { return m_devicePixelRatio; }
 
     inline void setAllocator(Qt3DCore::QFrameAllocator *allocator)
     {
@@ -270,6 +273,7 @@ private:
     Renderer *m_renderer;
     NodeManagers *m_manager;
     QSize m_surfaceSize;
+    qreal m_devicePixelRatio;
     Qt3DCore::QFrameAllocator *m_allocator;
 
     InnerData *m_data;
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index 35c194ccf..860445e48 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -200,6 +200,7 @@ void QRenderAspectPrivate::setSurface(QSurface *surface)
             QWindow *window = static_cast<QWindow *>(m_surface);
             m_surfaceEventFilter->setWindow(window);
             hasPlatformSurface = (window->handle() != Q_NULLPTR);
+            m_devicePixelRatio = window->devicePixelRatio();
             break;
         }
 
@@ -211,9 +212,15 @@ void QRenderAspectPrivate::setSurface(QSurface *surface)
         }
         }
 
+        if (!m_surfaceSize.isValid())
+            m_surfaceSize = surface->size();
+
         // If the window/offscreen surface has a native surface, tell the renderer
-        if (hasPlatformSurface)
+        if (hasPlatformSurface) {
             m_renderer->setSurface(surface);
+            m_renderer->setSurfaceSize(m_surfaceSize);
+            m_renderer->setDevicePixelRatio(m_devicePixelRatio);
+        }
     }
 }
 
@@ -409,6 +416,34 @@ QVector<Qt3DCore::QAspectJobPtr> QRenderAspect::jobsToExecute(qint64 time)
     return jobs;
 }
 
+const QSize &QRenderAspect::surfaceSize() const
+{
+    Q_D(const QRenderAspect);
+    return d->m_surfaceSize;
+}
+
+void QRenderAspect::setSurfaceSize(const QSize &s)
+{
+    Q_D(QRenderAspect);
+    d->m_surfaceSize = s;
+    if (d->m_renderer)
+        d->m_renderer->setSurfaceSize(s);
+}
+
+qreal QRenderAspect::devicePixelRatio() const
+{
+    Q_D(const QRenderAspect);
+    return d->m_devicePixelRatio;
+}
+
+void QRenderAspect::setDevicePixelRatio(qreal r)
+{
+    Q_D(QRenderAspect);
+    d->m_devicePixelRatio = r;
+    if (d->m_renderer)
+        d->m_renderer->setDevicePixelRatio(r);
+}
+
 void QRenderAspect::onRootEntityChanged(Qt3DCore::QEntity *rootEntity)
 {
     Q_D(QRenderAspect);
diff --git a/src/render/frontend/qrenderaspect.h b/src/render/frontend/qrenderaspect.h
index d7398dab7..2a9cd0eed 100644
--- a/src/render/frontend/qrenderaspect.h
+++ b/src/render/frontend/qrenderaspect.h
@@ -70,6 +70,11 @@ public:
 
     QVector<Qt3DCore::QAspectJobPtr> jobsToExecute(qint64 time) Q_DECL_OVERRIDE;
 
+    const QSize &surfaceSize() const;
+    void setSurfaceSize(const QSize &s);
+    qreal devicePixelRatio() const;
+    void setDevicePixelRatio(qreal r);
+
 protected:
     void registerBackendTypes();
     QRenderAspect(QRenderAspectPrivate &dd, QObject *parent);
diff --git a/src/render/frontend/qrenderaspect_p.h b/src/render/frontend/qrenderaspect_p.h
index 4690e98ac..61fd096db 100644
--- a/src/render/frontend/qrenderaspect_p.h
+++ b/src/render/frontend/qrenderaspect_p.h
@@ -87,6 +87,8 @@ public:
     // via QScopedPointerDeleteLater
     QScopedPointer<Render::PlatformSurfaceFilter, QScopedPointerDeleteLater> m_surfaceEventFilter;
     QSurface *m_surface;
+    QSize m_surfaceSize;
+    qreal m_devicePixelRatio;
 
     bool m_initialized;
     Render::FramePreparationJobPtr m_framePreparationJob;
diff --git a/src/render/graphicshelpers/graphicscontext.cpp b/src/render/graphicshelpers/graphicscontext.cpp
index b5b2898db..67d61deff 100644
--- a/src/render/graphicshelpers/graphicscontext.cpp
+++ b/src/render/graphicshelpers/graphicscontext.cpp
@@ -230,7 +230,7 @@ void GraphicsContext::endDrawing(bool swapBuffers)
     decayTextureScores();
 }
 
-void GraphicsContext::setViewport(const QRectF &viewport)
+void GraphicsContext::setViewport(const QRectF &viewport, const QSize &surfaceSize)
 {
     m_viewport = viewport;
     QSize renderTargetSize;
@@ -238,6 +238,8 @@ void GraphicsContext::setViewport(const QRectF &viewport)
         // For external FBOs we may not have a m_renderTargets entry.
         if (m_renderTargetsSize.contains(m_activeFBO)) {
             renderTargetSize = m_renderTargetsSize[m_activeFBO];
+        } else if (surfaceSize.isValid()) {
+            renderTargetSize = surfaceSize;
         } else {
             // External FBO (when used with QtQuick2 Scene3D)
 
diff --git a/src/render/graphicshelpers/graphicscontext_p.h b/src/render/graphicshelpers/graphicscontext_p.h
index 51e6c8bc4..090f05937 100644
--- a/src/render/graphicshelpers/graphicscontext_p.h
+++ b/src/render/graphicshelpers/graphicscontext_p.h
@@ -106,7 +106,7 @@ public:
     void clearBackBuffer(QClearBuffer::BufferType buffers);
     void endDrawing(bool swapBuffers);
 
-    void setViewport(const QRectF &viewport);
+    void setViewport(const QRectF &viewport, const QSize &surfaceSize);
     QRectF viewport() const { return m_viewport; }
 
     /**
diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp
index 23c320b83..344d83bff 100644
--- a/src/render/jobs/pickboundingvolumejob.cpp
+++ b/src/render/jobs/pickboundingvolumejob.cpp
@@ -395,10 +395,10 @@ void PickBoundingVolumeJob::viewMatrixForCamera(const Qt3DCore::QNodeId &cameraI
 QRect PickBoundingVolumeJob::windowViewport(const QRectF &relativeViewport) const
 {
     // TO DO: find another way to retrieve the size since this won't work with Scene3D
-    const QSurface *s = m_renderer->surface();
-    if (s) {
-        const int surfaceWidth = s->size().width();
-        const int surfaceHeight = s->size().height();
+    const QSize s = m_renderer->surfaceSize();
+    if (s.isValid()) {
+        const int surfaceWidth = s.width();
+        const int surfaceHeight = s.height();
         return QRect(relativeViewport.x() * surfaceWidth,
                      (1.0 - relativeViewport.y() - relativeViewport.height()) * surfaceHeight,
                      relativeViewport.width() * surfaceWidth,
@@ -419,10 +419,10 @@ QVector<Qt3DCore::QNodeId> PickBoundingVolumeJob::sphereHitsForViewportAndCamera
     viewMatrixForCamera(cameraId, viewMatrix, projectionMatrix);
     const QRect viewport = windowViewport(relativeViewport);
 
-    const QSurface *s = m_renderer->surface();
+    const QSize s = m_renderer->surfaceSize();
     // TO DO: find another way to retrieve the size since this won't work with Scene3D
     // In GL the y is inverted compared to Qt
-    const QPoint glCorrectPos = s ? QPoint(pos.x(), s->size().height() - pos.y()) : pos;
+    const QPoint glCorrectPos = s.isValid() ? QPoint(pos.x(), s.height() - pos.y()) : pos;
     const Qt3DCore::QRay3D ray = intersectionRay(glCorrectPos, viewMatrix, projectionMatrix, viewport);
     const QQueryHandle rayCastingHandle = rayCasting->query(ray, QAbstractCollisionQueryService::AllHits, volumeProvider);
     const QCollisionQueryResult queryResult = rayCasting->fetchResult(rayCastingHandle);
@@ -440,10 +440,10 @@ QVector<Qt3DCore::QNodeId> PickBoundingVolumeJob::triangleHitsForViewportAndCame
     viewMatrixForCamera(cameraId, viewMatrix, projectionMatrix);
     const QRect viewport = windowViewport(relativeViewport);
 
-    const QSurface *s = m_renderer->surface();
+    const QSize s = m_renderer->surfaceSize();
     // TO DO: find another way to retrieve the size since this won't work with Scene3D
     // In GL the y is inverted compared to Qt
-    const QPoint glCorrectPos = s ? QPoint(pos.x(), s->size().height() - pos.y()) : pos;
+    const QPoint glCorrectPos = s.isValid() ? QPoint(pos.x(), s.height() - pos.y()) : pos;
     const Qt3DCore::QRay3D ray = intersectionRay(glCorrectPos, viewMatrix, projectionMatrix, viewport);
 
     // Note: improve this further to only compute this once and not every time
diff --git a/src/render/jobs/renderviewjob.cpp b/src/render/jobs/renderviewjob.cpp
index 8482c672b..5c65d1d5f 100644
--- a/src/render/jobs/renderviewjob.cpp
+++ b/src/render/jobs/renderviewjob.cpp
@@ -60,6 +60,7 @@ void RenderViewJob::run()
     renderView->setAllocator(currentFrameAllocator);
     renderView->setRenderer(m_renderer);
     renderView->setSurfaceSize(m_surfaceSize);
+    renderView->setDevicePixelRatio(m_devicePixelRatio);
 
     // Populate the renderview's configuration from the framegraph
     setRenderViewConfigFromFrameGraphLeafNode(renderView, m_fgLeaf);
diff --git a/src/render/jobs/renderviewjob_p.h b/src/render/jobs/renderviewjob_p.h
index e26cce700..49be80697 100644
--- a/src/render/jobs/renderviewjob_p.h
+++ b/src/render/jobs/renderviewjob_p.h
@@ -67,12 +67,14 @@ class Q_AUTOTEST_EXPORT RenderViewJob : public Qt3DCore::QAspectJob
 public:
     RenderViewJob()
         : m_renderer(0)
+        , m_devicePixelRatio(1.)
         , m_fgLeaf(0)
         , m_index(0)
     {}
 
     inline void setRenderer(Renderer *renderer) { m_renderer = renderer; }
     inline void setSurfaceSize(const QSize &size) { m_surfaceSize = size; }
+    inline void setDevicePixelRatio(qreal r) { m_devicePixelRatio = r; }
 
     inline void setFrameGraphLeafNode(FrameGraphNode *fgLeaf)
     {
@@ -92,6 +94,7 @@ protected:
 private:
     Renderer *m_renderer;
     QSize m_surfaceSize;
+    qreal m_devicePixelRatio;
     FrameGraphNode *m_fgLeaf;
     int m_index;
 };