qquick3dshaderutils_p.h

qt/qtquick3d/src/quick3d/qquick3dshaderutils_p.h (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2020 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef QQUICK3DSHADERUTILS_H

#define QQUICK3DSHADERUTILS_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <QtQuick3D/qtquick3dglobal.h>

#include <QtQuick3D/private/qquick3dobject_p.h>

#include <QtQuick3D/private/qquick3dtexture_p.h>

#include <QtQuick3D/private/qquick3dmaterial_p.h>

#include <QtQuick3DUtils/private/qssgrenderbasetypes_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrendercommands_p.h>

QT_BEGIN_NAMESPACE

class QQuick3DShaderUtilsShader;

class QQmlContext;

class QQuick3DRenderPass;

namespace QSSGShaderUtils {

using MetaTypeList = QList<QMetaType::Type>;

using ResolveFunction = bool (*)(const QUrl &url, const QQmlContext *context, QByteArray &shaderData, QByteArray &shaderPathKey);

Q_QUICK3D_EXPORT void setResolveFunction(ResolveFunction fn);

Q_QUICK3D_EXPORT QByteArray resolveShader(const QUrl &fileUrl, const QQmlContext *context, QByteArray &shaderPathKey);

Q_QUICK3D_EXPORT MetaTypeList supportedMetatypes();

template<QMetaType::Type>

struct ShaderType

};

Q_QUICK3D_EXPORT QByteArray uniformTypeName(QMetaType type);

Q_QUICK3D_EXPORT QByteArray uniformTypeName(QSSGRenderShaderValue::Type type);

Q_QUICK3D_EXPORT QSSGRenderShaderValue::Type uniformType(QMetaType type);

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsTextureInput : public QQuick3DObject

    Q_OBJECT

    Q_PROPERTY(QQuick3DTexture *texture READ texture WRITE setTexture NOTIFY textureChanged)

    Q_PROPERTY(bool enabled MEMBER enabled NOTIFY enabledChanged)

    QML_NAMED_ELEMENT(TextureInput)

public:

    explicit QQuick3DShaderUtilsTextureInput(QQuick3DObject *p = nullptr);

    virtual ~QQuick3DShaderUtilsTextureInput();

    QQuick3DTexture *m_texture = nullptr;

    bool enabled = true;

    QByteArray name;

    QQuick3DTexture *texture() const

        return m_texture;

public Q_SLOTS:

    void setTexture(QQuick3DTexture *texture);

Q_SIGNALS:

    void textureChanged();

    void enabledChanged();

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsBuffer : public QQuick3DObject

    Q_OBJECT

    Q_PROPERTY(TextureFormat format READ format WRITE setFormat NOTIFY changed)

    Q_PROPERTY(TextureFilterOperation textureFilterOperation READ textureFilterOperation WRITE setTextureFilterOperation NOTIFY changed)

    Q_PROPERTY(TextureCoordOperation textureCoordOperation READ textureCoordOperation WRITE setTextureCoordOperation NOTIFY changed)

    Q_PROPERTY(float sizeMultiplier MEMBER sizeMultiplier NOTIFY changed)

    Q_PROPERTY(AllocateBufferFlagValues bufferFlags READ bufferFlags WRITE setBufferFlags NOTIFY changed)

    Q_PROPERTY(QByteArray name MEMBER name NOTIFY changed)

    QML_NAMED_ELEMENT(Buffer)

public:

    QQuick3DShaderUtilsBuffer() = default;

    ~QQuick3DShaderUtilsBuffer() override = default;

    enum class TextureFilterOperation // must match QSSGRenderTextureFilterOp

        Unknown = 0,

        Nearest,

        Linear

};

    Q_ENUM(TextureFilterOperation)

    enum class TextureCoordOperation // must match QSSGRenderTextureCoordOp

        Unknown = 0,

        ClampToEdge,

        MirroredRepeat,

        Repeat

};

    Q_ENUM(TextureCoordOperation)

    enum class AllocateBufferFlagValues

        None = 0,

        SceneLifetime = 1

};

    Q_ENUM(AllocateBufferFlagValues)

    enum class TextureFormat {

        Unknown = 0,

        RGBA8,

        RGBA16F,

        RGBA32F,

R8,

        R16,

        R16F,

        R32F

};

    Q_ENUM(TextureFormat)

    QSSGAllocateBuffer command {};

    TextureFilterOperation textureFilterOperation() const { return TextureFilterOperation(command.m_filterOp); }

    void setTextureFilterOperation(TextureFilterOperation op);

    TextureCoordOperation textureCoordOperation() const { return TextureCoordOperation(command.m_texCoordOp); }

    void setTextureCoordOperation(TextureCoordOperation texCoordOp);

    float &sizeMultiplier = command.m_sizeMultiplier;

    QSSGCommand *cloneCommand() { return new QSSGAllocateBuffer(command); }

    TextureFormat format() const;

    void setFormat(TextureFormat format);

    AllocateBufferFlagValues bufferFlags() const { return AllocateBufferFlagValues(int(command.m_bufferFlags)); }

    void setBufferFlags(AllocateBufferFlagValues flag);

    QByteArray &name = command.m_name;

    static QSSGRenderTextureFormat::Format mapTextureFormat(QQuick3DShaderUtilsBuffer::TextureFormat fmt);

    static QQuick3DShaderUtilsBuffer::TextureFormat mapRenderTextureFormat(QSSGRenderTextureFormat::Format fmt);

