main.cpp - mozsearch

++ // Copyright (C) 2019 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

++

++ #include <QtGui/QGuiApplication>

++ #include <QtCore/QCommandLineParser>

++ #include <QtCore/QStandardPaths>

++ #include <QtCore/QDir>

++ #include <QtCore/QVariant>

++ #include <QtCore/QHash>

++

++ #include <QtCore/QJsonObject>

++

++ #include <QtGui/QImageReader>

++

++ #include <QtQuick3DAssetImport/private/qssgassetimportmanager_p.h>

++ #include <QtQuick3DIblBaker/private/qssgiblbaker_p.h>

++

++ #include <QJsonDocument>

++ #include <iostream>

++

++ class OptionsManager {

++ public:

++     OptionsManager() {

++

++     }

++     ~OptionsManager() {

++         qDeleteAll(m_optionsMap);

++         m_optionsMap.clear();

++     }

++     void generateCommandLineOptions(const QJsonObject &options)

++     {

++         if (options.isEmpty() || !options.contains(QStringLiteral("options")))

++             return;

++

++         QJsonObject optionsObject = options.value(QStringLiteral("options")).toObject();

++         for (const QString &optionsKey : optionsObject.keys()) {

++             QJsonObject option = optionsObject.value(optionsKey).toObject();

++             QString optionType = option.value(QStringLiteral("type")).toString();

++             QString description = option.value(QStringLiteral("description")).toString();

++             if (optionType == QStringLiteral("Boolean")) {

++                 // boolean flags

++                 m_optionsMap.insert(optionsKey, new QCommandLineOption(optionsKey, description));

++                 const QString disableKey = QStringLiteral("disable-") + optionsKey;

++                 m_optionsMap.insert(disableKey, new QCommandLineOption(QStringLiteral("disable-") + optionsKey));

++             } else {

++                 // value types

++                 if (optionType == QStringLiteral("Real")) {

++                     QString defaultValue = QString::number(option.value("value").toDouble());

++                     QCommandLineOption *valueOption = new QCommandLineOption(optionsKey, description, optionsKey, defaultValue);

++                     m_optionsMap.insert(optionsKey, valueOption);

++                 } else if (optionType == QStringLiteral("String")) {

++                     QString defaultValue = option.value("value").toString();

++                     QCommandLineOption *valueOption = new QCommandLineOption(optionsKey, description, optionsKey, defaultValue);

++                     m_optionsMap.insert(optionsKey, valueOption);

++                 }

++             }

++         }

++     }

++

++     QJsonObject processCommandLineOptions(const QCommandLineParser &cmdLineParser, const QJsonObject &options, const QJsonObject &loadedOptions) const

++     {

++         QJsonObject result = loadedOptions;

++         if (options.isEmpty() || !options.contains(QStringLiteral("options")))

++             return result;

++

++         QJsonObject optionsObject = options.value(QStringLiteral("options")).toObject();

++         QJsonObject loadedOptionsObject = loadedOptions.value(QStringLiteral("options")).toObject();

++         for (const QString &optionsKey : optionsObject.keys()) {

++             QJsonObject option = optionsObject.value(optionsKey).toObject();

++             QString optionType = option.value(QStringLiteral("type")).toString();

++             if (optionType == QStringLiteral("Boolean")) {

++                 const QString disableKey = QStringLiteral("disable-") + optionsKey;

++                 if (m_optionsMap[optionsKey] && cmdLineParser.isSet(*m_optionsMap[optionsKey]))

++                     option["value"] = true;

++                 else if (m_optionsMap[disableKey] && cmdLineParser.isSet(*m_optionsMap[disableKey]))

++                     option["value"] = false;

++                 else if (auto loadedValue = loadedOptionsObject.value(optionsKey); !loadedValue.isUndefined())

++                     option.insert("value", loadedValue);

++             } else if (optionType == QStringLiteral("Real")) {

++                 if (cmdLineParser.isSet(optionsKey))

++                     option["value"] = cmdLineParser.value(optionsKey).toDouble();

++                 else if (auto loadedValue = loadedOptionsObject.value(optionsKey); !loadedValue.isUndefined())

++                     option.insert("value", loadedValue);

++             } else if (optionType == QStringLiteral("String")) {

++                 if (cmdLineParser.isSet(optionsKey))

++                     option["value"] = cmdLineParser.value(optionsKey);

++                 else if (auto loadedValue = loadedOptionsObject.value(optionsKey); !loadedValue.isUndefined())

++                     option.insert("value", loadedValue);

++             }

++             // update values

++             optionsObject[optionsKey] = option;

++         }

++

++         removeFlagConflicts(cmdLineParser, optionsObject);

++         result["options"] = optionsObject;

++         return result;

++     }

++

++     void registerOptions(QCommandLineParser &parser) {

++         for (const auto &cmdLineOption : std::as_const(m_optionsMap))

++             parser.addOption(*cmdLineOption);

++     }

++

++     void removeFlagConflicts(const QCommandLineParser &cmdLineParser, QJsonObject &options) const

++     {

++         // m_optionsMap only has the options of the loaded plugins

++         const auto isSet = [&](const QString &key) {

++             const QCommandLineOption *option = m_optionsMap.value(key);

++             return option && cmdLineParser.isSet(*option);

++         };

++

++         // "generateNormals" and "generateSmoothNormals" are mutually exclusive. "generateNormals"

++         // takes precedence.

++         QJsonObject opt;

++         if (isSet(QStringLiteral("generateNormals"))) {

++             opt = options.value(QStringLiteral("generateSmoothNormals")).toObject();

++             if (opt[QStringLiteral("value")] == true) {

++                 opt[QStringLiteral("value")] = false;

++                 options[QStringLiteral("generateSmoothNormals")] = opt;

++                 std::cerr << "\"--generateSmoothNormals\" disabled due to \"--generateNormals\".\n";

++             }

++

++         } else if (isSet(QStringLiteral("generateSmoothNormals"))) {

++             opt = options.value(QStringLiteral("generateNormals")).toObject();

++             if (opt[QStringLiteral("value")] == true) {

++                 opt[QStringLiteral("value")] = false;

++                 options[QStringLiteral("generateNormals")] = opt;

++                 std::cerr << "\"--generateNormals\" disabled due to \"--generateSmoothNormals\".\n";

++             }

++         }

++

++         // Ditto for "optimizeGraph" and "preTransformVertices".

++         if (isSet(QStringLiteral("optimizeGraph"))) {

++             opt = options.value(QStringLiteral("preTransformVertices")).toObject();

++             if (opt[QStringLiteral("value")] == true) {

++                 opt[QStringLiteral("value")] = false;

++                 options[QStringLiteral("preTransformVertices")] = opt;

++                 std::cerr << "\"--preTransformVertices\" disabled due to \"--optimizeGraph\".\n";

++             }

++         } else if (isSet(QStringLiteral("preTransformVertices"))) {

++             opt = options.value(QStringLiteral("optimizeGraph")).toObject();

++             if (opt[QStringLiteral("value")] == true) {

++                 opt[QStringLiteral("value")] = false;

++                 options[QStringLiteral("optimizeGraph")] = opt;

++                 std::cerr << "\"--optimizeGraph\" disabled due to \"--preTransformVertices\".\n";

++             }

++         }

++     }

++

++ private:

++     QHash<QString, QCommandLineOption *> m_optionsMap;

++ };

