acmxvk-source-manifest.cpp

Go to the documentation of this file.

#include "acmxvk-source-manifest.hpp"
 
#include <QDir>
#include <QDirIterator>
#include <QFile>
#include <QFileInfo>
#include <QHash>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonParseError>
#include <QRegularExpression>
#include <QSaveFile>
#include <QSet>
#include <QStringList>
#include <algorithm>
 
namespace {
    struct UniformMetadata {
        double minimum = 0.0;
        double maximum = 1.0;
        double step = 0.01;
        double value = 0.0;
    };
 
    QHash<int, QString> default_slot_names() {
        return {{0, QStringLiteral("square_size")}, {1, QStringLiteral("alpha_value")}, {2, QStringLiteral("alpha_r")}, {3, QStringLiteral("alpha_g")}, {4, QStringLiteral("alpha_b")}, {5, QStringLiteral("value_alpha_r")}, {6, QStringLiteral("value_alpha_g")}, {7, QStringLiteral("value_alpha_b")}, {8, QStringLiteral("index_value")}, {9, QStringLiteral("restore_black")}, {10, QStringLiteral("seed")}, {11, QStringLiteral("value1")}, {12, QStringLiteral("iChannelTime")}, {13, QStringLiteral("time_speed")}, {14, QStringLiteral("blendAmt")}, {15, QStringLiteral("uDistortion")}, {16, QStringLiteral("uRotateSpeed")}, {17, QStringLiteral("uWarpSpeed")}, {18, QStringLiteral("uRandRate")}, {19, QStringLiteral("uPhaseRate")}, {20, QStringLiteral("slider1")}, {21, QStringLiteral("slider2")}, {22, QStringLiteral("slider3")}, {23, QStringLiteral("slider4")}, {24, QStringLiteral("frequency")}, {25, QStringLiteral("strength")}, {26, QStringLiteral("random_seed")}};
    }
 
    QHash<QString, UniformMetadata> default_metadata() {
        QHash<QString, UniformMetadata> metadata;
        metadata.insert(QStringLiteral("square_size"), {1.0, 128.0, 1.0, 55.0});
        metadata.insert(QStringLiteral("slider1"), {0.0, 1.0, 0.01, 0.5});
        metadata.insert(QStringLiteral("slider2"), {0.0, 1.0, 0.01, 0.6});
        metadata.insert(QStringLiteral("slider3"), {0.0, 1.0, 0.01, 0.35});
        metadata.insert(QStringLiteral("slider4"), {0.0, 1.0, 0.01, 0.8});
        return metadata;
    }
 
    bool read_existing_metadata(const QString &path, QHash<QString, UniformMetadata> &metadata, QString &error) {
        if (!QFileInfo::exists(path))
            return true;
 
        QFile file(path);
        if (!file.open(QIODevice::ReadOnly)) {
            error = QObject::tr("Cannot read existing manifest %1: %2").arg(path, file.errorString());
            return false;
        }
        QJsonParseError parseError;
        const QJsonDocument document = QJsonDocument::fromJson(file.readAll(), &parseError);
        if (parseError.error != QJsonParseError::NoError || !document.isObject()) {
            error = QObject::tr("Cannot parse existing manifest %1 at offset %2: %3").arg(path).arg(parseError.offset).arg(parseError.errorString());
            return false;
        }
 
        const QJsonObject uniforms = document.object().value(QStringLiteral("custom_uniforms")).toObject();
        for (auto it = uniforms.constBegin(); it != uniforms.constEnd(); ++it) {
            if (!it.value().isObject())
                continue;
            const UniformMetadata fallback = metadata.value(it.key());
            const QJsonObject value = it.value().toObject();
            metadata.insert(it.key(), {value.value(QStringLiteral("minimum")).toDouble(fallback.minimum), value.value(QStringLiteral("maximum")).toDouble(fallback.maximum), value.value(QStringLiteral("step")).toDouble(fallback.step), value.value(QStringLiteral("value")).toDouble(fallback.value)});
        }
        return true;
    }
 
    bool scan_slots(const QString &path, QHash<int, QString> &slotNames, QHash<QString, int> &nameSlots, QString &error) {
        QFile file(path);
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            error = QObject::tr("Cannot read %1: %2").arg(path, file.errorString());
            return false;
        }
 