Q_SIGNALS:

    void changed();

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsRenderCommand : public QQuick3DObject

    Q_OBJECT

    QML_NAMED_ELEMENT(Command)

public:

    QQuick3DShaderUtilsRenderCommand() = default;

    ~QQuick3DShaderUtilsRenderCommand() override = default;

    virtual QSSGCommand *cloneCommand() { Q_ASSERT(0); return nullptr; }

    virtual int bufferCount() const { return 0; }

    virtual QQuick3DShaderUtilsBuffer *bufferAt(int idx) const { Q_UNUSED(idx); return nullptr; }

Q_SIGNALS:

    void changed();

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsBufferInput : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    Q_PROPERTY(QQuick3DShaderUtilsBuffer *buffer READ buffer WRITE setBuffer)

    Q_PROPERTY(QByteArray sampler MEMBER sampler)

    QML_NAMED_ELEMENT(BufferInput)

public:

    QQuick3DShaderUtilsBufferInput() = default;

    ~QQuick3DShaderUtilsBufferInput() override = default;

    QSSGApplyBufferValue command { QByteArray(), QByteArray() };

    QByteArray &sampler = command.m_samplerName;

    QSSGCommand *cloneCommand() override { return new QSSGApplyBufferValue(command); }

    int bufferCount() const override { return (m_buffer != nullptr) ? 1 : 0; }

    QQuick3DShaderUtilsBuffer *bufferAt(int idx) const override

        Q_ASSERT(idx < 1 && idx >= 0);

        return (m_buffer && idx == 0) ? m_buffer : nullptr;

    QQuick3DShaderUtilsBuffer *buffer() const { return m_buffer; }

    void setBuffer(QQuick3DShaderUtilsBuffer *buffer) {

        if (m_buffer == buffer)

            return;

        if (buffer) {

            Q_ASSERT(!buffer->name.isEmpty());

            command.m_bufferName = buffer->name;

        m_buffer = buffer;

    QQuick3DShaderUtilsBuffer *m_buffer = nullptr;

};

class Q_QUICK3D_EXPORT QQuick3DRenderPassTargetBlend

    Q_GADGET

    Q_PROPERTY(bool enable MEMBER enable)

    Q_PROPERTY(ColorMask colorWrite MEMBER colorWrite)

    Q_PROPERTY(BlendFactor srcColor MEMBER srcColor)

    Q_PROPERTY(BlendFactor dstColor MEMBER dstColor)

    Q_PROPERTY(BlendOperation opColor MEMBER opColor)

    Q_PROPERTY(BlendFactor srcAlpha MEMBER srcAlpha)

    Q_PROPERTY(BlendFactor dstAlpha MEMBER dstAlpha)

    Q_PROPERTY(BlendOperation opAlpha MEMBER opAlpha)

    QML_VALUE_TYPE(renderTargetBlend)

    QML_ADDED_IN_VERSION(6, 11)

public:

    enum ColorMaskComponent : quint32 {

        R = 1 << 0,

        G = 1 << 1,

        B = 1 << 2,

        A = 1 << 3,

};

    Q_DECLARE_FLAGS(ColorMask, ColorMaskComponent)

    enum class BlendFactor {

        Zero,

        One,

        SrcColor,

        OneMinusSrcColor,

        DstColor,

        OneMinusDstColor,

        SrcAlpha,

        OneMinusSrcAlpha,

        DstAlpha,

        OneMinusDstAlpha,

        ConstantColor,

        OneMinusConstantColor,

        ConstantAlpha,

        OneMinusConstantAlpha,

        SrcAlphaSaturate,

        Src1Color,

        OneMinusSrc1Color,

        Src1Alpha,

        OneMinusSrc1Alpha

};

    Q_ENUM(BlendFactor)

    enum class BlendOperation {

        Add,

        Subtract,

        ReverseSubtract,

        Min,

Max

};

    Q_ENUM(BlendOperation)

    ColorMask colorWrite = ColorMask(0xF); // R | G | B | A

    bool enable = false;

    BlendFactor srcColor = BlendFactor::One;

    BlendFactor dstColor = BlendFactor::OneMinusSrcAlpha;

    BlendOperation opColor = BlendOperation::Add;

    BlendFactor srcAlpha = BlendFactor::One;

    BlendFactor dstAlpha = BlendFactor::OneMinusSrcAlpha;

    BlendOperation opAlpha = BlendOperation::Add;

    bool operator==(const QQuick3DRenderPassTargetBlend &other) const

        return colorWrite == other.colorWrite

            && enable == other.enable

            && srcColor == other.srcColor

            && dstColor == other.dstColor

            && opColor == other.opColor

            && srcAlpha == other.srcAlpha

            && dstAlpha == other.dstAlpha

            && opAlpha == other.opAlpha;

    QQuick3DRenderPassTargetBlend() = default;

    QQuick3DRenderPassTargetBlend(QRhiGraphicsPipeline::TargetBlend targetBlend)

        : colorWrite(ColorMask(targetBlend.colorWrite.toInt()))

        , enable(targetBlend.enable)

        , srcColor(BlendFactor(targetBlend.srcColor))

        , dstColor(BlendFactor(targetBlend.dstColor))

        , opColor(BlendOperation(targetBlend.opColor))

        , srcAlpha(BlendFactor(targetBlend.srcAlpha))

        , dstAlpha(BlendFactor(targetBlend.dstAlpha))

        , opAlpha(BlendOperation(targetBlend.opAlpha))

    QRhiGraphicsPipeline::TargetBlend toRhiTargetBlend() const

        QRhiGraphicsPipeline::TargetBlend tb;

        tb.colorWrite = QRhiGraphicsPipeline::ColorMask(colorWrite.toInt());

        tb.enable = enable;

        tb.srcColor = QRhiGraphicsPipeline::BlendFactor(int(srcColor));

        tb.dstColor = QRhiGraphicsPipeline::BlendFactor(int(dstColor));

        tb.opColor = QRhiGraphicsPipeline::BlendOp(int(opColor));

        tb.srcAlpha = QRhiGraphicsPipeline::BlendFactor(int(srcAlpha));

        tb.dstAlpha = QRhiGraphicsPipeline::BlendFactor(int(dstAlpha));

        tb.opAlpha = QRhiGraphicsPipeline::BlendOp(int(opAlpha));

        return tb;

};