++

++ struct BuiltinConditioners

++ {

++     QSSGAssetImportManager::ImportState run(const QString &filename,

++                                             const QDir &outputPath,

++                                             QString *error);

++

++     QSSGIblBaker iblBaker;

++ };

++

++ QSSGAssetImportManager::ImportState BuiltinConditioners::run(const QString &filename,

++                                                              const QDir &outputPath,

++                                                              QString *error)

++ {

++     QFileInfo fileInfo(filename);

++     if (!fileInfo.exists()) {

++         if (error)

++             *error = QStringLiteral("File does not exist");

++         return QSSGAssetImportManager::ImportState::IoError;

++     }

++

++     const QString extension = fileInfo.suffix().toLower();

++     QStringList generatedFiles;

++     QSSGAssetImportManager::ImportState result = QSSGAssetImportManager::ImportState::Unsupported;

++

++     if (iblBaker.inputExtensions().contains(extension)) {

++         QString errorMsg = iblBaker.import(fileInfo.absoluteFilePath(), outputPath, &generatedFiles);

++         if (errorMsg.isEmpty()) {

++             result = QSSGAssetImportManager::ImportState::Success;

++         } else {

++             *error = errorMsg;

++             result = QSSGAssetImportManager::ImportState::IoError;

++         }

++     } else {

++         if (error)

++             *error = QStringLiteral("unsupported file extension %1").arg(extension);

++     }

++

++     for (const auto &file : generatedFiles)

++         qDebug() << "generated file:" << file;

++

++     return result;

++ }

++

++ int main(int argc, char *argv[])