        static const QRegularExpression aliasExpression(QStringLiteral("^\\s*#define\\s+([A-Za-z_][A-Za-z0-9_]*)\\s+"
                                                                       "ext\\.custom_uniforms\\[(\\d+)\\]\\.([xyzw])"));
        const QStringList lines = QString::fromUtf8(file.readAll()).split(QLatin1Char('\n'));
        for (const QString &line : lines) {
            const QRegularExpressionMatch match = aliasExpression.match(line);
            if (!match.hasMatch())
                continue;
            const QString name = match.captured(1);
            const int vector = match.captured(2).toInt();
            const int component = QStringLiteral("xyzw").indexOf(match.captured(3));
            const int slot = vector * 4 + component;
            if (slotNames.contains(slot) && slotNames.value(slot) != name) {
                error = QObject::tr("Custom-uniform slot %1 is both %2 and %3 (%4)").arg(slot).arg(slotNames.value(slot), name, path);
                return false;
            }
            if (nameSlots.contains(name) && nameSlots.value(name) != slot) {
                error = QObject::tr("Custom uniform %1 uses slots %2 and %3 (%4)").arg(name).arg(nameSlots.value(name)).arg(slot).arg(path);
                return false;
            }
            slotNames.insert(slot, name);
            nameSlots.insert(name, slot);
        }
        return true;
    }
 
    bool shader_name_less(const QString &left, const QString &right) {
        const int insensitive = QString::compare(left, right, Qt::CaseInsensitive);
        return insensitive == 0 ? left < right : insensitive < 0;
    }
} // namespace
 