namespace QQuick3DRenderTargetBlendForeign

Q_NAMESPACE_EXPORT(Q_QUICK3D_EXPORT)

QML_FOREIGN_NAMESPACE(QQuick3DRenderPassTargetBlend)

QML_NAMED_ELEMENT(RenderTargetBlend)

QML_ADDED_IN_VERSION(6, 11)

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsPipelineStateOverride : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    Q_PROPERTY(bool depthTestEnabled READ depthTestEnabled WRITE setDepthTestEnabled RESET resetDepthTestEnabled NOTIFY depthTestEnabledChanged)

    Q_PROPERTY(bool depthWriteEnabled READ depthWriteEnabled WRITE setDepthWriteEnabled RESET resetDepthWriteEnabled NOTIFY depthWriteEnabledChanged)

    Q_PROPERTY(bool blendEnabled READ blendEnabled WRITE setBlendEnabled RESET resetBlendEnabled NOTIFY blendEnabledChanged FINAL)

    Q_PROPERTY(bool usesStencilReference READ usesStencilReference WRITE setUsesStencilReference RESET resetUsesStencilReference NOTIFY usesStencilReferenceChanged)

    Q_PROPERTY(bool usesScissor READ usesScissor WRITE setUsesScissor RESET resetUsesScissor NOTIFY usesScissorChanged)

    Q_PROPERTY(CompareOperation depthFunction READ depthFunction WRITE setDepthFunction RESET resetDepthFunction NOTIFY depthFunctionChanged)

    Q_PROPERTY(CullMode cullMode READ cullMode WRITE setCullMode RESET resetCullMode NOTIFY cullModeChanged)

    Q_PROPERTY(PolygonMode polygonMode READ polygonMode WRITE setPolygonMode RESET resetPolygonMode NOTIFY polygonModeChanged)

    Q_PROPERTY(quint32 stencilWriteMask READ stencilWriteMask WRITE setStencilWriteMask RESET resetStencilWriteMask NOTIFY stencilWriteMaskChanged)

    Q_PROPERTY(quint32 stencilReference READ stencilReference WRITE setStencilReference RESET resetStencilReference NOTIFY stencilReferenceChanged)

    Q_PROPERTY(QRectF viewport READ viewport WRITE setViewport RESET resetViewport NOTIFY viewportChanged)

    Q_PROPERTY(QRect scissor READ scissor WRITE setScissor RESET resetScissor NOTIFY scissorChanged)

    Q_PROPERTY(QQuick3DRenderPassTargetBlend targetBlend0 READ targetBlend0 WRITE setTargetBlend0 RESET resetTargetBlend0 NOTIFY targetBlend0Changed)

    Q_PROPERTY(QQuick3DRenderPassTargetBlend targetBlend1 READ targetBlend1 WRITE setTargetBlend1 RESET resetTargetBlend1 NOTIFY targetBlend1Changed)

    Q_PROPERTY(QQuick3DRenderPassTargetBlend targetBlend2 READ targetBlend2 WRITE setTargetBlend2 RESET resetTargetBlend2 NOTIFY targetBlend2Changed)

    Q_PROPERTY(QQuick3DRenderPassTargetBlend targetBlend3 READ targetBlend3 WRITE setTargetBlend3 RESET resetTargetBlend3 NOTIFY targetBlend3Changed)

    Q_PROPERTY(QQuick3DRenderPassTargetBlend targetBlend4 READ targetBlend4 WRITE setTargetBlend4 RESET resetTargetBlend4 NOTIFY targetBlend4Changed)

    Q_PROPERTY(QQuick3DRenderPassTargetBlend targetBlend5 READ targetBlend5 WRITE setTargetBlend5 RESET resetTargetBlend5 NOTIFY targetBlend5Changed)

    Q_PROPERTY(QQuick3DRenderPassTargetBlend targetBlend6 READ targetBlend6 WRITE setTargetBlend6 RESET resetTargetBlend6 NOTIFY targetBlend6Changed)

    Q_PROPERTY(QQuick3DRenderPassTargetBlend targetBlend7 READ targetBlend7 WRITE setTargetBlend7 RESET resetTargetBlend7 NOTIFY targetBlend7Changed)

    QML_NAMED_ELEMENT(PipelineStateOverride)

    QML_ADDED_IN_VERSION(6, 11)

