Material: Material editor enhancements

Continues the work of the material subsystem improvements. This merge covers the continued development of the material editor. The primary improvements are the addition of new data types, a new appearance preview UI, and changes in the array data types. New data types were added to support more advanced workflows, such as the Render Workbench.The Image datatype allows the material to embed the image in the card instead of pointing to an image in an external file. Multi-buyte strings span multiple lines as the name implies. It preserves formatting accross those lines. Also several list types are now supported, with the primary difference being the editors. List is a list of strings, FileList is a list of file path names, and ImageList is a list of embedded images. For the appearance preview, the UI now uses the same Coin library as is used in the documents, meaning the preview will look exactly the same as the material will be shown in the documents. The array data types are now more complete. The default value wasn't being used as originially envisioned and was tehrefore removed. For 3D arrays, the Python API was implemented. There were a lot of code clean ups. This involved removing logging statements used for debugging during development, reduction of lint warnings, and code refactoring. The editor can automatically convert from previous format files to the current format. This has been extended to material files generated by the Render WB. Old format files are displayed in the editor with a warning icon. Selecting one will require saving the file in the new format before it can be used.
2023-12-03 13:22:43 -05:00
parent 008fc3297a
commit 09f67f2f6b
72 changed files with 4248 additions and 1334 deletions
--- a/src/Mod/Material/App/MaterialConfigLoader.cpp
+++ b/src/Mod/Material/App/MaterialConfigLoader.cpp
@@ -26,6 +26,11 @@
 #include <QString>
 #endif

+#include <memory>
+
+#include <QFile>
+#include <QIODevice>
+#include <QTextStream>
 #include <QUuid>

 #include <App/Application.h>
@@ -33,6 +38,7 @@
 #include <fstream>


+#include "Exceptions.h"
 #include "MaterialConfigLoader.h"
 #include "MaterialLoader.h"
 #include "Model.h"
@@ -41,27 +47,117 @@

 using namespace Materials;

