ShaderRegistry.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorShaders/phosphorshaders_export.h>
 
#include <PhosphorRegistry/IFactoryBase.h>
#include <PhosphorFsLoader/WatchedDirectorySet.h>
#include <PhosphorRegistry/MetadataPackLoader.h>
#include <PhosphorRegistry/Registry.h>
 
#include <QImage>
#include <QList>
#include <QMap>
#include <QMutex>
#include <QObject>
#include <QRect>
#include <QSize>
#include <QString>
#include <QUrl>
#include <QVariant>
#include <array>
#include <memory>
#include <optional>
 
namespace PhosphorShaders {
 
class IWallpaperProvider;
 
class PHOSPHORSHADERS_EXPORT ShaderRegistry : public QObject
{
    Q_OBJECT
 
public:
    struct ParameterInfo
    {
        QString id;
        QString name;
        QString group;
        QString type; 
        int slot = -1;
        QVariant defaultValue;
        QVariant minValue;
        QVariant maxValue;
        bool useZoneColor = false; 
        QString wrap;
        QString unit;
 
        QString uniformName() const;
    };
 
    struct ShaderInfo
    {
        QString id;
        QString name;
        QString description;
        QString author;
        QString version;
        QUrl shaderUrl;
        QString sourcePath;
        QString vertexShaderPath;
        QString packDir;
        QStringList bufferShaderPaths;
        QString previewPath;
        QString category;
        QList<ParameterInfo> parameters;
        QMap<QString, QVariantMap> presets;
        bool isUserShader = false;
        bool isMultipass = false;
        bool useWallpaper = false;
        bool bufferFeedback = false;
        qreal bufferScale = 1.0;
        bool halfFloatBuffers = true;
        QString bufferWrap = QStringLiteral("clamp");
        QStringList bufferWraps;
        QString bufferFilter = QStringLiteral("linear");
        QStringList bufferFilters;
        bool useDepthBuffer = false;
 
        bool isValid() const
        {
            // isNoneShader(id) is just id.isEmpty(), which the first conjunct
            // already excludes, so the "none" shader is never valid here.
            //
            // This says the metadata is WELL-FORMED, not that the pack will
            // load: `shaderUrl` is built from the declared fragment path
            // without a filesystem check, so a pack naming a frag that is not
            // there still reports valid. The live scan re-checks existence
            // before compiling; an offline caller has to check the file itself
            // (the shader validator reports it as its own lint).
            return !id.isEmpty() && shaderUrl.isValid();
        }
    };
 
    class ShaderPack final : public PhosphorRegistry::IFactoryBase
    {
    public:
        explicit ShaderPack(ShaderInfo info)
            : m_info(std::move(info))
        {
        }
        [[nodiscard]] QString id() const override
        {
            return m_info.id;
        }
        [[nodiscard]] QString displayName() const override
        {
            return m_info.name;
        }
        [[nodiscard]] const ShaderInfo& info() const
        {
            return m_info;
        }
 
    private:
        ShaderInfo m_info;
    };
 
    explicit ShaderRegistry(QObject* parent = nullptr);
    ~ShaderRegistry() override;
 
    // ── Search paths (forwarded to the internal MetadataPackLoader) ───
    //
    // Same surface the since-removed MetadataPackRegistryBase provided. liveReload
    // defaults to On (production hot-reload); pass Off for one-shot scans.
    void addSearchPath(const QString& path, PhosphorFsLoader::LiveReload liveReload = PhosphorFsLoader::LiveReload::On);
    void addSearchPaths(
        const QStringList& paths, PhosphorFsLoader::LiveReload liveReload = PhosphorFsLoader::LiveReload::On,
        PhosphorFsLoader::RegistrationOrder order = PhosphorFsLoader::RegistrationOrder::LowestPriorityFirst);
    [[nodiscard]] QStringList searchPaths() const;
    void setUserPath(const QString& path);
    Q_INVOKABLE void refresh();
 
    // ── Shader discovery ──────────────────────────────────────────────
 
    static QString noneShaderUuid();
    static bool isNoneShader(const QString& id);
 
    QList<ShaderInfo> availableShaders() const;
    Q_INVOKABLE QVariantList availableShadersVariant() const;
 