public:

    enum class CompareOperation {

        Never,

        Less,

        Equal,

        LessOrEqual,

        Greater,

        NotEqual,

        GreaterOrEqual,

        Always

};

    Q_ENUM(CompareOperation)

    enum class CullMode {

        None,

        Front,

        Back

};

    Q_ENUM(CullMode)

    enum class PolygonMode {

        Fill,

        Line

};

    Q_ENUM(PolygonMode)

    QQuick3DShaderUtilsPipelineStateOverride();

    ~QQuick3DShaderUtilsPipelineStateOverride() override;

    bool depthTestEnabled() const;

    void setDepthTestEnabled(bool newDepthTestEnabled);

    void resetDepthTestEnabled();

    bool depthWriteEnabled() const;

    void setDepthWriteEnabled(bool newDepthWriteEnabled);

    void resetDepthWriteEnabled();

    bool blendEnabled() const;

    void setBlendEnabled(bool newBlendEnabled);

    void resetBlendEnabled();

    bool usesStencilReference() const;

    void setUsesStencilReference(bool newUsesStencilReference);

    void resetUsesStencilReference();

    bool usesScissor() const;

    void setUsesScissor(bool newUsesScissor);

    void resetUsesScissor();

    CompareOperation depthFunction() const;

    void setDepthFunction(CompareOperation newDepthFunction);

    void resetDepthFunction();

    CullMode cullMode() const;

    void setCullMode(CullMode newCullMode);

    void resetCullMode();

    PolygonMode polygonMode() const;

    void setPolygonMode(PolygonMode newPolygonMode);

    void resetPolygonMode();

    quint32 stencilWriteMask() const;

    void setStencilWriteMask(quint32 newStencilWriteMask);

    void resetStencilWriteMask();

    quint32 stencilReference() const;

    void setStencilReference(quint32 newStencilReference);

    void resetStencilReference();

    QRectF viewport() const;

    void setViewport(const QRectF &newViewport);

    void resetViewport();

    QRect scissor() const;

    void setScissor(const QRect &newScissor);

    void resetScissor();

    QQuick3DRenderPassTargetBlend targetBlend0() const;

    void setTargetBlend0(const QQuick3DRenderPassTargetBlend &newTargetBlend0);

    void resetTargetBlend0();

    QQuick3DRenderPassTargetBlend targetBlend1() const;

    void setTargetBlend1(const QQuick3DRenderPassTargetBlend &newTargetBlend1);

    void resetTargetBlend1();

    QQuick3DRenderPassTargetBlend targetBlend2() const;

    void setTargetBlend2(const QQuick3DRenderPassTargetBlend &newTargetBlend2);

    void resetTargetBlend2();

    QQuick3DRenderPassTargetBlend targetBlend3() const;

    void setTargetBlend3(const QQuick3DRenderPassTargetBlend &newTargetBlend3);

    void resetTargetBlend3();

    QQuick3DRenderPassTargetBlend targetBlend4() const;

    void setTargetBlend4(const QQuick3DRenderPassTargetBlend &newTargetBlend4);

    void resetTargetBlend4();

    QQuick3DRenderPassTargetBlend targetBlend5() const;

    void setTargetBlend5(const QQuick3DRenderPassTargetBlend &newTargetBlend5);

    void resetTargetBlend5();

    QQuick3DRenderPassTargetBlend targetBlend6() const;

    void setTargetBlend6(const QQuick3DRenderPassTargetBlend &newTargetBlend6);

    void resetTargetBlend6();

    QQuick3DRenderPassTargetBlend targetBlend7() const;

    void setTargetBlend7(const QQuick3DRenderPassTargetBlend &newTargetBlend7);

    void resetTargetBlend7();