-MaterialConfigLoader::MaterialConfigLoader()
-{}
-
 bool MaterialConfigLoader::isConfigStyle(const QString& path)
 {
-    std::ifstream infile(path.toStdString());
+    QSettings fcmat(path, QSettings::IniFormat);

-    // Check the first 2 lines for a ";"
-    for (int i = 0; i < 2; i++) {
-        std::string line;
-        if (!std::getline(infile, line)) {
-            return false;
-        }
-        if (line.at(0) != ';') {
-            return false;
-        }
+    // No [sections] means not .ini
+    if (fcmat.childGroups().empty()) {
+        return false;
    }

+    // Sometimes arrays can create a false positive
+    QFile infile(path);
+    if (infile.open(QIODevice::ReadOnly)) {
+        QTextStream in(&infile);
+
+        if (!in.atEnd()) {
+            auto line = in.readLine();
+            if (line.trimmed().startsWith(QLatin1Char('-'))
+                || line.trimmed().startsWith(QLatin1Char('#'))) {
+                // Definitely a YAML file
+                return false;
+            }
+        }
+    }
+    infile.close();
+
+    // No false positive
    return true;
 }

+bool MaterialConfigLoader::readFile(const QString& path, QMap<QString, QString>& map)
+{
+    // This function is necessary as the built in routines don't always return the full value string
+    QFile infile(path);
+    if (infile.open(QIODevice::ReadOnly)) {
+        QTextStream in(&infile);
+        in.setCodec("UTF-8");
+
+        QString line;
+        QString prefix;
+        while (!in.atEnd()) {
+            line = in.readLine();
+            if (line.trimmed().startsWith(QLatin1Char(';'))) {
+                continue;
+            }
+
+            if (line.startsWith(QLatin1Char('['))) {
+                // read prefix
+                auto end = line.indexOf(QLatin1Char(']'));
+                if (end > 1) {
+                    prefix = line.mid(1, end - 1) + QString::fromStdString("/");
+
+                    // Render WB uses both Render and Rendering
+                    if (prefix == QString::fromStdString("Rendering/")) {
+                        prefix = QString::fromStdString("Render/");
+                    }
+                }
+            }
+            else {
+                auto separator = line.indexOf(QLatin1Char('='));
+                if (separator > 2) {
+                    auto left = line.mid(0, separator - 1);
+                    auto right = line.mid(separator + 2);
+                    map[prefix + left] = right;
+                }
+            }
+        }
+        infile.close();
+        return true;
+    }
+
+    return false;
+}
+
+void MaterialConfigLoader::splitTexture(const QString& value, QString* texture, QString* remain)
+{
+    // Split Texture(...);(...) into its two pieces
+    if (value.contains(QLatin1Char(';'))) {
+        auto separator = value.indexOf(QLatin1Char(';'));
+        auto left = value.mid(0, separator);
+        auto right = value.mid(separator + 1);
+        if (isTexture(left)) {
+            *texture = left;
+            *remain = right;
+        }
+        else {
+            *texture = right;
+            *remain = left;
+        }
+    }
+    else {
+        if (isTexture(value)) {
+            *texture = value;
+        }
+        else {
+            *remain = value;
+        }
+    }
+}
+
+void MaterialConfigLoader::splitTextureObject(const QString& value,
+                                              QString* texture,
+                                              QString* remain,
+                                              QString* object)
+{
+    splitTexture(value, texture, remain);
+    if (*remain == QString::fromStdString("Object")) {
+        *remain = QString();  // Empty string
+        *object = QString::fromStdString("true");
+    }
+}
+
 QString MaterialConfigLoader::getAuthorAndLicense(const QString& path)
 {
    std::ifstream infile(path.toStdString());
@@ -77,7 +173,7 @@ QString MaterialConfigLoader::getAuthorAndLicense(const QString& path)
    if (!std::getline(infile, line)) {
        return noAuthor;
    }
-    std::size_t found = line.find(";");
+    std::size_t found = line.find(';');
    if (found != std::string::npos) {
        return QString::fromStdString(trim_copy(line.substr(found + 1)));
    }
@@ -85,8 +181,8 @@ QString MaterialConfigLoader::getAuthorAndLicense(const QString& path)
    return noAuthor;
 }

-void MaterialConfigLoader::addVectorRendering(const QSettings& fcmat,
-                                              std::shared_ptr<Material> finalModel)
+void MaterialConfigLoader::addVectorRendering(const QMap<QString, QString>& fcmat,
+                                              const std::shared_ptr<Material>& finalModel)
 {
    QString sectionFillPattern = value(fcmat, "VectorRendering/SectionFillPattern", "");
    QString sectionLinewidth = value(fcmat, "VectorRendering/SectionLinewidth", "");
@@ -95,23 +191,30 @@ void MaterialConfigLoader::addVectorRendering(const QSettings& fcmat,
    QString viewFillPattern = value(fcmat, "VectorRendering/ViewFillPattern", "");
    QString viewLinewidth = value(fcmat, "VectorRendering/ViewLinewidth", "");

+    // Defined by the Render WB
+    QString aSection = value(fcmat, "Architectural/SectionColor", "");
+
+    if (!aSection.isEmpty()) {
+        sectionColor = aSection;
+    }
+
    if (sectionFillPattern.length() + sectionLinewidth.length() + sectionColor.length()
            + viewColor.length() + viewFillPattern.length() + viewLinewidth.length()
        > 0) {
        finalModel->addAppearance(ModelUUIDs::ModelUUID_Rendering_Vector);
-    }

-    // Now add the data
-    setAppearanceValue(finalModel, "SectionFillPattern", sectionFillPattern);
-    setAppearanceValue(finalModel, "SectionLinewidth", sectionLinewidth);
-    setAppearanceValue(finalModel, "SectionColor", sectionColor);
-    setAppearanceValue(finalModel, "ViewColor", viewColor);
-    setAppearanceValue(finalModel, "ViewFillPattern", viewFillPattern);
-    setAppearanceValue(finalModel, "ViewLinewidth", viewLinewidth);
+        // Now add the data
+        setAppearanceValue(finalModel, "SectionFillPattern", sectionFillPattern);
+        setAppearanceValue(finalModel, "SectionLinewidth", sectionLinewidth);
+        setAppearanceValue(finalModel, "SectionColor", sectionColor);
+        setAppearanceValue(finalModel, "ViewColor", viewColor);
+        setAppearanceValue(finalModel, "ViewFillPattern", viewFillPattern);
+        setAppearanceValue(finalModel, "ViewLinewidth", viewLinewidth);
+    }
 }

-void MaterialConfigLoader::addRendering(const QSettings& fcmat,
-                                        std::shared_ptr<Material> finalModel)
+void MaterialConfigLoader::addRendering(const QMap<QString, QString>& fcmat,
+                                        const std::shared_ptr<Material>& finalModel)
 {
    QString ambientColor = value(fcmat, "Rendering/AmbientColor", "");
    QString diffuseColor = value(fcmat, "Rendering/DiffuseColor", "");
@@ -124,6 +227,17 @@ void MaterialConfigLoader::addRendering(const QSettings& fcmat,
    QString fragmentShader = value(fcmat, "Rendering/FragmentShader", "");
    QString vertexShader = value(fcmat, "Rendering/VertexShader", "");

+    // Defined by the Render WB
+    QString aDiffuse = value(fcmat, "Architectural/DiffuseColor", "");
+    QString aTransparency = value(fcmat, "Architectural/Transparency", "");
+
+    if (!aDiffuse.isEmpty()) {
+        diffuseColor = aDiffuse;
+    }
+    if (!aTransparency.isEmpty()) {
+        transparency = aTransparency;
+    }
+
    // Check which model we need
    bool useTexture = false;
    bool useAdvanced = false;
@@ -163,7 +277,565 @@ void MaterialConfigLoader::addRendering(const QSettings& fcmat,
    setAppearanceValue(finalModel, "VertexShader", vertexShader);
 }

-void MaterialConfigLoader::addCosts(const QSettings& fcmat, std::shared_ptr<Material> finalModel)
+QString MaterialConfigLoader::multiLineKey(QMap<QString, QString>& fcmat, const QString& prefix)
+{
+    // fcmat.beginGroup(QString::fromStdString("Render"));
+    QString multiLineString;
+    auto keys = fcmat.keys();
+    for (const auto& key : keys) {
+        if (key.startsWith(prefix) || key.startsWith(QString::fromStdString("Render/") + prefix)) {
+            QString string = value(fcmat, key.toStdString(), "");
+            if (multiLineString.isEmpty()) {
+                multiLineString += string;
+            }
+            else {
+                multiLineString += QString::fromStdString("\n") + string;
+            }
+        }
+    }
+    // fcmat.endGroup();
+
+    return multiLineString;
+}
+
+void MaterialConfigLoader::addRenderAppleseed(QMap<QString, QString>& fcmat,
+                                              const std::shared_ptr<Material>& finalModel)
+{
+    QString prefix = QString::fromStdString("Render.Appleseed");
+    QString string = multiLineKey(fcmat, prefix);
+
+    if (!string.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Appleseed);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Appleseed", string);
+    }
+}
+
+void MaterialConfigLoader::addRenderCarpaint(QMap<QString, QString>& fcmat,
+                                             const std::shared_ptr<Material>& finalModel)
+{
+    QString renderBaseColorValue = value(fcmat, "Render/Render.Carpaint.BaseColor", "");
+    QString renderBump = value(fcmat, "Render/Render.Carpaint.Bump", "");
+    QString renderDisplacement = value(fcmat, "Render/Render.Carpaint.Displacement", "");
+    QString renderNormal = value(fcmat, "Render/Render.Carpaint.Normal", "");
+
+    // Split out the textures
+    QString renderBaseColor;
+    QString renderBaseColorTexture;
+    QString renderBaseColorObject;
+    splitTextureObject(renderBaseColorValue,
+                       &renderBaseColorTexture,
+                       &renderBaseColor,
+                       &renderBaseColorObject);
+
+    if (!renderBaseColorValue.isEmpty() || !renderBump.isEmpty() || !renderDisplacement.isEmpty()
+        || !renderNormal.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Carpaint);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Carpaint.BaseColor", renderBaseColor);
+        setAppearanceValue(finalModel, "Render.Carpaint.BaseColor.Texture", renderBaseColorTexture);
+        setAppearanceValue(finalModel, "Render.Carpaint.BaseColor.Object", renderBaseColorObject);
+        setAppearanceValue(finalModel, "Render.Carpaint.Bump", renderBump);
+        setAppearanceValue(finalModel, "Render.Carpaint.Displacement", renderDisplacement);
+        setAppearanceValue(finalModel, "Render.Carpaint.Normal", renderNormal);
+    }
+}
+
+void MaterialConfigLoader::addRenderCycles(QMap<QString, QString>& fcmat,
+                                           const std::shared_ptr<Material>& finalModel)
+{
+    QString prefix = QString::fromStdString("Render.Cycles");
+    QString string = multiLineKey(fcmat, prefix);
+    if (!string.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Cycles);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Cycles", string);
+    }
+}
+
+void MaterialConfigLoader::addRenderDiffuse(QMap<QString, QString>& fcmat,
+                                            const std::shared_ptr<Material>& finalModel)
+{
+    QString renderBump = value(fcmat, "Render/Render.Diffuse.Bump", "");
+    QString renderColorValue = value(fcmat, "Render/Render.Diffuse.Color", "");
+    QString renderDisplacement = value(fcmat, "Render/Render.Diffuse.Displacement", "");
+    QString renderNormal = value(fcmat, "Render/Render.Diffuse.Normal", "");
+
+    // Split out the textures
+    QString renderColor;
+    QString renderColorTexture;
+    QString renderColorObject;
+    splitTextureObject(renderColorValue, &renderColorTexture, &renderColor, &renderColorObject);
+
+    if (!renderBump.isEmpty() || !renderColorValue.isEmpty() || !renderDisplacement.isEmpty()
+        || !renderNormal.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Diffuse);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Diffuse.Bump", renderBump);
+        setAppearanceValue(finalModel, "Render.Diffuse.Color", renderColor);
+        setAppearanceValue(finalModel, "Render.Diffuse.Color.Texture", renderColorTexture);
+        setAppearanceValue(finalModel, "Render.Diffuse.Color.Object", renderColorObject);
+        setAppearanceValue(finalModel, "Render.Diffuse.Displacement", renderDisplacement);
+        setAppearanceValue(finalModel, "Render.Diffuse.Normal", renderNormal);
+    }
+}
+
+void MaterialConfigLoader::addRenderDisney(QMap<QString, QString>& fcmat,
+                                           const std::shared_ptr<Material>& finalModel)
+{
+    QString renderAnisotropicValue = value(fcmat, "Render/Render.Disney.Anisotropic", "");
+    QString renderBaseColorValue = value(fcmat, "Render/Render.Disney.BaseColor", "");
+    QString renderBump = value(fcmat, "Render/Render.Disney.Bump", "");
+    QString renderClearCoatValue = value(fcmat, "Render/Render.Disney.ClearCoat", "");
+    QString renderClearCoatGlossValue = value(fcmat, "Render/Render.Disney.ClearCoatGloss", "");
+    QString renderDisplacement = value(fcmat, "Render/Render.Disney.Displacement", "");
+    QString renderMetallicValue = value(fcmat, "Render/Render.Disney.Metallic", "");
+    QString renderNormal = value(fcmat, "Render/Render.Disney.Normal", "");
+    QString renderRoughnessValue = value(fcmat, "Render/Render.Disney.Roughness", "");
+    QString renderSheenValue = value(fcmat, "Render/Render.Disney.Sheen", "");
+    QString renderSheenTintValue = value(fcmat, "Render/Render.Disney.SheenTint", "");
+    QString renderSpecularValue = value(fcmat, "Render/Render.Disney.Specular", "");
+    QString renderSpecularTintValue = value(fcmat, "Render/Render.Disney.SpecularTint", "");
+    QString renderSubsurfaceValue = value(fcmat, "Render/Render.Disney.Subsurface", "");
+
+    // Split out the textures
+    QString renderAnisotropic;
+    QString renderAnisotropicTexture;
+    splitTexture(renderAnisotropicValue, &renderAnisotropicTexture, &renderAnisotropic);
+    QString renderBaseColor;
+    QString renderBaseColorTexture;
+    QString renderBaseColorObject;
+    splitTextureObject(renderBaseColorValue,
+                       &renderBaseColorTexture,
+                       &renderBaseColor,
+                       &renderBaseColorObject);
+    QString renderClearCoat;
+    QString renderClearCoatTexture;
+    QString renderClearCoatObject;
+    splitTextureObject(renderClearCoatValue,
+                       &renderClearCoatTexture,
+                       &renderClearCoat,
+                       &renderClearCoatObject);
+    QString renderClearCoatGloss;
+    QString renderClearCoatGlossTexture;
+    QString renderClearCoatGlossObject;
+    splitTextureObject(renderClearCoatGlossValue,
+                       &renderClearCoatGlossTexture,
+                       &renderClearCoatGloss,
+                       &renderClearCoatGlossObject);
+    QString renderMetallic;
+    QString renderMetallicTexture;
+    splitTexture(renderMetallicValue, &renderMetallicTexture, &renderMetallic);
+    QString renderRoughness;
+    QString renderRoughnessTexture;
+    splitTexture(renderRoughnessValue, &renderRoughnessTexture, &renderRoughness);
+    QString renderSheen;
+    QString renderSheenTexture;
+    splitTexture(renderSheenValue, &renderSheenTexture, &renderSheen);
+    QString renderSheenTint;
+    QString renderSheenTintTexture;
+    splitTexture(renderSheenTintValue, &renderSheenTintTexture, &renderSheenTint);
+    QString renderSpecular;
+    QString renderSpecularTexture;
+    QString renderSpecularObject;
+    splitTextureObject(renderSpecularValue,
+                       &renderSpecularTexture,
+                       &renderSpecular,
+                       &renderSpecularObject);
+    QString renderSpecularTint;
+    QString renderSpecularTintTexture;
+    QString renderSpecularTintObject;
+    splitTextureObject(renderSpecularTintValue,
+                       &renderSpecularTintTexture,
+                       &renderSpecularTint,
+                       &renderSpecularTintObject);
+    QString renderSubsurface;
+    QString renderSubsurfaceTexture;
+    splitTexture(renderSubsurfaceValue, &renderSubsurfaceTexture, &renderSubsurface);
+
+    if (!renderAnisotropicValue.isEmpty() || !renderBaseColorValue.isEmpty()
+        || !renderBump.isEmpty() || !renderClearCoatValue.isEmpty()
+        || !renderClearCoatGlossValue.isEmpty() || !renderDisplacement.isEmpty()
+        || !renderMetallicValue.isEmpty() || !renderNormal.isEmpty()
+        || !renderRoughnessValue.isEmpty() || !renderSheenValue.isEmpty()
+        || !renderSheenTintValue.isEmpty() || !renderSpecularValue.isEmpty()
+        || !renderSpecularTintValue.isEmpty() || !renderSubsurfaceValue.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Disney);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Disney.Anisotropic", renderAnisotropic);
+        setAppearanceValue(finalModel,
+                           "Render.Disney.Anisotropic.Texture",
+                           renderAnisotropicTexture);
+        setAppearanceValue(finalModel, "Render.Disney.BaseColor", renderBaseColor);
+        setAppearanceValue(finalModel, "Render.Disney.BaseColor.Texture", renderBaseColorTexture);
+        setAppearanceValue(finalModel, "Render.Disney.Bump", renderBump);
+        setAppearanceValue(finalModel, "Render.Disney.ClearCoat", renderClearCoat);
+        setAppearanceValue(finalModel, "Render.Disney.ClearCoat.Texture", renderClearCoatTexture);
+        setAppearanceValue(finalModel, "Render.Disney.ClearCoatGloss", renderClearCoatGloss);
+        setAppearanceValue(finalModel,
+                           "Render.Disney.ClearCoatGloss.Texture",
+                           renderClearCoatGlossTexture);
+        setAppearanceValue(finalModel, "Render.Disney.Displacement", renderDisplacement);
+        setAppearanceValue(finalModel, "Render.Disney.Metallic", renderMetallic);
+        setAppearanceValue(finalModel, "Render.Disney.Metallic.Texture", renderMetallicTexture);
+        setAppearanceValue(finalModel, "Render.Disney.Normal", renderNormal);
+        setAppearanceValue(finalModel, "Render.Disney.Roughness", renderRoughness);
+        setAppearanceValue(finalModel, "Render.Disney.Roughness.Texture", renderRoughnessTexture);
+        setAppearanceValue(finalModel, "Render.Disney.Sheen", renderSheen);
+        setAppearanceValue(finalModel, "Render.Disney.Sheen.Texture", renderSheenTexture);
+        setAppearanceValue(finalModel, "Render.Disney.SheenTint", renderSheenTint);
+        setAppearanceValue(finalModel, "Render.Disney.SheenTint.Texture", renderSheenTintTexture);
+        setAppearanceValue(finalModel, "Render.Disney.Specular", renderSpecular);
+        setAppearanceValue(finalModel, "Render.Disney.Specular.Texture", renderSpecularTexture);
+        setAppearanceValue(finalModel, "Render.Disney.SpecularTint", renderSpecularTint);
+        setAppearanceValue(finalModel,
+                           "Render.Disney.SpecularTint.Texture",
+                           renderSpecularTintTexture);
+        setAppearanceValue(finalModel, "Render.Disney.Subsurface", renderSubsurface);
+        setAppearanceValue(finalModel, "Render.Disney.Subsurface.Texture", renderSubsurfaceTexture);
+    }
+}
+
+void MaterialConfigLoader::addRenderEmission(QMap<QString, QString>& fcmat,
+                                             const std::shared_ptr<Material>& finalModel)
+{
+    QString renderBump = value(fcmat, "Render/Render.Emission.Bump", "");
+    QString renderColorValue = value(fcmat, "Render/Render.Emission.Color", "");
+    QString renderNormal = value(fcmat, "Render/Render.Emission.Normal", "");
+    QString renderPowerValue = value(fcmat, "Render/Render.Emission.Power", "");
+
+    // Split out the textures
+    QString renderColor;
+    QString renderColorTexture;
+    QString renderColorObject;
+    splitTextureObject(renderColorValue, &renderColorTexture, &renderColor, &renderColorObject);
+    QString renderPower;
+    QString renderPowerTexture;
+    splitTexture(renderPowerValue, &renderPowerTexture, &renderPower);
+
+    if (!renderColorValue.isEmpty() || !renderBump.isEmpty() || !renderPowerValue.isEmpty()
+        || !renderNormal.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Emission);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Emission.Bump", renderBump);
+        setAppearanceValue(finalModel, "Render.Emission.Color", renderColor);
+        setAppearanceValue(finalModel, "Render.Emission.Color.Texture", renderColorTexture);
+        setAppearanceValue(finalModel, "Render.Emission.Color.Object", renderColorObject);
+        setAppearanceValue(finalModel, "Render.Emission.Normal", renderNormal);
+        setAppearanceValue(finalModel, "Render.Emission.Power", renderPower);
+        setAppearanceValue(finalModel, "Render.Emission.Power.Texture", renderPowerTexture);
+    }
+}
+
+void MaterialConfigLoader::addRenderGlass(QMap<QString, QString>& fcmat,
+                                          const std::shared_ptr<Material>& finalModel)
+{
+    QString renderBump = value(fcmat, "Render/Render.Glass.Bump", "");
+    QString renderColorValue = value(fcmat, "Render/Render.Glass.Color", "");
+    QString renderIORValue = value(fcmat, "Render/Render.Glass.IOR", "");
+    QString renderDisplacement = value(fcmat, "Render/Render.Glass.Displacement", "");
+    QString renderNormal = value(fcmat, "Render/Render.Glass.Normal", "");
+
+    // Split out the textures
+    QString renderColor;
+    QString renderColorTexture;
+    QString renderColorObject;
+    splitTextureObject(renderColorValue, &renderColorTexture, &renderColor, &renderColorObject);
+    QString renderIOR;
+    QString renderIORTexture;
+    splitTexture(renderIORValue, &renderIORTexture, &renderIOR);
+
+    if (!renderBump.isEmpty() || !renderColorValue.isEmpty() || !renderIORValue.isEmpty()
+        || !renderDisplacement.isEmpty() || !renderNormal.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Glass);
+
+        setAppearanceValue(finalModel, "Render.Glass.Bump", renderBump);
+        setAppearanceValue(finalModel, "Render.Glass.Color", renderColor);
+        setAppearanceValue(finalModel, "Render.Glass.Color.Texture", renderColorTexture);
+        setAppearanceValue(finalModel, "Render.Glass.Color.Object", renderColorObject);
+        setAppearanceValue(finalModel, "Render.Glass.IOR", renderIOR);
+        setAppearanceValue(finalModel, "Render.Glass.IOR.Texture", renderIORTexture);
+        setAppearanceValue(finalModel, "Render.Glass.Displacement", renderDisplacement);
+        setAppearanceValue(finalModel, "Render.Glass.Normal", renderNormal);
+    }
+}
+
+void MaterialConfigLoader::addRenderLuxcore(QMap<QString, QString>& fcmat,
+                                            const std::shared_ptr<Material>& finalModel)
+{
+    QString prefix = QString::fromStdString("Render.Luxcore");
+    QString string = multiLineKey(fcmat, prefix);
+
+    if (!string.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Luxcore);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Luxcore", string);
+    }
+}
+
+void MaterialConfigLoader::addRenderLuxrender(QMap<QString, QString>& fcmat,
+                                              const std::shared_ptr<Material>& finalModel)
+{
+    QString prefix = QString::fromStdString("Render.Luxrender");
+    QString string = multiLineKey(fcmat, prefix);
+
+    if (!string.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Luxrender);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Luxrender", string);
+    }
+}
+
+void MaterialConfigLoader::addRenderMixed(QMap<QString, QString>& fcmat,
+                                          const std::shared_ptr<Material>& finalModel)
+{
+    QString renderBump = value(fcmat, "Render/Render.Mixed.Bump", "");
+    QString renderDiffuseColorValue = value(fcmat, "Render/Render.Mixed.Diffuse.Color", "");
+    QString renderDisplacement = value(fcmat, "Render/Render.Mixed.Displacement", "");
+    QString renderGlassColorValue = value(fcmat, "Render/Render.Mixed.Glass.Color", "");
+    QString renderGlassIORValue = value(fcmat, "Render/Render.Mixed.Glass.IOR", "");
+    QString renderNormal = value(fcmat, "Render/Render.Mixed.Normal", "");
+    QString renderTransparencyValue = value(fcmat, "Render/Render.Mixed.Transparency", "");
+
+    // Split out the textures
+    QString renderDiffuseColor;
+    QString renderDiffuseColorTexture;
+    QString renderDiffuseColorObject;
+    splitTextureObject(renderDiffuseColorValue,
+                       &renderDiffuseColorTexture,
+                       &renderDiffuseColor,
+                       &renderDiffuseColorObject);
+    QString renderGlassColor;
+    QString renderGlassColorTexture;
+    QString renderGlassColorObject;
+    splitTextureObject(renderGlassColorValue,
+                       &renderGlassColorTexture,
+                       &renderGlassColor,
+                       &renderGlassColorObject);
+    QString renderGlassIOR;
+    QString renderGlassIORTexture;
+    splitTexture(renderGlassIORValue, &renderGlassIORTexture, &renderGlassIOR);
+    QString renderTransparency;
+    QString renderTransparencyTexture;
+    splitTexture(renderTransparencyValue, &renderTransparencyTexture, &renderTransparency);
+
+    if (!renderBump.isEmpty() || !renderDiffuseColorValue.isEmpty() || !renderDisplacement.isEmpty()
+        || !renderGlassColorValue.isEmpty() || !renderGlassIORValue.isEmpty()
+        || !renderNormal.isEmpty() || !renderTransparencyValue.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Mixed);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Mixed.Bump", renderBump);
+        setAppearanceValue(finalModel, "Render.Mixed.Diffuse.Color", renderDiffuseColor);
+        setAppearanceValue(finalModel,
+                           "Render.Mixed.Diffuse.Color.Texture",
+                           renderDiffuseColorTexture);
+        setAppearanceValue(finalModel,
+                           "Render.Mixed.Diffuse.Color.Object",
+                           renderDiffuseColorObject);
+        setAppearanceValue(finalModel, "Render.Mixed.Displacement", renderDisplacement);
+        setAppearanceValue(finalModel, "Render.Mixed.Glass.Color", renderGlassColor);
+        setAppearanceValue(finalModel, "Render.Mixed.Glass.Color.Texture", renderGlassColorTexture);
+        setAppearanceValue(finalModel, "Render.Mixed.Glass.Color.Object", renderGlassColorObject);
+        setAppearanceValue(finalModel, "Render.Mixed.Glass.IOR", renderGlassIOR);
+        setAppearanceValue(finalModel, "Render.Mixed.Glass.IOR.Texture", renderGlassIORTexture);
+        setAppearanceValue(finalModel, "Render.Mixed.Normal", renderNormal);
+        setAppearanceValue(finalModel, "Render.Mixed.Transparency", renderTransparency);
+        setAppearanceValue(finalModel,
+                           "Render.Mixed.Transparency.Texture",
+                           renderTransparencyTexture);
+    }
+}
+
+void MaterialConfigLoader::addRenderOspray(QMap<QString, QString>& fcmat,
+                                           const std::shared_ptr<Material>& finalModel)
+{
+    QString prefix = QString::fromStdString("Render.Ospray");
+    QString string = multiLineKey(fcmat, prefix);
+
+    if (!string.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Ospray);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Ospray", string);
+    }
+}
+
+void MaterialConfigLoader::addRenderPbrt(QMap<QString, QString>& fcmat,
+                                         const std::shared_ptr<Material>& finalModel)
+{
+    QString prefix = QString::fromStdString("Render.Pbrt");
+    QString string = multiLineKey(fcmat, prefix);
+
+    if (!string.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Pbrt);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Pbrt", string);
+    }
+}
+
+void MaterialConfigLoader::addRenderPovray(QMap<QString, QString>& fcmat,
+                                           const std::shared_ptr<Material>& finalModel)
+{
+    QString prefix = QString::fromStdString("Render.Povray");
+    QString string = multiLineKey(fcmat, prefix);
+
+    if (!string.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Povray);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Povray", string);
+    }
+}
+
+void MaterialConfigLoader::addRenderSubstancePBR(QMap<QString, QString>& fcmat,
+                                                 const std::shared_ptr<Material>& finalModel)
+{
+    QString renderBaseColorValue = value(fcmat, "Render/Render.Substance_PBR.BaseColor", "");
+    QString renderBump = value(fcmat, "Render/Render.Substance_PBR.Bump", "");
+    QString renderMetallicValue = value(fcmat, "Render/Render.Substance_PBR.Metallic", "");
+    QString renderNormal = value(fcmat, "Render/Render.Substance_PBR.Normal", "");
+    QString renderRoughnessValue = value(fcmat, "Render/Render.Substance_PBR.Roughness", "");
+    QString renderSpecularValue = value(fcmat, "Render/Render.Substance_PBR.Specular", "");
+
+    // Split out the textures
+    QString renderBaseColor;
+    QString renderBaseColorTexture;
+    QString renderBaseColorObject;
+    splitTextureObject(renderBaseColorValue,
+                       &renderBaseColorTexture,
+                       &renderBaseColor,
+                       &renderBaseColorObject);
+    QString renderMetallic;
+    QString renderMetallicTexture;
+    splitTexture(renderMetallicValue, &renderMetallicTexture, &renderMetallic);
+    QString renderRoughness;
+    QString renderRoughnessTexture;
+    splitTexture(renderRoughnessValue, &renderRoughnessTexture, &renderRoughness);
+    QString renderSpecular;
+    QString renderSpecularTexture;
+    splitTexture(renderSpecularValue, &renderSpecularTexture, &renderSpecular);
+
+    if (!renderBaseColorValue.isEmpty() || !renderBump.isEmpty() || !renderMetallicValue.isEmpty()
+        || !renderNormal.isEmpty() || !renderRoughnessValue.isEmpty()
+        || !renderSpecularValue.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_SubstancePBR);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Substance_PBR.BaseColor", renderBaseColor);
+        setAppearanceValue(finalModel,
+                           "Render.Substance_PBR.BaseColor.Texture",
+                           renderBaseColorTexture);
+        setAppearanceValue(finalModel,
+                           "Render.Substance_PBR.BaseColor.Object",
+                           renderBaseColorObject);
+        setAppearanceValue(finalModel, "Render.Substance_PBR.Bump", renderBump);
+        setAppearanceValue(finalModel, "Render.Substance_PBR.Metallic", renderMetallic);
+        setAppearanceValue(finalModel,
+                           "Render.Substance_PBR.Metallic.Texture",
+                           renderMetallicTexture);
+        setAppearanceValue(finalModel, "Render.Substance_PBR.Normal", renderNormal);
+        setAppearanceValue(finalModel, "Render.Substance_PBR.Roughness", renderRoughness);
+        setAppearanceValue(finalModel,
+                           "Render.Substance_PBR.Roughness.Texture",
+                           renderRoughnessTexture);
+        setAppearanceValue(finalModel, "Render.Substance_PBR.Specular", renderSpecular);
+        setAppearanceValue(finalModel,
+                           "Render.Substance_PBR.Specular.Texture",
+                           renderSpecularTexture);
+    }
+}
+
+void MaterialConfigLoader::addRenderTexture(QMap<QString, QString>& fcmat,
+                                            const std::shared_ptr<Material>& finalModel)
+{
+    QString renderName;
+    auto renderImage = std::make_shared<QList<QVariant>>();
+    QString renderScale;
+    QString renderRotation;
+    QString renderTranslationU;
+    QString renderTranslationV;
+
+    auto keys = fcmat.keys();
+    for (const auto& key : keys) {
+        if (key.startsWith(QString::fromStdString("Render/Render.Textures."))) {
+            QStringList list1 = key.split(QLatin1Char('.'));
+            if (renderName.isEmpty()) {
+                renderName = list1[2];
+            }
+            if (list1[3] == QString::fromStdString("Images")) {
+                renderImage->push_back(value(fcmat, key.toStdString(), ""));
+            }
+            else if (list1[3] == QString::fromStdString("Scale")) {
+                renderScale = value(fcmat, key.toStdString(), "");
+            }
+            else if (list1[3] == QString::fromStdString("Rotation")) {
+                renderRotation = value(fcmat, key.toStdString(), "");
+            }
+            else if (list1[3] == QString::fromStdString("TranslationU")) {
+                renderTranslationU = value(fcmat, key.toStdString(), "");
+            }
+            else if (list1[3] == QString::fromStdString(" TranslationV")) {
+                renderTranslationV = value(fcmat, key.toStdString(), "");
+            }
+        }
+    }
+
+    if (!renderName.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Texture);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "Render.Textures.Name", renderName);
+        setAppearanceValue(finalModel, "Render.Textures.Images", renderImage);
+        setAppearanceValue(finalModel, "Render.Textures.Scale", renderScale);
+        setAppearanceValue(finalModel, "Render.Textures.Rotation", renderRotation);
+        setAppearanceValue(finalModel, "Render.Textures.TranslationU", renderTranslationU);
+        setAppearanceValue(finalModel, "Render.Textures.TranslationV", renderTranslationV);
+    }
+}
+
+void MaterialConfigLoader::addRenderWB(QMap<QString, QString>& fcmat,
+                                       const std::shared_ptr<Material>& finalModel)
+{
+    QString useObjectColor = value(fcmat, "General/UseObjectColor", "");
+    QString renderType = value(fcmat, "Render/Render.Type", "");
+
+    if (!renderType.isEmpty()) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_RenderWB);
+
+        // Now add the data
+        setAppearanceValue(finalModel, "UseObjectColor", useObjectColor);
+        setAppearanceValue(finalModel, "Render.Type", renderType);
+    }
+
+    addRenderAppleseed(fcmat, finalModel);
+    addRenderCarpaint(fcmat, finalModel);
+    addRenderCycles(fcmat, finalModel);
+    addRenderDiffuse(fcmat, finalModel);
+    addRenderDisney(fcmat, finalModel);
+    addRenderEmission(fcmat, finalModel);
+    addRenderGlass(fcmat, finalModel);
+    addRenderLuxcore(fcmat, finalModel);
+    addRenderLuxrender(fcmat, finalModel);
+    addRenderMixed(fcmat, finalModel);
+    addRenderOspray(fcmat, finalModel);
+    addRenderPbrt(fcmat, finalModel);
+    addRenderPovray(fcmat, finalModel);
+    addRenderSubstancePBR(fcmat, finalModel);
+    addRenderTexture(fcmat, finalModel);
+}
+
+void MaterialConfigLoader::addCosts(const QMap<QString, QString>& fcmat,
+                                    const std::shared_ptr<Material>& finalModel)
 {
    QString productURL = value(fcmat, "Cost/ProductURL", "");
    QString specificPrice = value(fcmat, "Cost/SpecificPrice", "");
@@ -171,16 +843,16 @@ void MaterialConfigLoader::addCosts(const QSettings& fcmat, std::shared_ptr<Mate

    if (productURL.length() + specificPrice.length() + vendor.length() > 0) {
        finalModel->addPhysical(ModelUUIDs::ModelUUID_Costs_Default);
-    }

-    // Now add the data
-    setPhysicalValue(finalModel, "ProductURL", productURL);
-    setPhysicalValue(finalModel, "SpecificPrice", specificPrice);
-    setPhysicalValue(finalModel, "Vendor", vendor);
+        // Now add the data
+        setPhysicalValue(finalModel, "ProductURL", productURL);
+        setPhysicalValue(finalModel, "SpecificPrice", specificPrice);
+        setPhysicalValue(finalModel, "Vendor", vendor);
+    }
 }