++ {

++     QGuiApplication app(argc, argv);

++

++     QImageReader::setAllocationLimit(0);

++

++     const bool canUsePlugins = !QCoreApplication::arguments().contains(QStringLiteral("--no-plugins"));

++     if (!canUsePlugins)

++         qDebug("balsam: Not loading assetimporter plugins");

++

++     QScopedPointer<QSSGAssetImportManager> assetImporter;

++     OptionsManager optionsManager;

++     BuiltinConditioners builtins;

++

++     // Setup command line arguments

++     QCommandLineParser cmdLineParser;

++     cmdLineParser.setApplicationDescription(

++             QStringLiteral("Converts graphical assets to a runtime format for use with Qt Quick 3D"));

++     cmdLineParser.addHelpOption();

++     cmdLineParser.addPositionalArgument(QStringLiteral("sourceFilename"), QStringLiteral("Asset file to be imported"));

++     QCommandLineOption outputPathOption({ "outputPath", "o" }, QStringLiteral("Sets the location to place the generated file(s). Default is the current directory"), QStringLiteral("outputPath"), QDir::currentPath());

++     cmdLineParser.addOption(outputPathOption);

++     QCommandLineOption noPluginsOption(QStringLiteral("no-plugins"), QStringLiteral("Disable assetimporter plugin loading, only considers built-ins"));

++     cmdLineParser.addOption(noPluginsOption);

++

++     QCommandLineOption loadOptionsFromFileOption({"f","options-file"}, QStringLiteral("Load options from <file>"), QStringLiteral("file"));

++     cmdLineParser.addOption(loadOptionsFromFileOption);

++

++     // Get Plugin options

++     if (canUsePlugins) {

++         assetImporter.reset(new QSSGAssetImportManager);

++         auto pluginOptions = assetImporter->getAllOptions();

++         for (const auto &options : std::as_const(pluginOptions))

++             optionsManager.generateCommandLineOptions(options);

++         optionsManager.registerOptions(cmdLineParser);

++     }

++

++     cmdLineParser.process(app);

++

++     QStringList assetFileNames = cmdLineParser.positionalArguments();

++     QDir outputDirectory = QDir::currentPath();

++     if (cmdLineParser.isSet(outputPathOption)) {

++         outputDirectory = QDir(cmdLineParser.value(outputPathOption));

++         if (!outputDirectory.exists()) {

++             if (!outputDirectory.mkpath(QStringLiteral("."))) {

++                 std::cerr << "Failed to create export directory: " << qPrintable(outputDirectory.path()) << "\n";

++                 return 2;

++             }

++         }

++     }

++

++     // if there is nothing to do show help

++     if (assetFileNames.isEmpty())

++         cmdLineParser.showHelp(1);

++

++     // Convert each assetFile is possible

++     for (const auto &assetFileName : assetFileNames) {

++         QString errorString;

++         QSSGAssetImportManager::ImportState result = QSSGAssetImportManager::ImportState::Unsupported;

++         if (canUsePlugins) {

++             QJsonObject options = assetImporter->getOptionsForFile(assetFileName);

++             QJsonObject loadedOptions;

++

++             if (cmdLineParser.isSet(loadOptionsFromFileOption)) {

++                 QFile optionsFile(cmdLineParser.value(loadOptionsFromFileOption));

++                 if (!optionsFile.open(QIODevice::ReadOnly)) {

++                     qCritical() << "Could not open options file" << optionsFile.fileName() << "for reading.";

++                     return -1;

++                 }

++                 QByteArray optionData = optionsFile.readAll();

++                 QJsonParseError error;

++                 auto optionsDoc = QJsonDocument::fromJson(optionData, &error);

++                 if (optionsDoc.isEmpty()) {

++                     qCritical() << "Could not read options file:" << error.errorString();

++                     return -1;

++                 }

++                 loadedOptions = optionsDoc.object();

++             }

++

++             options = optionsManager.processCommandLineOptions(cmdLineParser, options, loadedOptions);

++

++             // first try the plugin-based asset importer system

++             result = assetImporter->importFile(assetFileName, outputDirectory, options, &errorString);

++         }

++         // if the file extension is unsupported, try the builtins

++         if (result == QSSGAssetImportManager::ImportState::Unsupported)

++             result = builtins.run(assetFileName, outputDirectory, &errorString);

++         if (result != QSSGAssetImportManager::ImportState::Success) {

++             std::cerr << "Failed to import file with error: " << qPrintable(errorString) << "\n";

++             return 2;

++         }

++     }

++

++     return 0;

++ }

Revision control