Q_SIGNALS:

    void depthTestEnabledChanged();

    void depthWriteEnabledChanged();

    void blendEnabledChanged();

    void usesStencilReferenceChanged();

    void usesScissorChanged();

    void depthFunctionChanged();

    void cullModeChanged();

    void polygonModeChanged();

    void stencilWriteMaskChanged();

    void stencilReferenceChanged();

    void viewportChanged();

    void scissorChanged();

    void targetBlend0Changed();

    void targetBlend1Changed();

    void targetBlend2Changed();

    void targetBlend3Changed();

    void targetBlend4Changed();

    void targetBlend5Changed();

    void targetBlend6Changed();

    void targetBlend7Changed();

private:

    QSSGCommand *cloneCommand() override { return new QSSGPipelineStateOverrideCommand(command); }

    QSSGPipelineStateOverrideCommand command { };

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsApplyValue : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    Q_PROPERTY(QByteArray target MEMBER target)

    Q_PROPERTY(QVariant value MEMBER value)

    QML_NAMED_ELEMENT(SetUniformValue)

public:

    QQuick3DShaderUtilsApplyValue() = default;

    ~QQuick3DShaderUtilsApplyValue() override = default;

    QSSGCommand *cloneCommand() override { return new QSSGApplyValue(command); }

    QSSGApplyValue command { };

    QVariant &value = command.m_value;

    QByteArray &target = command.m_propertyName;

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsRenderablesFilter : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    Q_PROPERTY(quint32 layerMask MEMBER layerMask)

    Q_PROPERTY(RenderableTypes renderableTypes READ renderableTypes WRITE setRenderableTypes)

    QML_NAMED_ELEMENT(RenderablesFilter)

    QML_ADDED_IN_VERSION(6, 11)