namespace acmx2 {
    static bool create_acmxvk_source_manifest_impl(const QString &rootDirectory, const QString &requestedOutputPath, const QStringList *includedShaders, AcmxvkSourceManifestResult &result, QString &error) {
        result = {};
        error.clear();
 
        const QFileInfo rootInfo(rootDirectory);
        if (!rootInfo.exists() || !rootInfo.isDir()) {
            error = QObject::tr("Shader source directory does not exist: %1").arg(rootDirectory);
            return false;
        }
        const QString root = QDir(rootInfo.absoluteFilePath()).canonicalPath();
        const QString outputPath = requestedOutputPath.trimmed().isEmpty() ? QDir(root).filePath(QStringLiteral("library.json")) : QFileInfo(requestedOutputPath).absoluteFilePath();
        if (!QDir().mkpath(QFileInfo(outputPath).absolutePath())) {
            error = QObject::tr("Cannot create manifest directory: %1").arg(QFileInfo(outputPath).absolutePath());
            return false;
        }
 
        QSet<QString> includedFiles;
        if (includedShaders) {
            for (QString entry : *includedShaders) {
                entry = entry.trimmed();
                entry.replace(QLatin1Char('\\'), QLatin1Char('/'));
                entry = QDir::cleanPath(entry);
                if (entry.isEmpty() || entry == QStringLiteral(".") || entry == QStringLiteral("..") || entry.startsWith(QStringLiteral("../")) || QDir::isAbsolutePath(entry)) {
                    error = QObject::tr("Invalid shader path in source manifest: %1").arg(entry);
                    return false;
                }
                if (includedFiles.contains(entry)) {
                    error = QObject::tr("Duplicate shader path in source manifest: %1").arg(entry);
                    return false;
                }
                includedFiles.insert(entry);
            }
        }
 
        QHash<int, QString> slotNames = default_slot_names();
        QHash<QString, int> nameSlots;
        for (auto it = slotNames.constBegin(); it != slotNames.constEnd(); ++it)
            nameSlots.insert(it.value(), it.key());
 
        QStringList fragmentFiles;
        QStringList computeFiles;
        QSet<QString> discoveredFiles;
        QDirIterator iterator(root, QDir::Files | QDir::Hidden, QDirIterator::Subdirectories);
        while (iterator.hasNext()) {
            const QString absolutePath = iterator.next();
            QString relative = QDir(root).relativeFilePath(absolutePath);
            relative.replace(QLatin1Char('\\'), QLatin1Char('/'));
            const QStringList parts = relative.split(QLatin1Char('/'));
            const int directoryPartCount = std::max(0, static_cast<int>(parts.size()) - 1);
            const bool underCompute = parts.mid(0, directoryPartCount).contains(QStringLiteral("compute"));
            const bool computeShader = underCompute && relative.endsWith(QStringLiteral(".comp"));
            const bool fragmentShader = !underCompute && relative.endsWith(QStringLiteral(".frag"));
            if (!computeShader && !fragmentShader)
                continue;
            if (includedShaders && !includedFiles.contains(relative))
                continue;
            if (computeShader) {
                computeFiles.append(relative);
            } else {
                fragmentFiles.append(relative);
            }
            discoveredFiles.insert(relative);
            if (!scan_slots(absolutePath, slotNames, nameSlots, error))
                return false;
        }
 
        if (includedShaders) {
            for (const QString &entry : includedFiles) {
                if (!discoveredFiles.contains(entry)) {
                    error = QObject::tr("Manifest shader is missing or is not a supported "
                                        ".frag/compute/*.comp source: %1")
                                .arg(entry);
                    return false;
                }
            }
        }
 
        std::sort(fragmentFiles.begin(), fragmentFiles.end(), shader_name_less);
        std::sort(computeFiles.begin(), computeFiles.end(), shader_name_less);
        QStringList shaders = fragmentFiles;
        shaders.append(computeFiles);
        if (shaders.isEmpty()) {
            error = QObject::tr("No .frag or compute/*.comp sources found in %1").arg(root);
            return false;
        }
        if (shaders.size() > 16384) {
            error = QObject::tr("Shader library exceeds ACMXVK's 16384-entry limit");
            return false;
        }
 
        QHash<QString, QString> outputNames;
        for (const QString &shader : shaders) {
            const QString compiled = (shader + QStringLiteral(".spv")).toLower();
            if (outputNames.contains(compiled)) {
                error = QObject::tr("Case-insensitive duplicate shader output: %1.spv").arg(shader);
                return false;
            }
            outputNames.insert(compiled, shader);
        }
 
        int maximumSlot = 0;
        for (auto it = slotNames.constBegin(); it != slotNames.constEnd(); ++it)
            maximumSlot = std::max(maximumSlot, it.key());
        for (int slot = 0; slot <= maximumSlot; ++slot) {
            if (!slotNames.contains(slot)) {
                error = QObject::tr("No custom-uniform name was found for slot %1").arg(slot);
                return false;
            }
        }
 
        QHash<QString, UniformMetadata> metadata = default_metadata();
        if (!read_existing_metadata(outputPath, metadata, error))
            return false;
 
        QJsonObject customUniforms;
        for (int slot = 0; slot <= maximumSlot; ++slot) {
            const QString name = slotNames.value(slot);
            const UniformMetadata values = metadata.value(name);
            QJsonObject uniform;
            uniform.insert(QStringLiteral("slot"), slot);
            uniform.insert(QStringLiteral("minimum"), values.minimum);
            uniform.insert(QStringLiteral("maximum"), values.maximum);
            uniform.insert(QStringLiteral("step"), values.step);
            uniform.insert(QStringLiteral("value"), values.value);
            customUniforms.insert(name, uniform);
        }
        QJsonArray shaderArray;
        for (const QString &shader : shaders)
            shaderArray.append(shader);
 
        QJsonObject manifest;
        manifest.insert(QStringLiteral("version"), 1);
        manifest.insert(QStringLiteral("backend"), QStringLiteral("acmxvk"));
        manifest.insert(QStringLiteral("library_type"), QStringLiteral("source"));
        manifest.insert(QStringLiteral("custom_uniforms"), customUniforms);
        manifest.insert(QStringLiteral("shaders"), shaderArray);
 
        QSaveFile output(outputPath);
        if (!output.open(QIODevice::WriteOnly)) {
            error = QObject::tr("Cannot write %1: %2").arg(outputPath, output.errorString());
            return false;
        }
        const QByteArray json = QJsonDocument(manifest).toJson(QJsonDocument::Indented);
        if (output.write(json) != json.size() || !output.commit()) {
            error = QObject::tr("Cannot replace %1: %2").arg(outputPath, output.errorString());
            return false;
        }
 
        result.fragmentCount = fragmentFiles.size();
        result.computeCount = computeFiles.size();
        result.customUniformCount = maximumSlot + 1;
        result.outputPath = outputPath;
        return true;
    }
 
    bool create_acmxvk_source_manifest(const QString &rootDirectory, const QString &outputPath, AcmxvkSourceManifestResult &result, QString &error) { return create_acmxvk_source_manifest_impl(rootDirectory, outputPath, nullptr, result, error); }
 
    bool create_acmxvk_source_manifest_for_shaders(const QString &rootDirectory, const QStringList &shaderFiles, const QString &outputPath, AcmxvkSourceManifestResult &result, QString &error) { return create_acmxvk_source_manifest_impl(rootDirectory, outputPath, &shaderFiles, result, error); }
} // namespace acmx2