qshader.h

Go to the documentation of this file.

// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#ifndef QSHADER_H
#define QSHADER_H
 
//
//  W A R N I N G
//  -------------
//
// This file is part of the RHI API, with limited compatibility guarantees.
// Usage of this API may make your code source and binary incompatible with
// future versions of Qt.
//
 
#include <QtGui/qtguiglobal.h>
#include <QtCore/qhash.h>
#include <QtCore/qmap.h>
#include <rhi/qshaderdescription.h>
 
QT_BEGIN_NAMESPACE
 
struct QShaderPrivate;
class QShaderKey;
 
class Q_GUI_EXPORT QShaderVersion
{
public:
    enum Flag {
        GlslEs = 0x01
    };
    Q_DECLARE_FLAGS(Flags, Flag)
 
    QShaderVersion() = default;
    QShaderVersion(int v, Flags f = Flags());
 
    int version() const { return m_version; }
    void setVersion(int v) { m_version = v; }
 
    Flags flags() const { return m_flags; }
    void setFlags(Flags f) { m_flags = f; }
 
private:
    Q_GUI_EXPORT friend size_t qHash(QShaderVersion key, size_t seed) noexcept;
    friend size_t qHash(QShaderVersion key) noexcept { return qHash(key, size_t{0}); }
    #define QSHADERVERSION_IS_HASHABLE
 
    int m_version = 100;
    Flags m_flags;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(QShaderVersion::Flags)
Q_DECLARE_TYPEINFO(QShaderVersion, Q_RELOCATABLE_TYPE);
 
class QShaderCode;
Q_GUI_EXPORT size_t qHash(const QShaderCode &, size_t = 0) noexcept;
 
class Q_GUI_EXPORT QShaderCode
{
public:
    QShaderCode() = default;
    QShaderCode(const QByteArray &code, const QByteArray &entry = QByteArray());
 
    QByteArray shader() const { return m_shader; }
    void setShader(const QByteArray &code) { m_shader = code; }
 
    QByteArray entryPoint() const { return m_entryPoint; }
    void setEntryPoint(const QByteArray &entry) { m_entryPoint = entry; }
 
private:
    friend Q_GUI_EXPORT size_t qHash(const QShaderCode &, size_t) noexcept;
 
    QByteArray m_shader;
    QByteArray m_entryPoint;
};
 
Q_DECLARE_TYPEINFO(QShaderCode, Q_RELOCATABLE_TYPE);
 
class Q_GUI_EXPORT QShader
{
public:
    enum Stage {
        VertexStage = 0,
        TessellationControlStage,
        TessellationEvaluationStage,
        GeometryStage,
        FragmentStage,
        ComputeStage
    };
 
    enum Source {
        SpirvShader = 0,
        GlslShader,
        HlslShader,
        DxbcShader, // fxc
        MslShader,
        DxilShader, // dxc
        MetalLibShader, // xcrun metal + xcrun metallib
        WgslShader
    };
 
    enum Variant {
        StandardShader = 0,
        BatchableVertexShader,
        UInt16IndexedVertexAsComputeShader,
        UInt32IndexedVertexAsComputeShader,
        NonIndexedVertexAsComputeShader,
        HdrCapableFragmentShader,
    };
 
    enum class SerializedFormatVersion {
        Latest = 0,
        Qt_6_5,
        Qt_6_4
    };
 
    QShader();
    QShader(const QShader &other);
    QShader &operator=(const QShader &other);
    QShader(QShader &&other) noexcept : d(std::exchange(other.d, nullptr)) {}
    QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QShader)
    ~QShader();
 
    void swap(QShader &other) noexcept { qt_ptr_swap(d, other.d); }
    void detach();
 
    bool isValid() const;
 
    Stage stage() const;
    void setStage(Stage stage);
 
    QShaderDescription description() const;
    void setDescription(const QShaderDescription &desc);
 
    QList<QShaderKey> availableShaders() const;
    QShaderCode shader(const QShaderKey &key) const;
    void setShader(const QShaderKey &key, const QShaderCode &shader);
    void removeShader(const QShaderKey &key);
 
    QByteArray serialized(SerializedFormatVersion version = SerializedFormatVersion::Latest) const;
    static QShader fromSerialized(const QByteArray &data);
 
