Avoid using public API in the engine and viewer

Q3DSViewerSettings gets replaced by Q3DSViewportSettings in the
engine since dependencies to the "old" public API (runtime/api)
are not desirable.

Task-number: QT3DS-1795
Change-Id: I40224ffcf591e69fe36953fa9958513a94bcd207
Reviewed-by: Andy Nichols <andy.nichols@qt.io>

15 files changed, 272 insertions, 59 deletions

diff --git a/src/imports/studio3d/q3dsstudio3ditem.cpp b/src/imports/studio3d/q3dsstudio3ditem.cpp
index 16e1ab4..eded414 100644
--- a/src/imports/studio3d/q3dsstudio3ditem.cpp
+++ b/src/imports/studio3d/q3dsstudio3ditem.cpp
@@ -42,7 +42,7 @@
 #include <QQmlEngine>
 #include <QQmlContext>
 #include <QGuiApplication>
-#include <q3dsviewersettings.h>
+#include <private/q3dsviewersettings_p.h>
 #include <private/q3dsengine_p.h>
 #include <private/q3dsutils_p.h>
 #include <private/q3dslogging_p.h>
@@ -258,7 +258,7 @@ void Q3DSStudio3DItem::componentComplete()
             } else {
                 m_viewerSettings = viewerSettings;
                 if (m_engine)
-                    m_engine->setViewerSettings(m_viewerSettings);
+                    m_engine->setViewportSettings(Q3DSViewerSettingsPrivate::get(m_viewerSettings)->createViewportSettingsProxy());
             }
         }
     }
@@ -360,7 +360,7 @@ void Q3DSStudio3DItem::createEngine()
         }
 
         if (m_viewerSettings)
-            m_engine->setViewerSettings(m_viewerSettings);
+            m_engine->setViewportSettings(Q3DSViewerSettingsPrivate::get(m_viewerSettings)->createViewportSettingsProxy());
 
         qCDebug(lcStudio3D, "created engine %p", m_engine);
 
diff --git a/src/runtime/api/q3dssurfaceviewer.cpp b/src/runtime/api/q3dssurfaceviewer.cpp
index 09d590f..72a6cb9 100644
--- a/src/runtime/api/q3dssurfaceviewer.cpp
+++ b/src/runtime/api/q3dssurfaceviewer.cpp
@@ -506,7 +506,7 @@ bool Q3DSSurfaceViewerPrivate::createEngine()
         return false;
     }
     engine->setSurface(windowOrOffscreenSurface);
-    engine->setViewerSettings(viewerSettings);
+    engine->setViewportSettings(Q3DSViewerSettingsPrivate::get(viewerSettings)->createViewportSettingsProxy());
 
     qCDebug(lc3DSSurface, "Created engine %p", engine);
 
diff --git a/src/runtime/api/q3dssurfaceviewer_p.h b/src/runtime/api/q3dssurfaceviewer_p.h
index e9d011b..4649956 100644
--- a/src/runtime/api/q3dssurfaceviewer_p.h
+++ b/src/runtime/api/q3dssurfaceviewer_p.h
@@ -44,7 +44,7 @@
 #include <private/q3dsruntimeglobal_p.h>
 #include "q3dssurfaceviewer.h"
 #include "q3dspresentation_p.h"
-#include "q3dsviewersettings.h"
+#include "q3dsviewersettings_p.h"
 #include <private/qobject_p.h>
 #include <QUrl>
 #include <QTimer>
diff --git a/src/runtime/api/q3dsviewersettings.cpp b/src/runtime/api/q3dsviewersettings.cpp
index 7ea74d9..3d4f3fe 100644
--- a/src/runtime/api/q3dsviewersettings.cpp
+++ b/src/runtime/api/q3dsviewersettings.cpp
@@ -240,6 +240,29 @@ void Q3DSViewerSettings::load(const QString &group,
     qWarning() << Q_FUNC_INFO << "not implemented";
 }
 