public:

    enum class RenderableType : quint32 {

        None = 0x0,

        Opaque = 0x1,

        Transparent = 0x2,

};

    Q_DECLARE_FLAGS(RenderableTypes, RenderableType)

    Q_FLAG(RenderableTypes)

    QQuick3DShaderUtilsRenderablesFilter() = default;

    ~QQuick3DShaderUtilsRenderablesFilter() override;

    RenderableTypes renderableTypes() const;

    void setRenderableTypes(RenderableTypes types);

    QSSGCommand *cloneCommand() override { return new QSSGRenderablesFilterCommand(command); }

    QSSGRenderablesFilterCommand command { };

    quint32 &layerMask = command.layerMask;

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsRenderPassTexture : public QQuick3DObject

    Q_OBJECT

    Q_PROPERTY(TextureFormat format READ format WRITE setFormat FINAL)

    QML_NAMED_ELEMENT(RenderPassTexture)

    QML_ADDED_IN_VERSION(6, 11)

public:

    enum class TextureFormat {

        Unknown = 0,

        RGBA8,

        RGBA16F,

        RGBA32F,

R8,

        R16,

        R16F,

        R32F,

        Depth16,

        Depth24,

        Depth32,

        Depth24Stencil8,

};

    Q_ENUM(TextureFormat)

    QQuick3DShaderUtilsRenderPassTexture() = default;

    ~QQuick3DShaderUtilsRenderPassTexture() override;

    TextureFormat format() const;

    void setFormat(TextureFormat newFormat);

    std::shared_ptr<QSSGAllocateTexture> command;

private:

    friend class QQuick3DShaderUtilsRenderPassColorAttachment;

    friend class QQuick3DShaderUtilsRenderPassDepthTextureAttachment;

private:

    static QSSGRenderTextureFormat asRenderTextureFormat(QQuick3DShaderUtilsRenderPassTexture::TextureFormat fmt);

    static QQuick3DShaderUtilsRenderPassTexture::TextureFormat fromRenderTextureFormat(QSSGRenderTextureFormat fmt);

};

// Class for user defined color attachments in render passes

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsRenderPassColorAttachment : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    Q_PROPERTY(QQuick3DShaderUtilsRenderPassTexture *target MEMBER target)

    Q_PROPERTY(QByteArray name READ name WRITE setName FINAL)

    QML_NAMED_ELEMENT(ColorAttachment)

    QML_ADDED_IN_VERSION(6, 11)

public:

    QQuick3DShaderUtilsRenderPassColorAttachment() = default;

    ~QQuick3DShaderUtilsRenderPassColorAttachment() override;

    QByteArray name() const;

    void setName(const QByteArray &newName);

    QSSGCommand *cloneCommand() override;

private:

    QPointer<QQuick3DShaderUtilsRenderPassTexture> target;

    QByteArray m_name;

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsRenderPassDepthTextureAttachment : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    Q_PROPERTY(QQuick3DShaderUtilsRenderPassTexture *target MEMBER target)

    QML_NAMED_ELEMENT(DepthTextureAttachment)

    QML_ADDED_IN_VERSION(6, 11)