-void MaterialConfigLoader::addArchitectural(const QSettings& fcmat,
-                                            std::shared_ptr<Material> finalModel)
+void MaterialConfigLoader::addArchitectural(const QMap<QString, QString>& fcmat,
+                                            const std::shared_ptr<Material>& finalModel)
 {
    QString color = value(fcmat, "Architectural/Color", "");
    QString environmentalEfficiencyClass =
@@ -192,26 +864,30 @@ void MaterialConfigLoader::addArchitectural(const QSettings& fcmat,
    QString soundTransmissionClass = value(fcmat, "Architectural/SoundTransmissionClass", "");
    QString unitsPerQuantity = value(fcmat, "Architectural/UnitsPerQuantity", "");

-    if (color.length() + environmentalEfficiencyClass.length() + executionInstructions.length()
-            + finish.length() + fireResistanceClass.length() + model.length()
-            + soundTransmissionClass.length() + unitsPerQuantity.length()
+    if (environmentalEfficiencyClass.length() + executionInstructions.length()
+            + fireResistanceClass.length() + model.length() + soundTransmissionClass.length()
+            + unitsPerQuantity.length()
        > 0) {
        finalModel->addPhysical(ModelUUIDs::ModelUUID_Architectural_Default);
    }
+    if (color.length() + finish.length() > 0) {
+        finalModel->addAppearance(ModelUUIDs::ModelUUID_Rendering_Architectural);
+    }

    // Now add the data
-    setPhysicalValue(finalModel, "Color", color);
    setPhysicalValue(finalModel, "EnvironmentalEfficiencyClass", environmentalEfficiencyClass);
    setPhysicalValue(finalModel, "ExecutionInstructions", executionInstructions);
-    setPhysicalValue(finalModel, "Finish", finish);
    setPhysicalValue(finalModel, "FireResistanceClass", fireResistanceClass);
    setPhysicalValue(finalModel, "Model", model);
    setPhysicalValue(finalModel, "SoundTransmissionClass", soundTransmissionClass);
    setPhysicalValue(finalModel, "UnitsPerQuantity", unitsPerQuantity);
+
+    setAppearanceValue(finalModel, "Color", color);
+    setAppearanceValue(finalModel, "Finish", finish);
 }

-void MaterialConfigLoader::addElectromagnetic(const QSettings& fcmat,
-                                              std::shared_ptr<Material> finalModel)
+void MaterialConfigLoader::addElectromagnetic(const QMap<QString, QString>& fcmat,
+                                              const std::shared_ptr<Material>& finalModel)
 {
    QString relativePermittivity = value(fcmat, "Electromagnetic/RelativePermittivity", "");
    QString electricalConductivity = value(fcmat, "Electromagnetic/ElectricalConductivity", "");
@@ -221,15 +897,16 @@ void MaterialConfigLoader::addElectromagnetic(const QSettings& fcmat,
            + relativePermeability.length()
        > 0) {
        finalModel->addPhysical(ModelUUIDs::ModelUUID_Electromagnetic_Default);
-    }

-    // Now add the data
-    setPhysicalValue(finalModel, "RelativePermittivity", relativePermittivity);
-    setPhysicalValue(finalModel, "ElectricalConductivity", electricalConductivity);
-    setPhysicalValue(finalModel, "RelativePermeability", relativePermeability);
+        // Now add the data
+        setPhysicalValue(finalModel, "RelativePermittivity", relativePermittivity);
+        setPhysicalValue(finalModel, "ElectricalConductivity", electricalConductivity);
+        setPhysicalValue(finalModel, "RelativePermeability", relativePermeability);
+    }
 }

-void MaterialConfigLoader::addThermal(const QSettings& fcmat, std::shared_ptr<Material> finalModel)
+void MaterialConfigLoader::addThermal(const QMap<QString, QString>& fcmat,
+                                      const std::shared_ptr<Material>& finalModel)
 {
    QString specificHeat = value(fcmat, "Thermal/SpecificHeat", "");
    QString thermalConductivity = value(fcmat, "Thermal/ThermalConductivity", "");
@@ -238,15 +915,16 @@ void MaterialConfigLoader::addThermal(const QSettings& fcmat, std::shared_ptr<Ma
    if (specificHeat.length() + thermalConductivity.length() + thermalExpansionCoefficient.length()
        > 0) {
        finalModel->addPhysical(ModelUUIDs::ModelUUID_Thermal_Default);
-    }

-    // Now add the data
-    setPhysicalValue(finalModel, "SpecificHeat", specificHeat);
-    setPhysicalValue(finalModel, "ThermalConductivity", thermalConductivity);
-    setPhysicalValue(finalModel, "ThermalExpansionCoefficient", thermalExpansionCoefficient);
+        // Now add the data
+        setPhysicalValue(finalModel, "SpecificHeat", specificHeat);
+        setPhysicalValue(finalModel, "ThermalConductivity", thermalConductivity);
+        setPhysicalValue(finalModel, "ThermalExpansionCoefficient", thermalExpansionCoefficient);
+    }
 }

-void MaterialConfigLoader::addFluid(const QSettings& fcmat, std::shared_ptr<Material> finalModel)
+void MaterialConfigLoader::addFluid(const QMap<QString, QString>& fcmat,
+                                    const std::shared_ptr<Material>& finalModel)
 {
    QString density = value(fcmat, "Fluidic/Density", "");
    QString dynamicViscosity = value(fcmat, "Fluidic/DynamicViscosity", "");
@@ -277,8 +955,8 @@ void MaterialConfigLoader::addFluid(const QSettings& fcmat, std::shared_ptr<Mate
    setPhysicalValue(finalModel, "PrandtlNumber", prandtlNumber);
 }

-void MaterialConfigLoader::addMechanical(const QSettings& fcmat,
-                                         std::shared_ptr<Material> finalModel)
+void MaterialConfigLoader::addMechanical(const QMap<QString, QString>& fcmat,
+                                         const std::shared_ptr<Material>& finalModel)
 {
    QString density = value(fcmat, "Mechanical/Density", "");
    QString bulkModulus = value(fcmat, "Mechanical/BulkModulus", "");
@@ -340,12 +1018,16 @@ void MaterialConfigLoader::addMechanical(const QSettings& fcmat,
 }

 std::shared_ptr<Material>
-MaterialConfigLoader::getMaterialFromPath(std::shared_ptr<MaterialLibrary> library,
+MaterialConfigLoader::getMaterialFromPath(const std::shared_ptr<MaterialLibrary>& library,
                                          const QString& path)
 {
    QString author = getAuthorAndLicense(path);  // Place them both in the author field

-    QSettings fcmat(path, QSettings::IniFormat);
+    QMap<QString, QString> fcmat;
+    if (!readFile(path, fcmat)) {
+        Base::Console().Log("Error reading '%s'\n", path.toStdString().c_str());
+        throw MaterialReadError();
+    }

    // General section
    // QString name = value(fcmat, "Name", ""); - always get the name from the filename
@@ -359,13 +1041,15 @@ MaterialConfigLoader::getMaterialFromPath(std::shared_ptr<MaterialLibrary> libra
    QString sourceURL = value(fcmat, "SourceURL", "");

    std::shared_ptr<Material> finalModel = std::make_shared<Material>(library, path, uuid, name);
+    finalModel->setOldFormat(true);
+
    finalModel->setAuthor(author);
    finalModel->setDescription(description);
    finalModel->setReference(sourceReference);
    finalModel->setURL(sourceURL);

    QString father = value(fcmat, "Father", "");
-    if (father.length() > 0) {
+    if (!father.isEmpty()) {
        finalModel->addPhysical(ModelUUIDs::ModelUUID_Legacy_Father);

        // Now add the data
@@ -396,6 +1080,7 @@ MaterialConfigLoader::getMaterialFromPath(std::shared_ptr<MaterialLibrary> libra
    addCosts(fcmat, finalModel);
    addRendering(fcmat, finalModel);
    addVectorRendering(fcmat, finalModel);
+    addRenderWB(fcmat, finalModel);

    return finalModel;
-}
+}