Refactor: Extract the code for adding a texture

Task-number: QDS-8344
Change-Id: I433e2beb3ffd6346ea37e093705943b0701efd3d
Reviewed-by: Mahmoud Badri <mahmoud.badri@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@qt.io>

src/plugins/qmldesigner/CMakeLists.txt

@@ -588,7 +588,7 @@ extend_qtc_plugin(QmlDesigner
   PUBLIC_INCLUDES components
   DEFINES QMLDESIGNERCOMPONENTS_LIBRARY
   SOURCES
-    addtexture.h
+    createtexture.cpp createtexture.h
     qmldesignercomponents_global.h
 )
 

src/plugins/qmldesigner/components/addtexture.h

@@ -1,10 +0,0 @@
-// Copyright (C) 2022 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
-
-#pragma once
-
-namespace QmlDesigner {
-
-enum class AddTextureMode { Image, Texture, LightProbe };
-
-} // namespace QmlDesigner

src/plugins/qmldesigner/components/assetslibrary/assetslibraryview.cpp

@@ -4,7 +4,9 @@
 #include "assetslibraryview.h"
 
 #include "assetslibrarywidget.h"
+#include "createtexture.h"
 #include "qmldesignerplugin.h"
+
 #include <asynchronousimagecache.h>
 #include <bindingproperty.h>
 #include <coreplugin/icore.h>
@@ -44,6 +46,7 @@ public:
 
 AssetsLibraryView::AssetsLibraryView(ExternalDependenciesInterface &externalDependencies)
     : AbstractView{externalDependencies}
+    , m_createTextures{this, false}
 {}
 
 AssetsLibraryView::~AssetsLibraryView()
@@ -62,9 +65,9 @@ WidgetInfo AssetsLibraryView::widgetInfo()
 
         connect(m_widget, &AssetsLibraryWidget::addTexturesRequested, this,
         [&] (const QStringList &filePaths, AddTextureMode mode) {
-            // to MaterialBrowserView
+            executeInTransaction("AssetsLibraryView::widgetInfo", [&]() {
-            emitCustomNotification("add_textures", {}, {"AssetsLibraryView::widgetInfo",
+                m_createTextures.execute(filePaths, mode, m_sceneId);
-                                                        filePaths, QVariant::fromValue(mode), false});
+            });
         });
     }
 
@@ -111,4 +114,9 @@ AssetsLibraryView::ImageCacheData *AssetsLibraryView::imageCacheData()
     return m_imageCacheData.get();
 }
 
+void AssetsLibraryView::active3DSceneChanged(qint32 sceneId)
+{
+    m_sceneId = sceneId;
+}
+
 } // namespace QmlDesigner

src/plugins/qmldesigner/components/assetslibrary/assetslibraryview.h

@@ -3,7 +3,8 @@
 
 #pragma once
 
-#include <abstractview.h>
+#include "abstractview.h"
+#include "createtexture.h"
 
 #include <QPointer>
 
@@ -30,6 +31,7 @@ public:
     void modelAboutToBeDetached(Model *model) override;
 
     void setResourcePath(const QString &resourcePath);
+    void active3DSceneChanged(qint32 sceneId) override;
 
 private:
     class ImageCacheData;
@@ -39,6 +41,8 @@ private:
     std::unique_ptr<ImageCacheData> m_imageCacheData;
     QPointer<AssetsLibraryWidget> m_widget;
     QString m_lastResourcePath;
+    CreateTextures m_createTextures;
+    qint32 m_sceneId = -1;
 };
 
 }

src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.h

@@ -4,8 +4,9 @@
 #pragma once
 
 #include <previewtooltip/previewtooltipbackend.h>
-#include "addtexture.h"
+
 #include "assetslibrarymodel.h"
+#include "createtexture.h"
 
 #include <QFileIconProvider>
 #include <QFrame>

src/plugins/qmldesigner/components/contentlibrary/contentlibraryview.cpp

@@ -4,12 +4,11 @@
 #include "contentlibraryview.h"
 
 #include "contentlibrarybundleimporter.h"
-#include "contentlibrarywidget.h"
 #include "contentlibrarymaterial.h"
 #include "contentlibrarymaterialsmodel.h"
 #include "contentlibrarytexture.h"
 #include "contentlibrarytexturesmodel.h"
-#include "modelnodeoperations.h"
+#include "contentlibrarywidget.h"
 #include "nodelistproperty.h"
 #include "qmldesignerconstants.h"
 #include "qmlobjectnode.h"
@@ -31,6 +30,7 @@ namespace QmlDesigner {
 
 ContentLibraryView::ContentLibraryView(ExternalDependenciesInterface &externalDependencies)
     : AbstractView(externalDependencies)
+    , m_createTexture(this, true)
 {}
 
 ContentLibraryView::~ContentLibraryView()
@@ -54,14 +54,20 @@ WidgetInfo ContentLibraryView::widgetInfo()
                 [&] (QmlDesigner::ContentLibraryTexture *tex) {
             m_draggedBundleTexture = tex;
         });
