| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB). |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt3D module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** 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 https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://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.LGPL3 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-3.0.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 (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qrendersurfaceselector.h" |
| #include "qrendersurfaceselector_p.h" |
| |
| #include <QtGui/QWindow> |
| #include <QtGui/QScreen> |
| #include <QtGui/QOffscreenSurface> |
| #include <Qt3DCore/qentity.h> |
| #include <Qt3DRender/qrendersettings.h> |
| #include <Qt3DRender/qframegraphnodecreatedchange.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| namespace Qt3DRender { |
| |
| /*! |
| \class Qt3DRender::QRenderSurfaceSelector |
| \inmodule Qt3DRender |
| \brief Provides a way of specifying the render surface. |
| \since 5.7 |
| |
| The Qt3DRender::QRenderSurfaceSelector can be used to select the surface, where |
| Qt3D renders the content. The surface can either be window surface or offscreen |
| surface. The externalRenderTargetSize is used to specify the actual size of the |
| surface when offscreen surface is used. |
| |
| When DPI scaling is used by the system, the logical surface size, which is used |
| by mouse events, and the actual 'physical' size of the surface can differ. |
| The surfacePixelRatio is the factor to convert the logical size to the physical |
| size. |
| |
| \sa QWindow, QOffscreenSurface, QSurface |
| */ |
| |
| /*! |
| \qmltype RenderSurfaceSelector |
| \inqmlmodule Qt3D.Render |
| \since 5.7 |
| \instantiates Qt3DRender::QRenderSurfaceSelector |
| \inherits FrameGraphNode |
| \brief Provides a way of specifying the render surface. |
| |
| The RenderSurfaceSelector can be used to select the surface, where |
| Qt3D renders the content. The surface can either be window surface or offscreen |
| surface. The externalRenderTargetSize is used to specify the actual size of the |
| render target when offscreen surface is used. |
| |
| When DPI scaling is used by the system, the logical surface size, which is used |
| by mouse events, and the actual 'physical' size of the surface can differ. |
| The surfacePixelRatio is the factor to convert the logical size to the physical |
| size. |
| */ |
| |
| /*! \qmlproperty QSurface Qt3D.Render::RenderSurfaceSelector::surface |
| Holds the surface. |
| */ |
| |
| /*! \qmlproperty size Qt3D.Render::RenderSurfaceSelector::externalRenderTargetSize |
| |
| Holds the size of the external render target. |
| */ |
| |
| /*! \qmlproperty real Qt3D.Render::RenderSurfaceSelector::surfacePixelRatio |
| |
| Holds the surfacePixelRatio of the surface. |
| */ |
| |
| /*! |
| \property QRenderSurfaceSelector::surface |
| Holds the surface |
| */ |
| |
| /*! |
| \property QRenderSurfaceSelector::externalRenderTargetSize |
| Holds the size of the external render target. |
| */ |
| |
| /*! \property QRenderSurfaceSelector::surfacePixelRatio |
| |
| Holds the surfacePixelRatio of the surface. |
| */ |
| |
| QRenderSurfaceSelectorPrivate::QRenderSurfaceSelectorPrivate() |
| : Qt3DRender::QFrameGraphNodePrivate() |
| , m_surface(nullptr) |
| , m_surfaceEventFilter(new Qt3DRender::Render::PlatformSurfaceFilter()) |
| , m_surfacePixelRatio(1.0f) |
| { |
| } |
| |
| QRenderSurfaceSelectorPrivate::~QRenderSurfaceSelectorPrivate() |
| { |
| QObject::disconnect(m_heightConn); |
| QObject::disconnect(m_widthConn); |
| QObject::disconnect(m_screenConn); |
| } |
| |
| QRenderSurfaceSelector *QRenderSurfaceSelectorPrivate::find(QObject *rootObject) |
| { |
| QFrameGraphNode *frameGraphRoot = qobject_cast<QFrameGraphNode *>(rootObject); |
| |
| if (!frameGraphRoot) { |
| auto rendererSettings = rootObject->findChild<Qt3DRender::QRenderSettings *>(); |
| if (!rendererSettings) { |
| qWarning() << "No renderer settings component found"; |
| return nullptr; |
| } |
| |
| frameGraphRoot = rendererSettings->activeFrameGraph(); |
| if (!frameGraphRoot) { |
| qWarning() << "No active frame graph found"; |
| return nullptr; |
| } |
| } |
| |
| auto surfaceSelector = qobject_cast<Qt3DRender::QRenderSurfaceSelector *>(frameGraphRoot); |
| if (!surfaceSelector) |
| surfaceSelector = frameGraphRoot->findChild<Qt3DRender::QRenderSurfaceSelector *>(); |
| |
| if (!surfaceSelector) |
| qWarning() << "No render surface selector found in frame graph"; |
| |
| return surfaceSelector; |
| } |
| |
| void QRenderSurfaceSelectorPrivate::setExternalRenderTargetSize(const QSize &size) |
| { |
| m_externalRenderTargetSize = size; |
| } |
| |
| /*! |
| Constructs QRenderSurfaceSelector with given \a parent. |
| */ |
| QRenderSurfaceSelector::QRenderSurfaceSelector(Qt3DCore::QNode *parent) |
| : Qt3DRender::QFrameGraphNode(*new QRenderSurfaceSelectorPrivate, parent) |
| { |
| } |
| |
| /*! |
| \internal |
| */ |
| QRenderSurfaceSelector::~QRenderSurfaceSelector() |
| { |
| } |
| |
| /*! |
| \internal |
| */ |
| QRenderSurfaceSelector::QRenderSurfaceSelector(QRenderSurfaceSelectorPrivate &dd, Qt3DCore::QNode *parent) |
| : Qt3DRender::QFrameGraphNode(dd, parent) |
| { |
| } |
| |
| QObject *QRenderSurfaceSelector::surface() const |
| { |
| Q_D(const QRenderSurfaceSelector); |
| QObject *surfaceObj = nullptr; |
| if (!d->m_surface) |
| return surfaceObj; |
| |
| switch (d->m_surface->surfaceClass()) { |
| case QSurface::Window: |
| surfaceObj = static_cast<QWindow *>(d->m_surface); |
| break; |
| |
| case QSurface::Offscreen: |
| surfaceObj = static_cast<QOffscreenSurface *>(d->m_surface); |
| break; |
| } |
| |
| return surfaceObj; |
| } |
| |
| /*! |
| Sets \a surfaceObject. |
| */ |
| void QRenderSurfaceSelector::setSurface(QObject *surfaceObject) |
| { |
| Q_D(QRenderSurfaceSelector); |
| QSurface *surface = nullptr; |
| if (surfaceObject) { |
| QWindow *window = qobject_cast<QWindow *>(surfaceObject); |
| if (window) { |
| surface = static_cast<QSurface *>(window); |
| } else { |
| QOffscreenSurface *offscreen = qobject_cast<QOffscreenSurface *>(surfaceObject); |
| if (offscreen) |
| surface = static_cast<QSurface *>(offscreen); |
| } |
| |
| Q_ASSERT_X(surface, Q_FUNC_INFO, "surfaceObject is not a valid QSurface object"); |
| } |
| |
| if (d->m_surface == surface) |
| return; |
| |
| if (d->m_surface && d->m_surface->surfaceClass() == QSurface::Window) { |
| QWindow *prevWindow = static_cast<QWindow *>(d->m_surface); |
| if (prevWindow) { |
| QObject::disconnect(d->m_widthConn); |
| QObject::disconnect(d->m_heightConn); |
| QObject::disconnect(d->m_screenConn); |
| } |
| } |
| d->m_surface = surface; |
| |
| // The platform surface filter only deals with QObject |
| // We assume therefore that our surface is actually a QObject underneath |
| if (d->m_surface) { |
| switch (d->m_surface->surfaceClass()) { |
| case QSurface::Window: { |
| QWindow *window = static_cast<QWindow *>(d->m_surface); |
| d->m_surfaceEventFilter->setSurface(window); |
| |
| if (window) { |
| d->m_widthConn = QObject::connect(window, &QWindow::widthChanged, [=] (int) { |
| d->update(); |
| }); |
| d->m_heightConn = QObject::connect(window, &QWindow::heightChanged, [=] (int) { |
| d->update(); |
| }); |
| d->m_screenConn = QObject::connect(window, &QWindow::screenChanged, [=] (QScreen *screen) { |
| if (screen && !qFuzzyCompare(surfacePixelRatio(), float(screen->devicePixelRatio()))) |
| setSurfacePixelRatio(float(screen->devicePixelRatio())); |
| }); |
| setSurfacePixelRatio(float(window->devicePixelRatio())); |
| } |
| |
| break; |
| } |
| case QSurface::Offscreen: { |
| d->m_surfaceEventFilter->setSurface(static_cast<QOffscreenSurface *>(d->m_surface)); |
| break; |
| } |
| |
| default: |
| Q_UNREACHABLE(); |
| break; |
| } |
| } else { |
| QWindow *nullWindow = nullptr; |
| d->m_surfaceEventFilter->setSurface(nullWindow); |
| } |
| emit surfaceChanged(surfaceObject); |
| } |
| |
| QSize QRenderSurfaceSelector::externalRenderTargetSize() const |
| { |
| Q_D(const QRenderSurfaceSelector); |
| return d->externalRenderTargetSize(); |
| } |
| |
| void QRenderSurfaceSelector::setSurfacePixelRatio(float ratio) |
| { |
| Q_D(QRenderSurfaceSelector); |
| if (qFuzzyCompare(d->m_surfacePixelRatio, ratio)) |
| return; |
| d->m_surfacePixelRatio = ratio; |
| emit surfacePixelRatioChanged(ratio); |
| } |
| |
| float QRenderSurfaceSelector::surfacePixelRatio() const |
| { |
| Q_D(const QRenderSurfaceSelector); |
| return d->m_surfacePixelRatio; |
| } |
| /*! |
| Sets render target \a size if different than underlying surface size. |
| Tells picking the correct size. |
| */ |
| void QRenderSurfaceSelector::setExternalRenderTargetSize(const QSize &size) |
| { |
| Q_D(QRenderSurfaceSelector); |
| if (size != d->m_externalRenderTargetSize) { |
| d->setExternalRenderTargetSize(size); |
| emit externalRenderTargetSizeChanged(size); |
| } |
| } |
| |
| Qt3DCore::QNodeCreatedChangeBasePtr QRenderSurfaceSelector::createNodeCreationChange() const |
| { |
| auto creationChange = QFrameGraphNodeCreatedChangePtr<QRenderSurfaceSelectorData>::create(this); |
| auto &data = creationChange->data; |
| Q_D(const QRenderSurfaceSelector); |
| data.surface = QPointer<QObject>(surface()); |
| data.externalRenderTargetSize = d->m_externalRenderTargetSize; |
| data.surfacePixelRatio = d->m_surfacePixelRatio; |
| return creationChange; |
| } |
| |
| } // namespace Qt3DRender |
| |
| QT_END_NAMESPACE |