qquick3dshaderutils_p.h

++ // 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

Revision control