+
         connect(m_widget, &ContentLibraryWidget::addTextureRequested, this,
                 [&] (const QString &texPath, AddTextureMode mode) {
-            emitCustomNotification("add_texture", {}, {"ContentLibraryView::widgetInfo",
+            executeInTransaction("ContentLibraryView::widgetInfo", [&]() {
-                                                       texPath, QVariant::fromValue(mode), true});
+                m_createTexture.execute(texPath, mode, m_sceneId);
+            });
         });
 
-        connect(m_widget, &ContentLibraryWidget::updateSceneEnvStateRequested,
+        connect(m_widget, &ContentLibraryWidget::updateSceneEnvStateRequested, this, [&]() {
-                this, &ContentLibraryView::resolveSceneEnv);
+            ModelNode activeSceneEnv = m_createTexture.resolveSceneEnv(m_sceneId);
+            const bool sceneEnvExists = activeSceneEnv.isValid();
+            m_widget->texturesModel()->setHasSceneEnv(sceneEnvExists);
+            m_widget->environmentsModel()->setHasSceneEnv(sceneEnvExists);
+        });
 
         ContentLibraryMaterialsModel *materialsModel = m_widget->materialsModel().data();
 
@@ -318,33 +324,6 @@ ModelNode ContentLibraryView::createMaterial(const NodeMetaInfo &metaInfo)
     return newMatNode;
 }
 
-ModelNode ContentLibraryView::resolveSceneEnv()
-{
-    ModelNode activeSceneEnv;
-
-    if (m_sceneId != -1) {
-        ModelNode activeScene = active3DSceneNode();
-        if (activeScene.isValid()) {
-            QmlObjectNode view3D;
-            if (activeScene.metaInfo().isQtQuick3DView3D()) {
-                view3D = activeScene;
-            } else {
-                ModelNode sceneParent = activeScene.parentProperty().parentModelNode();
-                if (sceneParent.metaInfo().isQtQuick3DView3D())
-                    view3D = sceneParent;
-            }
-            if (view3D.isValid())
-                activeSceneEnv = modelNodeForId(view3D.expression("environment"));
-        }
-    }
-
-    const bool sceneEnvExists = activeSceneEnv.isValid();
-    m_widget->texturesModel()->setHasSceneEnv(sceneEnvExists);
-    m_widget->environmentsModel()->setHasSceneEnv(sceneEnvExists);
-
-    return activeSceneEnv;
-}
-
 void ContentLibraryView::updateBundleMaterialsImportedState()
 {
     using namespace Utils;

src/plugins/qmldesigner/components/contentlibrary/contentlibraryview.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "createtexture.h"
 #include "abstractview.h"
 #include "nodemetainfo.h"
 
@@ -47,7 +48,6 @@ private:
     void applyBundleMaterialToDropTarget(const ModelNode &bundleMat, const NodeMetaInfo &metaInfo = {});
     ModelNode getBundleMaterialDefaultInstance(const TypeName &type);
     ModelNode createMaterial(const NodeMetaInfo &metaInfo);
-    ModelNode resolveSceneEnv();
 
     QPointer<ContentLibraryWidget> m_widget;
     QList<ModelNode> m_bundleMaterialTargets;
@@ -57,6 +57,7 @@ private:
     bool m_bundleMaterialAddToSelected = false;
     bool m_hasQuick3DImport = false;
     qint32 m_sceneId = -1;
+    CreateTexture m_createTexture;
 };
 
 } // namespace QmlDesigner

src/plugins/qmldesigner/components/contentlibrary/contentlibrarywidget.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include "addtexture.h"
+#include "createtexture.h"
 
 #include <QFrame>
 #include <QPointer>

src/plugins/qmldesigner/components/createtexture.cpp