public:

    QQuick3DShaderUtilsRenderPassDepthTextureAttachment() = default;

    ~QQuick3DShaderUtilsRenderPassDepthTextureAttachment() override;

    QSSGCommand *cloneCommand() override;

    QPointer<QQuick3DShaderUtilsRenderPassTexture> target;

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsRenderPassDepthStencilAttachment : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    QML_NAMED_ELEMENT(DepthStencilAttachment)

    QML_ADDED_IN_VERSION(6, 11)

public:

    QQuick3DShaderUtilsRenderPassDepthStencilAttachment() = default;

    ~QQuick3DShaderUtilsRenderPassDepthStencilAttachment() override;

    QSSGCommand *cloneCommand() override;

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsRenderPassAddDefine : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    Q_PROPERTY(QByteArray name READ name WRITE setName NOTIFY nameChanged)

    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)

    QML_NAMED_ELEMENT(AddDefine)

    QML_ADDED_IN_VERSION(6, 11)

public:

    QQuick3DShaderUtilsRenderPassAddDefine();

    ~QQuick3DShaderUtilsRenderPassAddDefine() override;

    QSSGCommand *cloneCommand() override;

    QByteArray name() const;

    void setName(const QByteArray &newName);

    int value() const;

    void setValue(int newValue);

    QSSGAddShaderDefine command;

Q_SIGNALS:

    void nameChanged();

    void valueChanged();

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsSubRenderPass : public QQuick3DShaderUtilsRenderCommand

    Q_OBJECT

    Q_PROPERTY(QQuick3DRenderPass *renderPass READ renderPass WRITE setRenderPass NOTIFY renderPassChanged FINAL)

    QML_NAMED_ELEMENT(SubRenderPass)

    QML_ADDED_IN_VERSION(6, 11)

public:

    QQuick3DShaderUtilsSubRenderPass() = default;

    ~QQuick3DShaderUtilsSubRenderPass() override;

    QQuick3DRenderPass *renderPass() const;

    void setRenderPass(QQuick3DRenderPass *newRenderPass);

    QSSGCommand *cloneCommand() override;

signals:

    void renderPassChanged();

protected:

    virtual QSSGRenderGraphObject *updateSpatialNode(QSSGRenderGraphObject *node) final;

    virtual void itemChange(ItemChange change, const ItemChangeData &value) final;

private:

    void updateSceneManager(QQuick3DSceneManager *sceneManager);

    QPointer<QQuick3DRenderPass> m_renderPass;

    mutable bool m_hasWarnedAboutInvalidId = false;

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsRenderPass : public QQuick3DObject

    Q_OBJECT

    Q_PROPERTY(QQmlListProperty<QQuick3DShaderUtilsRenderCommand> commands READ commands)

    Q_PROPERTY(QQuick3DShaderUtilsBuffer *output MEMBER outputBuffer)

    Q_PROPERTY(QQmlListProperty<QQuick3DShaderUtilsShader> shaders READ shaders)

    QML_NAMED_ELEMENT(Pass)

    QML_ADDED_IN_VERSION(6, 11)

public:

    QQuick3DShaderUtilsRenderPass() = default;

    ~QQuick3DShaderUtilsRenderPass() override;

    static void qmlAppendCommand(QQmlListProperty<QQuick3DShaderUtilsRenderCommand> *list, QQuick3DShaderUtilsRenderCommand *command);

    static QQuick3DShaderUtilsRenderCommand *qmlCommandAt(QQmlListProperty<QQuick3DShaderUtilsRenderCommand> *list, qsizetype index);

    static qsizetype qmlCommandCount(QQmlListProperty<QQuick3DShaderUtilsRenderCommand> *list);

    static void qmlCommandClear(QQmlListProperty<QQuick3DShaderUtilsRenderCommand> *list);

    static void qmlAppendShader(QQmlListProperty<QQuick3DShaderUtilsShader> *list, QQuick3DShaderUtilsShader *shader);

    static QQuick3DShaderUtilsShader *qmlShaderAt(QQmlListProperty<QQuick3DShaderUtilsShader> *list, qsizetype index);

    static qsizetype qmlShaderCount(QQmlListProperty<QQuick3DShaderUtilsShader> *list);

    static void qmlShaderClear(QQmlListProperty<QQuick3DShaderUtilsShader> *list);

    QQmlListProperty<QQuick3DShaderUtilsRenderCommand> commands();

    QVector<QQuick3DShaderUtilsRenderCommand *> m_commands;

    QQuick3DShaderUtilsBuffer *outputBuffer = nullptr;

    QQmlListProperty<QQuick3DShaderUtilsShader> shaders();

    QVarLengthArray<QQuick3DShaderUtilsShader *, 2> m_shaders;