    ShaderInfo shader(const QString& id) const;
    Q_INVOKABLE QVariantMap shaderInfo(const QString& id) const;
    Q_INVOKABLE QUrl shaderUrl(const QString& id) const;
 
    // ── Parameters & presets ──────────────────────────────────────────
 
    Q_INVOKABLE QVariantMap defaultParams(const QString& id) const;
    bool validateParams(const QString& id, const QVariantMap& params) const;
    QVariantMap validateAndCoerceParams(const QString& id, const QVariantMap& params) const;
    Q_INVOKABLE QVariantMap translateParamsToUniforms(const QString& shaderId, const QVariantMap& storedParams) const;
 
    static QString paramPreamble(const ShaderInfo& info);
 
    static ShaderInfo parsePackMetadata(const QString& packDir, QString* error = nullptr, bool validateSchema = true);
 
    Q_INVOKABLE QVariantMap presetParams(const QString& shaderId, const QString& presetName) const;
    Q_INVOKABLE QStringList shaderPresetNames(const QString& shaderId) const;
    Q_INVOKABLE QVariantList shaderPresetsVariant(const QString& shaderId) const;
 
    Q_INVOKABLE bool shadersEnabled() const
    {
        return true;
    }
 
    // ── Lifecycle ─────────────────────────────────────────────────────
 
    void reportShaderBakeStarted(const QString& shaderId);
    void reportShaderBakeFinished(const QString& shaderId, bool success, const QString& error);
 
    // ── Wallpaper ─────────────────────────────────────────────────────
 
    static QString wallpaperPath();
    static QImage loadWallpaperImage();
 
    static QImage loadWallpaperImage(const QRect& subGeom, const QRect& physGeom);
 
    static QRect computeWallpaperCropRect(QSize wpSize, const QRect& physGeom, const QRect& subGeom);
 
    static std::optional<QRectF> wallpaperSliceNormalized(QSize wpSize, const QRect& physGeom, const QRect& subGeom);
 
    static void invalidateWallpaperCache();
 
Q_SIGNALS:
    void shadersChanged();
    void shaderCompilationStarted(const QString& shaderId);
    void shaderCompilationFinished(const QString& shaderId, bool success, const QString& error);
 
private:
    bool validateParameterValue(const ParameterInfo& param, const QVariant& value) const;
    QVariantMap shaderInfoToVariantMap(const ShaderInfo& info) const;
    QVariantMap parameterInfoToVariantMap(const ParameterInfo& param) const;
 
    // Generic id-keyed storage + change-notify for the discovered shader
    // packs. m_loader (below) populates it from disk; the lookup methods
    // read it. Declared before m_loader so it is destroyed AFTER the loader:
    // the loader holds a borrowed Registry pointer (used during live rescans
    // in reconcile(), not at teardown), which must stay valid for the loader's
    // whole lifetime.
    PhosphorRegistry::Registry<ShaderPack> m_registry;
    // On-disk scan + hot-reload. Parses each pack's metadata.json into a
    // ShaderPack and reconciles m_registry; its onCommitted hook re-emits
    // shadersChanged. unique_ptr so the ctor can configure it after the
    // member-init list (parser, watch paths, signature, commit hook).
    std::unique_ptr<PhosphorRegistry::MetadataPackLoader<ShaderPack>> m_loader;
 
    static std::unique_ptr<IWallpaperProvider> s_wallpaperProvider;
    static QString s_cachedWallpaperPath;
    static bool s_wallpaperPathResolved;
    static qint64 s_wallpaperPathResolvedAtMs;
    static QImage s_cachedWallpaperImage;
    static qint64 s_cachedWallpaperMtime;
    static QMutex s_wallpaperCacheMutex;
 
    // Per-VS crop cache: keeps the same QImage (and cacheKey) for repeated
    // loadWallpaperImage(sub, phys) calls so downstream cacheKey()-based
    // short-circuits in ShaderEffect/ShaderNodeRhi keep working and the GPU
    // doesn't re-upload the wallpaper on every overlay update.
    struct WallpaperCropEntry
    {
        QRect sub;
        QRect phys;
        qint64 mtime = 0;
        QImage img;
    };
    static constexpr int CropCacheCapacity = 8;
    static std::array<WallpaperCropEntry, CropCacheCapacity> s_cachedWallpaperCrops;
    static int s_cachedWallpaperCropNextSlot;
};
 
} // namespace PhosphorShaders