@@ -0,0 +1,116 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+
+#include "createtexture.h"
+
+#include "abstractview.h"
+#include "modelnodeoperations.h"
+#include "nodelistproperty.h"
+#include "nodemetainfo.h"
+#include "qmlobjectnode.h"
+#include "variantproperty.h"
+
+#include <coreplugin/messagebox.h>
+
+#include <QTimer>
+
+namespace QmlDesigner {
+
+CreateTexture::CreateTexture(AbstractView *view, bool importFile)
+    : m_view{view}
+    , m_importFile{importFile}
+{}
+
+void CreateTexture::execute(const QString &filePath, AddTextureMode mode, int sceneId)
+{
+    if (m_importFile && !addFileToProject(filePath))
+        return;
+
+    ModelNode texture = createTextureFromImage(filePath, mode);
+    if (!texture.isValid())
+        return;
+
+    if (mode == AddTextureMode::LightProbe && sceneId != -1)
+        assignTextureAsLightProbe(texture, sceneId);
+
+    QTimer::singleShot(0, m_view, [this, texture]() {
+        if (m_view->model())
+            m_view->emitCustomNotification("selected_texture_changed", {texture});
+    });
+}
+
+bool CreateTexture::addFileToProject(const QString &filePath)
+{
+    AddFilesResult result = ModelNodeOperations::addImageToProject({filePath}, "images", false);
+
+    if (result.status() == AddFilesResult::Failed) {
+        Core::AsynchronousMessageBox::warning(QObject::tr("Failed to Add Texture"),
+                                              QObject::tr("Could not add %1 to project.").arg(filePath));
+        return false;
+    }
+
+    return true;
+}
+
+ModelNode CreateTexture::createTextureFromImage(const QString &assetPath, AddTextureMode mode)
+{
+    if (mode != AddTextureMode::Texture && mode != AddTextureMode::LightProbe)
+        return {};
+
+    ModelNode matLib = m_view->materialLibraryNode();
+    if (!matLib.isValid())
+        return {};
+
+    NodeMetaInfo metaInfo = m_view->model()->qtQuick3DTextureMetaInfo();
+
+    QString sourceVal = QLatin1String("images/%1").arg(assetPath.split('/').last());
+    ModelNode newTexNode = m_view->getTextureDefaultInstance(sourceVal);
+    if (!newTexNode.isValid()) {
+        newTexNode = m_view->createModelNode("QtQuick3D.Texture",
+                                            metaInfo.majorVersion(),
+                                            metaInfo.minorVersion());
+        newTexNode.validId();
+        VariantProperty sourceProp = newTexNode.variantProperty("source");
+        sourceProp.setValue(sourceVal);
+        matLib.defaultNodeListProperty().reparentHere(newTexNode);
+    }
+
+    return newTexNode;
+}
+
+void CreateTexture::assignTextureAsLightProbe(const ModelNode &texture, int sceneId)
+{
+    ModelNode sceneEnvNode = resolveSceneEnv(sceneId);
+    QmlObjectNode sceneEnv = sceneEnvNode;
+    if (sceneEnv.isValid()) {
+        sceneEnv.setBindingProperty("lightProbe", texture.id());
+        sceneEnv.setVariantProperty("backgroundMode",
+                                    QVariant::fromValue(Enumeration("SceneEnvironment",
+                                                                    "SkyBox")));
+    }
+}
+
+ModelNode CreateTexture::resolveSceneEnv(int sceneId)
+{
+    ModelNode activeSceneEnv;
+
+    if (sceneId != -1) {
+        ModelNode activeScene = m_view->active3DSceneNode();
+        if (activeScene.isValid()) {
+            QmlObjectNode view3D;
+            if (activeScene.metaInfo().isQtQuick3DView3D()) {
+                view3D = activeScene;
+            } else {
+                ModelNode sceneParent = activeScene.parentProperty().parentModelNode();
+                if (sceneParent.metaInfo().isQtQuick3DView3D())
+                    view3D = sceneParent;
+            }
+            if (view3D.isValid())
+                activeSceneEnv = m_view->modelNodeForId(view3D.expression("environment"));
+        }
+    }
+
+    return activeSceneEnv;
+}
+
+} // namespace QmlDesigner

src/plugins/qmldesigner/components/createtexture.h

@@ -0,0 +1,43 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+
+#pragma once
+
+#include <modelnode.h>
+
+namespace QmlDesigner {
+
+class AbstractView;
+
+enum class AddTextureMode { Image, Texture, LightProbe };
+
+class CreateTexture
+{
+public:
+    CreateTexture(AbstractView *view, bool importFiles = false);
+    void execute(const QString &filePath, AddTextureMode mode, int sceneId);
+    ModelNode resolveSceneEnv(int sceneId);
+
+private:
+    bool addFileToProject(const QString &filePath);
+    ModelNode createTextureFromImage(const QString &assetPath, AddTextureMode mode);
+
+    void assignTextureAsLightProbe(const ModelNode &texture, int sceneId);
+
+private:
+    AbstractView *m_view = nullptr;
+    bool m_importFile = false;
+};
+
+class CreateTextures : public CreateTexture
+{
+public:
+    using CreateTexture::CreateTexture;
+    void execute(const QStringList &filePaths, AddTextureMode mode, int sceneId)
+    {
+        for (const QString &path : filePaths)
+            CreateTexture::execute(path, mode, sceneId);
+    }
+};
+
+}

src/plugins/qmldesigner/components/materialbrowser/materialbrowserview.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include "abstractview.h"
-#include "addtexture.h"
+#include "createtexture.h"
 
 #include <QPointer>
 #include <QSet>