+Q3DSViewportSettings *Q3DSViewerSettingsPrivate::createViewportSettingsProxy()
+{
+    Q_Q(Q3DSViewerSettings);
+    Q3DSViewportSettings *vp = new Q3DSViewportSettings(q);
+    vp->setShowRenderStats(q->isShowingRenderStats());
+    QObject::connect(q, &Q3DSViewerSettings::showRenderStatsChanged, q, [vp, q] {
+        vp->setShowRenderStats(q->isShowingRenderStats());
+    });
+    vp->setScaleMode(Q3DSViewportSettings::ScaleMode(q->scaleMode()));
+    QObject::connect(q, &Q3DSViewerSettings::scaleModeChanged, q, [vp, q] {
+        vp->setScaleMode(Q3DSViewportSettings::ScaleMode(q->scaleMode()));
+    });
+    vp->setMatteEnabled(q->matteEnabled());
+    QObject::connect(q, &Q3DSViewerSettings::matteEnabledChanged, q, [vp, q] {
+        vp->setMatteEnabled(q->matteEnabled());
+    });
+    vp->setMatteColor(q->matteColor());
+    QObject::connect(q, &Q3DSViewerSettings::matteColorChanged, q, [vp, q] {
+        vp->setMatteColor(q->matteColor());
+    });
+    return vp;
+}
+
 /*!
     \qmltype ViewerSettings
     \instantiates Q3DSViewerSettings
diff --git a/src/runtime/api/q3dsviewersettings.h b/src/runtime/api/q3dsviewersettings.h
index 044c436..7e3fb52 100644
--- a/src/runtime/api/q3dsviewersettings.h
+++ b/src/runtime/api/q3dsviewersettings.h
@@ -59,7 +59,7 @@ public:
     };
     Q_ENUM(ShadeMode)
 
-    enum ScaleMode {
+    enum ScaleMode { // must match Q3DSViewportSettings::ScaleMode
         ScaleModeFit,
         ScaleModeFill,
         ScaleModeCenter
diff --git a/src/runtime/api/q3dsviewersettings_p.h b/src/runtime/api/q3dsviewersettings_p.h
index 9255d35..d84229d 100644
--- a/src/runtime/api/q3dsviewersettings_p.h
+++ b/src/runtime/api/q3dsviewersettings_p.h
@@ -44,6 +44,7 @@
 #include <private/q3dsruntimeglobal_p.h>
 #include "q3dsviewersettings.h"
 #include <private/qobject_p.h>
+#include <private/q3dsviewportsettings_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -54,6 +55,8 @@ class Q3DSV_PRIVATE_EXPORT Q3DSViewerSettingsPrivate : public QObjectPrivate
 public:
     static Q3DSViewerSettingsPrivate *get(Q3DSViewerSettings *p) { return p->d_func(); }
 
+    Q3DSViewportSettings *createViewportSettingsProxy();
+
     bool matteEnabled = false;
     QColor matteColor = QColor(51, 51, 51);
     bool showRenderStats = false;
diff --git a/src/runtime/api/q3dswidget.cpp b/src/runtime/api/q3dswidget.cpp
index 2f7d6cd..0f59fa3 100644
--- a/src/runtime/api/q3dswidget.cpp
+++ b/src/runtime/api/q3dswidget.cpp
@@ -350,7 +350,7 @@ void Q3DSWidgetPrivate::createEngine()
     engine->setAutoToggleProfileUi(false); // up to the app to control this via the API instead
 
     engine->setSurface(q_ptr->window()->windowHandle());
-    engine->setViewerSettings(viewerSettings);
+    engine->setViewportSettings(Q3DSViewerSettingsPrivate::get(viewerSettings)->createViewportSettingsProxy());
     qCDebug(lc3DSWidget, "Created engine %p", engine);
 
     initializePresentationController(engine, presentation);
diff --git a/src/runtime/api/q3dswidget_p.h b/src/runtime/api/q3dswidget_p.h
index 7df90f7..8f3cc2d 100644
--- a/src/runtime/api/q3dswidget_p.h
+++ b/src/runtime/api/q3dswidget_p.h
@@ -44,7 +44,7 @@
 #include <private/q3dsruntimeglobal_p.h>
 #include "q3dswidget.h"
 #include "q3dspresentation_p.h"
-#include "q3dsviewersettings.h"
+#include "q3dsviewersettings_p.h"
 #include <QTimer>
 
 QT_BEGIN_NAMESPACE
diff --git a/src/runtime/q3dsengine.cpp b/src/runtime/q3dsengine.cpp
index 1a438f0..861f574 100644
--- a/src/runtime/q3dsengine.cpp
+++ b/src/runtime/q3dsengine.cpp
@@ -34,7 +34,7 @@
 #include "q3dslogging_p.h"
 #include "q3dsinputmanager_p.h"
 #include "q3dsinlineqmlsubpresentation_p.h"
-#include "q3dsviewersettings.h"
+#include "q3dsviewportsettings_p.h"
 
 #include <QLoggingCategory>
 #include <QKeyEvent>
@@ -162,7 +162,7 @@ Q3DSEngine::Q3DSEngine()
         // same for q3ds.input
         const_cast<QLoggingCategory &>(lcInput()).setEnabled(QtDebugMsg, logValueChanges);
     }
-    setViewerSettings(new Q3DSViewerSettings(this));
+    setViewportSettings(new Q3DSViewportSettings(this));
 }
 
 Q3DSEngine::~Q3DSEngine()
@@ -784,8 +784,8 @@ bool Q3DSEngine::buildUipPresentationScene(UipPresentation *pres)
     pres->sceneManager->updateSizes(effectiveSize, effectiveDpr, params.viewport);
 
     // Set matte preferences
-    pres->sceneManager->setMatteEnabled(m_viewerSettings->matteEnabled());
-    pres->sceneManager->setMatteColor(m_viewerSettings->matteColor());
+    pres->sceneManager->setMatteEnabled(m_viewportSettings->matteEnabled());
+    pres->sceneManager->setMatteColor(m_viewportSettings->matteColor());
 
     // Expose update signal
     connect(pres->q3dscene.frameAction, &Qt3DLogic::QFrameAction::triggered, this, [this](float dt) {
@@ -1197,32 +1197,32 @@ Qt3DCore::QEntity *Q3DSEngine::rootEntity() const
     return m_uipPresentations.isEmpty() ? nullptr : m_uipPresentations[0].q3dscene.rootEntity;
 }
 
-Q3DSViewerSettings *Q3DSEngine::viewerSettings() const
+Q3DSViewportSettings *Q3DSEngine::viewportSettings() const
 {
-    return m_viewerSettings;
+    return m_viewportSettings;
 }
 
-void Q3DSEngine::setViewerSettings(Q3DSViewerSettings *viewerSettings)
+void Q3DSEngine::setViewportSettings(Q3DSViewportSettings *viewportSettings)
 {
-    if (m_viewerSettings == viewerSettings)
+    if (m_viewportSettings == viewportSettings)
         return;
 
-    m_viewerSettings = viewerSettings;
-    connect(m_viewerSettings, &Q3DSViewerSettings::showRenderStatsChanged, [this] {
-        setProfileUiVisible(m_viewerSettings->isShowingRenderStats());
+    m_viewportSettings = viewportSettings;
+    connect(m_viewportSettings, &Q3DSViewportSettings::showRenderStatsChanged, [this] {
+        setProfileUiVisible(m_viewportSettings->isShowingRenderStats());
     });
-    connect(m_viewerSettings, &Q3DSViewerSettings::scaleModeChanged, [this] {
+    connect(m_viewportSettings, &Q3DSViewportSettings::scaleModeChanged, [this] {
         // Force a resize
         resize(m_size, m_dpr);
     });
-    connect(m_viewerSettings, &Q3DSViewerSettings::matteEnabledChanged, [this] {
+    connect(m_viewportSettings, &Q3DSViewportSettings::matteEnabledChanged, [this] {
         if (!m_uipPresentations.isEmpty()) {
-            m_uipPresentations[0].sceneManager->setMatteEnabled(m_viewerSettings->matteEnabled());
+            m_uipPresentations[0].sceneManager->setMatteEnabled(m_viewportSettings->matteEnabled());
         }
     });
-    connect(m_viewerSettings, &Q3DSViewerSettings::matteColorChanged, [this] {
+    connect(m_viewportSettings, &Q3DSViewportSettings::matteColorChanged, [this] {
         if (!m_uipPresentations.isEmpty()) {
-            m_uipPresentations[0].sceneManager->setMatteColor(m_viewerSettings->matteColor());
+            m_uipPresentations[0].sceneManager->setMatteColor(m_viewportSettings->matteColor());
         }
     });
 }
@@ -1691,7 +1691,7 @@ void Q3DSEngine::behaviorFrameUpdate(float dt)
 QRect Q3DSEngine::calculateViewport(const QSize &surfaceSize, const QSize &presentationSize) const
 {
     // The top level persentations viewport depends on the scale mode of
-    // the Q3DSViewerSettings. The method returns the viewport rect based
+    // the Q3DSViewportSettings. The method returns the viewport rect based
     // on the current surface size and scale mode.
 
     // We need to have the presentation size
@@ -1699,10 +1699,10 @@ QRect Q3DSEngine::calculateViewport(const QSize &surfaceSize, const QSize &prese
         return QRect();
 
     QRect viewportRect;
-    if (m_viewerSettings->scaleMode() == Q3DSViewerSettings::ScaleModeFill) {
+    if (m_viewportSettings->scaleMode() == Q3DSViewportSettings::ScaleModeFill) {
         // the presentation is always rendered to fill the viewport
         viewportRect = QRect(0, 0, surfaceSize.width(), surfaceSize.height());
-    } else if (m_viewerSettings->scaleMode() == Q3DSViewerSettings::ScaleModeCenter) {
+    } else if (m_viewportSettings->scaleMode() == Q3DSViewportSettings::ScaleModeCenter) {
         // the presentation is rendered at the size specified in Studio. Additional content is cropped,
         // additional space is letterboxed.
         const qreal presHorizontalCenter = presentationSize.width() * 0.5;
@@ -1712,7 +1712,7 @@ QRect Q3DSEngine::calculateViewport(const QSize &surfaceSize, const QSize &prese
         const qreal x = surfaceHorizontalCenter - presHorizontalCenter;
         const qreal y = surfaceVerticalCenter - presVerticalCenter;
         viewportRect = QRect(qFloor(x), qFloor(y), presentationSize.width(), presentationSize.height());
-    } else if (m_viewerSettings->scaleMode() == Q3DSViewerSettings::ScaleModeFit) {
+    } else if (m_viewportSettings->scaleMode() == Q3DSViewportSettings::ScaleModeFit) {
         // the aspect ratio of the presentation is preserved, letterboxing as needed.
         const qreal presentationAspectRatio = qreal(presentationSize.width()) / qreal(presentationSize.height());
         const qreal surfaceAspectRatio = qreal(surfaceSize.width()) / qreal(surfaceSize.height());
diff --git a/src/runtime/q3dsengine_p.h b/src/runtime/q3dsengine_p.h
index 2a602b9..cb84f55 100644
--- a/src/runtime/q3dsengine_p.h
+++ b/src/runtime/q3dsengine_p.h
@@ -61,7 +61,7 @@ class QTabletEvent;
 class QQmlEngine;
 class QQmlComponent;
 class Q3DSInlineQmlSubPresentation;
-class Q3DSViewerSettings;
+class Q3DSViewportSettings;
 
 namespace Qt3DRender {
 class QRenderCapture;
@@ -135,8 +135,8 @@ public:
     Qt3DCore::QAspectEngine *aspectEngine() const;
     Qt3DCore::QEntity *rootEntity() const;
 
-    Q3DSViewerSettings *viewerSettings() const;
-    void setViewerSettings(Q3DSViewerSettings *viewerSettings);
+    Q3DSViewportSettings *viewportSettings() const;
+    void setViewportSettings(Q3DSViewportSettings *viewportSettings);
 
     void setOnDemandRendering(bool enabled);
 
@@ -284,7 +284,7 @@ private:
     BehaviorMap m_behaviorHandles;
 
     bool m_onDemandRendering = false;
-    Q3DSViewerSettings *m_viewerSettings = nullptr;
+    Q3DSViewportSettings *m_viewportSettings = nullptr;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Q3DSEngine::Flags)
diff --git a/src/runtime/q3dsviewportsettings.cpp b/src/runtime/q3dsviewportsettings.cpp
new file mode 100644
index 0000000..3f45448
--- /dev/null
+++ b/src/runtime/q3dsviewportsettings.cpp
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt 3D Studio.
+**
+** $QT_BEGIN_LICENSE:GPL$
+** 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 General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 or (at your option) 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.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-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "q3dsviewportsettings_p.h"
+
+QT_BEGIN_NAMESPACE
+
+Q3DSViewportSettings::Q3DSViewportSettings(QObject *parent)
+    : QObject(parent)
+{
+}
+
+bool Q3DSViewportSettings::matteEnabled() const
+{
+    return m_matteEnabled;
+}
+
+QColor Q3DSViewportSettings::matteColor() const
+{
+    return m_matteColor;
+}
+
+bool Q3DSViewportSettings::isShowingRenderStats() const
+{
+    return m_showRenderStats;
+}
+
+Q3DSViewportSettings::ScaleMode Q3DSViewportSettings::scaleMode() const
+{
+    return m_scaleMode;
+}
+
+void Q3DSViewportSettings::setMatteEnabled(bool isEnabled)
+{
+    if (m_matteEnabled != isEnabled) {
+        m_matteEnabled = isEnabled;
+        emit matteEnabledChanged();
+    }
+}
+
+void Q3DSViewportSettings::setMatteColor(const QColor &color)
+{
+    if (m_matteColor != color) {
+        m_matteColor = color;
+        emit matteColorChanged();
+    }
+}
+
+void Q3DSViewportSettings::setShowRenderStats(bool show)
+{
+    if (m_showRenderStats != show) {
+        m_showRenderStats = show;
+        emit showRenderStatsChanged();
+    }
+}
+
+void Q3DSViewportSettings::setScaleMode(Q3DSViewportSettings::ScaleMode mode)
+{
+    if (m_scaleMode != mode) {
+        m_scaleMode = mode;
+        emit scaleModeChanged();
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/runtime/q3dsviewportsettings_p.h b/src/runtime/q3dsviewportsettings_p.h
new file mode 100644
index 0000000..93d3e33
--- /dev/null
+++ b/src/runtime/q3dsviewportsettings_p.h
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt 3D Studio.
+**
+** $QT_BEGIN_LICENSE:GPL$
+** 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 General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 or (at your option) 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.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-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q3DSVIEWPORTSETTINGS_P_H
+#define Q3DSVIEWPORTSETTINGS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "q3dsruntimeglobal_p.h"
+#include <QObject>
+#include <QColor>
+
+QT_BEGIN_NAMESPACE
+
+class Q3DSV_PRIVATE_EXPORT Q3DSViewportSettings : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool matteEnabled READ matteEnabled WRITE setMatteEnabled NOTIFY matteEnabledChanged)
+    Q_PROPERTY(QColor matteColor READ matteColor WRITE setMatteColor NOTIFY matteColorChanged)
+    Q_PROPERTY(bool showRenderStats READ isShowingRenderStats WRITE setShowRenderStats NOTIFY showRenderStatsChanged)
+    Q_PROPERTY(ScaleMode scaleMode READ scaleMode WRITE setScaleMode NOTIFY scaleModeChanged)
+
+public:
+    enum ScaleMode {
+        ScaleModeFit,
+        ScaleModeFill,
+        ScaleModeCenter
+    };
+    Q_ENUM(ScaleMode)
+
+    explicit Q3DSViewportSettings(QObject *parent = nullptr);
+
+    bool matteEnabled() const;
+    QColor matteColor() const;
+    bool isShowingRenderStats() const;
+    ScaleMode scaleMode() const;
+
+public Q_SLOTS:
+    void setMatteEnabled(bool isEnabled);
+    void setMatteColor(const QColor &color);
+    void setShowRenderStats(bool show);
+    void setScaleMode(ScaleMode mode);
+
+Q_SIGNALS:
+    void matteEnabledChanged();
+    void matteColorChanged();
+    void showRenderStatsChanged();
+    void scaleModeChanged();
+
+private:
+    Q_DISABLE_COPY(Q3DSViewportSettings)
+
+    bool m_matteEnabled = false;
+    QColor m_matteColor = QColor(51, 51, 51);
+    bool m_showRenderStats = false;
+    Q3DSViewportSettings::ScaleMode m_scaleMode = ScaleModeFill;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/runtime/runtime.pro b/src/runtime/runtime.pro
index 8a0c957..cdc828d 100644
--- a/src/runtime/runtime.pro
+++ b/src/runtime/runtime.pro
@@ -35,7 +35,8 @@ SOURCES += \
     q3dsinputmanager.cpp \
     q3dsconsolecommands.cpp \
     q3dsinlineqmlsubpresentation.cpp \
-    q3dslogging.cpp
+    q3dslogging.cpp \
+    q3dsviewportsettings.cpp
 
 HEADERS += \
     q3dsruntimeglobal.h \
@@ -75,7 +76,8 @@ HEADERS += \
     q3dsinputmanager_p.h \
     q3dsconsolecommands_p.h \
     q3dsinlineqmlsubpresentation_p.h \
-    q3dslogging_p.h
+    q3dslogging_p.h \
+    q3dsviewportsettings_p.h
 
 qtHaveModule(widgets) {
     QT += widgets
diff --git a/tools/q3dsviewer/main.cpp b/tools/q3dsviewer/main.cpp
index ed94de4..e96c036 100644
--- a/tools/q3dsviewer/main.cpp
+++ b/tools/q3dsviewer/main.cpp
@@ -43,8 +43,7 @@
 #include <private/q3dsengine_p.h>
 #include <private/q3dswindow_p.h>
 #include <private/q3dsutils_p.h>
-
-#include <Qt3DStudioRuntime2/Q3DSViewerSettings>
+#include <private/q3dsviewportsettings_p.h>
 
 QT_BEGIN_NAMESPACE
 class Q3DStudioMainWindow;
@@ -140,23 +139,22 @@ int main(int argc, char *argv[])
             return 0;
     }
 
-    // Setup Viewer Settings
-    Q3DSViewerSettings *viewerSettings = new Q3DSViewerSettings;
-    engine->setViewerSettings(viewerSettings);
-    viewerSettings->setMatteEnabled(true);
-    viewerSettings->setScaleMode(Q3DSViewerSettings::ScaleModeCenter);
+    // Setup Viewport Settings
+    Q3DSViewportSettings *viewportSettings = new Q3DSViewportSettings;
+    engine->setViewportSettings(viewportSettings);
+    viewportSettings->setMatteEnabled(true);
+    viewportSettings->setScaleMode(Q3DSViewportSettings::ScaleModeCenter);
     if (cmdLineParser.isSet(scaleModeOption)) {
         const QString scaleMode = cmdLineParser.value(scaleModeOption);
         if (scaleMode == QStringLiteral("center"))
-            viewerSettings->setScaleMode(Q3DSViewerSettings::ScaleModeCenter);
+            viewportSettings->setScaleMode(Q3DSViewportSettings::ScaleModeCenter);
         else if (scaleMode == QStringLiteral("fit"))
-            viewerSettings->setScaleMode(Q3DSViewerSettings::ScaleModeFit);
+            viewportSettings->setScaleMode(Q3DSViewportSettings::ScaleModeFit);
         else
-            viewerSettings->setScaleMode(Q3DSViewerSettings::ScaleModeFill);
-    }
-    if (cmdLineParser.isSet(matteColorOption)) {
-        viewerSettings->setMatteColor(cmdLineParser.value(matteColorOption));
+            viewportSettings->setScaleMode(Q3DSViewportSettings::ScaleModeFill);
     }
+    if (cmdLineParser.isSet(matteColorOption))
+        viewportSettings->setMatteColor(cmdLineParser.value(matteColorOption));
 
 #ifdef Q3DSVIEWER_WIDGETS
     Q3DStudioMainWindow *mw = nullptr;
diff --git a/tools/q3dsviewer/q3dsmainwindow.cpp b/tools/q3dsviewer/q3dsmainwindow.cpp
index 3c68f33..7283c43 100644
--- a/tools/q3dsviewer/q3dsmainwindow.cpp
+++ b/tools/q3dsviewer/q3dsmainwindow.cpp
@@ -34,7 +34,7 @@
 #include <private/q3dsengine_p.h>
 #include <private/q3dsutils_p.h>
 #include <private/q3dsslideplayer_p.h>
-#include <Qt3DStudioRuntime2/Q3DSViewerSettings>
+#include <private/q3dsviewportsettings_p.h>
 #include <QApplication>
 #include <QMenuBar>
 #include <QMenu>
@@ -134,10 +134,10 @@ Q3DStudioMainWindow::Q3DStudioMainWindow(Q3DSWindow *view, Q3DSRemoteDeploymentM
     QAction *showMatte = viewMenu->addAction(tr("Show Matte"));
     addAction(showMatte);
     showMatte->setCheckable(true);
-    showMatte->setChecked(view->engine()->viewerSettings()->matteEnabled());
+    showMatte->setChecked(view->engine()->viewportSettings()->matteEnabled());
     showMatte->setShortcut(QKeySequence(tr("Ctrl+D")));
     connect(showMatte, &QAction::toggled, [=]() {
-        view->engine()->viewerSettings()->setMatteEnabled(showMatte->isChecked());
+        view->engine()->viewportSettings()->setMatteEnabled(showMatte->isChecked());
     });
     QAction *scaleModeAction = new QAction(tr("Scale Mode"));
     addAction(scaleModeAction);
@@ -146,33 +146,33 @@ Q3DStudioMainWindow::Q3DStudioMainWindow(Q3DSWindow *view, Q3DSRemoteDeploymentM
     scaleModeAction->setMenu(scaleModeMenu);
     QAction *scaleModeCenter = new QAction(tr("Center"));
     scaleModeCenter->setCheckable(true);
-    scaleModeCenter->setChecked(view->engine()->viewerSettings()->scaleMode() == Q3DSViewerSettings::ScaleModeCenter);
+    scaleModeCenter->setChecked(view->engine()->viewportSettings()->scaleMode() == Q3DSViewportSettings::ScaleModeCenter);
     scaleModeMenu->addAction(scaleModeCenter);
 
     QAction *scaleModeFit = new QAction(tr("Scale to Fit"));
     scaleModeFit->setCheckable(true);
-    scaleModeFit->setChecked(view->engine()->viewerSettings()->scaleMode() == Q3DSViewerSettings::ScaleModeFit);
+    scaleModeFit->setChecked(view->engine()->viewportSettings()->scaleMode() == Q3DSViewportSettings::ScaleModeFit);
     scaleModeMenu->addAction(scaleModeFit);
 
     QAction *scaleModeFill = new QAction(tr("Scale to Fill"));
     scaleModeFill->setCheckable(true);
-    scaleModeFill->setChecked(view->engine()->viewerSettings()->scaleMode() == Q3DSViewerSettings::ScaleModeFill);
+    scaleModeFill->setChecked(view->engine()->viewportSettings()->scaleMode() == Q3DSViewportSettings::ScaleModeFill);
     scaleModeMenu->addAction(scaleModeFill);
 
     connect(scaleModeFit, &QAction::triggered, [=]() {
-        view->engine()->viewerSettings()->setScaleMode(Q3DSViewerSettings::ScaleModeFit);
+        view->engine()->viewportSettings()->setScaleMode(Q3DSViewportSettings::ScaleModeFit);
         scaleModeCenter->setChecked(false);
         scaleModeFill->setChecked(false);
         scaleModeFit->setChecked(true);
     });
     connect(scaleModeCenter, &QAction::triggered, [=]() {
-        view->engine()->viewerSettings()->setScaleMode(Q3DSViewerSettings::ScaleModeCenter);
+        view->engine()->viewportSettings()->setScaleMode(Q3DSViewportSettings::ScaleModeCenter);
         scaleModeCenter->setChecked(true);
         scaleModeFill->setChecked(false);
         scaleModeFit->setChecked(false);
     });
     connect(scaleModeFill, &QAction::triggered, [=]() {
-        view->engine()->viewerSettings()->setScaleMode(Q3DSViewerSettings::ScaleModeFill);
+        view->engine()->viewportSettings()->setScaleMode(Q3DSViewportSettings::ScaleModeFill);
         scaleModeCenter->setChecked(false);
         scaleModeFill->setChecked(true);
         scaleModeFit->setChecked(false);
@@ -182,15 +182,15 @@ Q3DStudioMainWindow::Q3DStudioMainWindow(Q3DSWindow *view, Q3DSRemoteDeploymentM
         if (scaleModeCenter->isChecked()) {
             scaleModeCenter->setChecked(false);
             scaleModeFit->setChecked(true);
-            view->engine()->viewerSettings()->setScaleMode(Q3DSViewerSettings::ScaleModeFit);
+            view->engine()->viewportSettings()->setScaleMode(Q3DSViewportSettings::ScaleModeFit);
         } else if (scaleModeFit->isChecked()) {
             scaleModeFit->setChecked(false);
             scaleModeFill->setChecked(true);
-            view->engine()->viewerSettings()->setScaleMode(Q3DSViewerSettings::ScaleModeFill);
+            view->engine()->viewportSettings()->setScaleMode(Q3DSViewportSettings::ScaleModeFill);
         } else {
             scaleModeFill->setChecked(false);
             scaleModeCenter->setChecked(true);
-            view->engine()->viewerSettings()->setScaleMode(Q3DSViewerSettings::ScaleModeCenter);
+            view->engine()->viewportSettings()->setScaleMode(Q3DSViewportSettings::ScaleModeCenter);
         }
     });