Q_SIGNALS:

    void changed();

};

class Q_QUICK3D_EXPORT QQuick3DShaderUtilsShader : public QQuick3DObject

    Q_OBJECT

    Q_PROPERTY(QUrl shader MEMBER shader NOTIFY shaderChanged)

    Q_PROPERTY(Stage stage MEMBER stage NOTIFY stageChanged)

    QML_NAMED_ELEMENT(Shader)

public:

    QQuick3DShaderUtilsShader() = default;

    virtual ~QQuick3DShaderUtilsShader() = default;

    enum class Stage : quint8

        Vertex = 0,

        Fragment = 1

};

    Q_ENUM(Stage)

    QUrl shader;

    Stage stage = Stage::Fragment;

Q_SIGNALS:

    void shaderChanged();

    void stageChanged();

};

template<typename T, typename std::enable_if_t<std::is_base_of_v<QQuick3DObject, T>, bool> = true>

class QQuick3DSuperClassInfo

public:

    QQuick3DSuperClassInfo() = default;

    static const char *superClassName()

        return T::staticMetaObject.className();

};

class QQuick3DPropertyChangedTracker;

class QQuick3DPropertyWatcher : public QObject

    Q_OBJECT

public:

    QQuick3DPropertyWatcher(QQuick3DPropertyChangedTracker *tracker, QMetaProperty property);

public Q_SLOTS:

    void onValuePropertyChanged();

    void onPointerPropertyChanged();

private:

    QQuick3DPropertyChangedTracker *m_tracker = nullptr;

    QMetaProperty m_property;

};

class Q_QUICK3D_EXPORT QQuick3DPropertyChangedTracker

public:

    enum class DirtyPropertyHint

        Value,

        Reference,

};

    template<typename T>

    explicit QQuick3DPropertyChangedTracker(QQuick3DObject *owner, QQuick3DSuperClassInfo<T> info)

        : m_owner(owner)

        , m_superClassName(info.superClassName())

        Q_ASSERT(m_owner != nullptr);

    virtual ~QQuick3DPropertyChangedTracker();

    using UniformProperty = QSSGUserShaderAugmentation::Property;

    using UniformPropertyList = QVector<UniformProperty>;

protected:

    friend class QQuick3DPropertyWatcher;

    // Will re-use already extracted list and update dirty properties

    QList<UniformProperty> extractProperties();

    void addPropertyWatcher(QMetaProperty property, DirtyPropertyHint hint, QQuick3DObject *object = nullptr);

    virtual void markTrackedPropertyDirty(QMetaProperty property, DirtyPropertyHint hint) = 0;

    struct Tracked

        QQuick3DPropertyWatcher *watcher = nullptr;

        QPointer<QQuick3DObject> object;

        int pid = -1;

};

    QHash<int, Tracked> m_trackedProperties;

    QQuick3DObject *m_owner = nullptr;

    const char *m_superClassName = nullptr;

    QList<UniformProperty> m_propertyList; // always sorted by propertyIndex

private:

    std::optional<UniformProperty> createOrUpdateTrackedProperty(const QMetaProperty property, bool addWatchers);

    std::vector<int> m_dirtyProperties;

    bool m_extracted = false;

};

QT_END_NAMESPACE

Q_DECLARE_OPAQUE_POINTER(QQuick3DShaderUtilsTextureInput)

#endif // QQUICK3DSHADERUTILS_H