    using NativeResourceBindingMap = QMap<int, std::pair<int, int>>; // binding -> native_binding[, native_binding]
    NativeResourceBindingMap nativeResourceBindingMap(const QShaderKey &key) const;
    void setResourceBindingMap(const QShaderKey &key, const NativeResourceBindingMap &map);
    void removeResourceBindingMap(const QShaderKey &key);
 
    struct SeparateToCombinedImageSamplerMapping {
        QByteArray combinedSamplerName;
        int textureBinding;
        int samplerBinding;
    };
    using SeparateToCombinedImageSamplerMappingList = QList<SeparateToCombinedImageSamplerMapping>;
    SeparateToCombinedImageSamplerMappingList separateToCombinedImageSamplerMappingList(const QShaderKey &key) const;
    void setSeparateToCombinedImageSamplerMappingList(const QShaderKey &key,
                                                      const SeparateToCombinedImageSamplerMappingList &list);
    void removeSeparateToCombinedImageSamplerMappingList(const QShaderKey &key);
 
    struct NativeShaderInfo {
        int flags = 0;
        QMap<int, int> extraBufferBindings;
    };
    NativeShaderInfo nativeShaderInfo(const QShaderKey &key) const;
    void setNativeShaderInfo(const QShaderKey &key, const NativeShaderInfo &info);
    void removeNativeShaderInfo(const QShaderKey &key);
 
private:
    QShaderPrivate *d;
    friend struct QShaderPrivate;
    friend Q_GUI_EXPORT bool operator==(const QShader &, const QShader &) noexcept;
    friend Q_GUI_EXPORT size_t qHash(const QShader &, size_t) noexcept;
#ifndef QT_NO_DEBUG_STREAM
    friend Q_GUI_EXPORT QDebug operator<<(QDebug, const QShader &);
#endif
};
 
Q_DECLARE_SHARED(QShader)
 
class Q_GUI_EXPORT QShaderKey
{
public:
    QShaderKey() = default;
    QShaderKey(QShader::Source s,
               const QShaderVersion &sver,
               QShader::Variant svar = QShader::StandardShader);
 
    QShader::Source source() const { return m_source; }
    void setSource(QShader::Source s) { m_source = s; }
 
    QShaderVersion sourceVersion() const { return m_sourceVersion; }
    void setSourceVersion(const QShaderVersion &sver) { m_sourceVersion = sver; }
 
    QShader::Variant sourceVariant() const { return m_sourceVariant; }
    void setSourceVariant(QShader::Variant svar) { m_sourceVariant = svar; }
 
private:
    QShader::Source m_source = QShader::SpirvShader;
    QShaderVersion m_sourceVersion;
    QShader::Variant m_sourceVariant = QShader::StandardShader;
};
 
Q_DECLARE_TYPEINFO(QShaderKey, Q_RELOCATABLE_TYPE);
 
Q_GUI_EXPORT bool operator==(const QShader &lhs, const QShader &rhs) noexcept;
Q_GUI_EXPORT size_t qHash(const QShader &s, size_t seed = 0) noexcept;
 
inline bool operator!=(const QShader &lhs, const QShader &rhs) noexcept
{
    return !(lhs == rhs);
}
 
Q_GUI_EXPORT bool operator==(const QShaderVersion &lhs, const QShaderVersion &rhs) noexcept;
Q_GUI_EXPORT bool operator<(const QShaderVersion &lhs, const QShaderVersion &rhs) noexcept;
Q_GUI_EXPORT bool operator==(const QShaderKey &lhs, const QShaderKey &rhs) noexcept;
Q_GUI_EXPORT bool operator<(const QShaderKey &lhs, const QShaderKey &rhs) noexcept;
Q_GUI_EXPORT bool operator==(const QShaderCode &lhs, const QShaderCode &rhs) noexcept;
 
inline bool operator!=(const QShaderVersion &lhs, const QShaderVersion &rhs) noexcept
{
    return !(lhs == rhs);
}
 
inline bool operator!=(const QShaderKey &lhs, const QShaderKey &rhs) noexcept
{
    return !(lhs == rhs);
}
 
inline bool operator!=(const QShaderCode &lhs, const QShaderCode &rhs) noexcept
{
    return !(lhs == rhs);
}
 
Q_GUI_EXPORT size_t qHash(const QShaderKey &k, size_t seed = 0) noexcept;
 
#ifndef QT_NO_DEBUG_STREAM
Q_GUI_EXPORT QDebug operator<<(QDebug, const QShader &);
Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QShaderKey &k);
Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QShaderVersion &v);
#endif
 
QT_END_NAMESPACE
 
#endif