Revision control
+ // Copyright (C) 2026 The Qt Company Ltd.
+ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
+ // Qt-Security score:significant reason:default
+
+ #include "qquick3dquadtextureprovider_p.h"
+
+ #include <QtQuick3DRuntimeRender/private/qssgshadermaterialadapter_p.h>
+
+ #include <ssg/qssgrenderextensions.h>
+ #include <ssg/qssgrenderhelpers.h>
+ #include <ssg/qssgrendercontextcore.h>
+ #include <ssg/qquick3dextensionhelpers.h>
+
+
+ /*!
+ \qmltype QuadTextureProvider
+ \nativetype QQuick3DQuadTextureProvider
+ \inqmlmodule QtQuick3D.Helpers
+ \inherits TextureProviderExtension
+ \since 6.12
+ \brief Used to render a quad texture using a custom fragment shader.
+
+ This type is used to render quad textures using custom shader code, enabling a convenient way
+ to get programmable textures. By providing a fragment shader and wanted properties, a pass is created
+ and a shader pipeline is built based on the provided data, passing the properties in as uniform values
+ to the fragment shader.
+
+ Built-ins provided:
+
+ \table
+ \header
+ \li Keyword
+ \li Type
+ \li Description
+ \row
+ \li MAIN
+ \li
+ \li void MAIN() is the entry point. This function must always be present in the fragment shader provided.
+ \row
+ \li INPUT_UV
+ \li vec2
+ \li UV coordinates for current fragment. Top-right: [1, 1] and bottom-left: [0, 0].
+ \row
+ \li OUTPUT_SIZE
+ \li vec2
+ \li Size of the output texture.
+ \row
+ \endtable
+
+ Custom properties gets mapped to uniforms. Any time the values change, the updated
+ value will become visible in the shader. This concept may already be familiar from \l ShaderEffect.
+
+ The name of the QML property and the GLSL variable must match. There is no separate
+ declaration in the shader code for the individual uniforms. Rather, the QML property name
+ can be used as-is.
+
+ The following table lists how the types are mapped:
+
+ \table
+ \header
+ \li QML Type
+ \li Shader Type
+ \li Notes
+ \row
+ \li real, int, bool
+ \li float, int, bool
+ \li
+ \row
+ \li color
+ \li vec4
+ \li sRGB to linear conversion is performed implicitly
+ \row
+ \li vector2d
+ \li vec2
+ \li
+ \row
+ \li vector3d
+ \li vec3
+ \li
+ \row
+ \li vector4d
+ \li vec4
+ \li
+ \row
+ \li matrix4x4
+ \li mat4
+ \li
+ \row
+ \li quaternion
+ \li vec4
+ \li scalar value is \c w
+ \row
+ \li rect
+ \li vec4
+ \li
+ \row
+ \li point, size
+ \li vec2
+ \li
+ \row
+ \li TextureInput
+ \li sampler2D
+ \li
+ \endtable
+
+ An example of outputting a simple red texture could be done the following way:
+ \badcode
+ Texture {
+ textureProvider: QuadTextureProvider {
+ width: 128
+ height: 128
+ fragmentShaderCode: `
+ void MAIN() {
+ FRAGCOLOR = vec4(1.0, 0.0, 0.0, 1.0);
+ }
+ `
+ }
+ }
+ \endcode
+
+ Another example sampling from a \l Texture property and mixing with UV colors:
+ \badcode
+ Texture {
+ textureProvider: QuadTextureProvider {
+ fragmentShaderCode: `
+ void MAIN() {
+ vec2 uv = INPUT_UV;
+ vec4 c = texture(checkers, uv);
+ FRAGCOLOR = mix(c, vec4(uv, 1, 1), 0.5);
+ }`
+
+ property Texture checkers : Texture {
+ source: "../shared/maps/checkers2.png"
+ }
+ }
+ }
+ \endcode
+
+ The result is the following:
+ \image quadtextureprovider_checkers.webp
+
+ \note Providing a vertex shader is not supported, only a fragment shader.
+
+ \note If \l Texture properties are provided it will not render until the dependent textures are available.
+
+ \note There is currently no support for adding / removing properties at runtime, just modifying the original ones.
+
+ \sa ShaderEffect
+ */
+
+ /*!
+ \qmlproperty url QuadTextureProvider::fragmentShader
+ \since 6.12
+
+ Specifies the file with the snippet of custom fragment shader code.
+
+ The value is a URL and must either be a local file or use the qrc scheme to
+ access files embedded via the Qt resource system. Relative file paths
+ (without a scheme) are also accepted, in which case the file is treated as
+ relative to the component (the \c{.qml} file).
+
+ \warning Shader snippets are assumed to be trusted content. Application
+ developers are advised to carefully consider the potential implications
+ before allowing the loading of user-provided content that is not part of the
+ application.
+
+ \note If set, fragmentShaderCode will take precedence over fragmentShader.
+
+ \sa fragmentShaderCode
+ */
+
+ /*!
+ \qmlproperty string QuadTextureProvider::fragmentShaderCode
+ \since 6.12
+
+ Specifies a snippet of custom fragment shader code.
+
+ Used as a way to inline shader code as a string instead of providing a file.
+
+ \note If set, this property will take precedence over \l fragmentShader.
+
+ \sa fragmentShader
+ */
+
+ /*!
+ \qmlproperty int QuadTextureProvider::width
+ \since 6.12
+ \default 128
+
+ Specifies the width in pixels of the output texture.
+
+ \sa height
+ */
+
+ /*!
+ \qmlproperty int QuadTextureProvider::height
+ \since 6.12
+ \default 128
+
+ Specifies the height in pixels of the output texture.
+
+ \sa width
+ */
+
+ /*!
+ \qmlproperty enumeration QuadTextureProvider::format
+ \since 6.12
+ \default TexureData.RGBA16F
+
+ This property holds the format of the output texture.
+
+ \value TexureData.RGBA8 The color format is considered as 8-bit integer in R, G, B and alpha channels.
+ \value TexureData.RGBA16F The color format is considered as 16-bit float in R,G,B and alpha channels.
+ \value TexureData.RGBA32F The color format is considered as 32-bit float in R, G, B and alpha channels.
+ \value TexureData.RGBE8 The color format is considered as 8-bit mantissa in the R, G, and B channels and 8-bit shared exponent.
+ \value TexureData.R8 The color format is considered as 8-bit integer in R channel.
+ \value TexureData.R16 The color format is considered as 16-bit integer in R channel.
+ \value TexureData.R16F The color format is considered as 16-bit float in R channel.
+ \value TexureData.R32F The color format is considered as 32-bit float R channel.
+
+ \note With the exception of \c TexureData.RGBA8, not every format is supported at runtime as this
+ depends on which backend is being used as well which hardware is being used.
+ */
+
+ QT_BEGIN_NAMESPACE
+
+ static constexpr float g_vertexData[] = { -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
+ 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f };
+
+ static constexpr uint16_t g_indexData[] = { 0, 1, 2, 0, 2, 3 };
+
+ static const QByteArray mainVertexSnippet = R"(
+ void main()
+ {
+ qt_inputUV = attr_uv;
+ gl_Position = vec4(attr_pos, 0.0, 1.0);
+ }
+ )";
+
+ static const QByteArray mainVertexSnippetFlipped = R"(
+ void main()
+ {
+ qt_inputUV = attr_uv;
+ qt_inputUV.y = 1.0 - qt_inputUV.y;
+ gl_Position = vec4(attr_pos, 0.0, 1.0);
+ }
+ )";
+
+ static const QByteArray mainFragmentSnippet = R"(
+ void main()
+ {
+ qt_customMain();
+ }
+ )";
+
+ static const QByteArray fallbackFragmentShaderStr = R"(
+ void MAIN()
+ {
+ FRAGCOLOR = vec4(1.0, 0.0, 1.0, 1.0);
+ }
+ )";
+
+ static inline void insertVertexMainArgs(QByteArray &snippet)
+ {
+ static const char *argKey = "/*%QT_ARGS_MAIN%*/";
+ const int argKeyLen = int(strlen(argKey));
+ const int argKeyPos = snippet.indexOf(argKey);
+ if (argKeyPos >= 0)
+ snippet = snippet.left(argKeyPos) + QByteArrayLiteral("inout vec3 VERTEX") + snippet.mid(argKeyPos + argKeyLen);
+ }
+
+ namespace {
+
+ QRhiTexture::Format rhiTextureFormatFromTextureDataFormat(QQuick3DTextureData::Format format)
+ {
+ switch (format) {
+ case QQuick3DTextureData::RGBA8:
+ return QRhiTexture::Format::RGBA8;
+ case QQuick3DTextureData::RGBA16F:
+ return QRhiTexture::Format::RGBA16F;
+ case QQuick3DTextureData::RGBA32F:
+ return QRhiTexture::Format::RGBA32F;
+ case QQuick3DTextureData::RGBE8:
+ return QRhiTexture::Format::RGBA8;
+ case QQuick3DTextureData::R8:
+ return QRhiTexture::Format::R8;
+ case QQuick3DTextureData::R16:
+ return QRhiTexture::Format::R16;
+ case QQuick3DTextureData::R16F:
+ return QRhiTexture::Format::R16F;
+ case QQuick3DTextureData::R32F:
+ return QRhiTexture::Format::R32F;
+ default:
+ return QRhiTexture::Format::RGBA8;
+ }
+ Q_UNREACHABLE_RETURN(QRhiTexture::Format::RGBA8);
+ }
+
+ QByteArray generateFinalVertexShaderCode(QRhi *rhi,
+ QSSGShaderCustomMaterialAdapter::StringPairList uniforms,
+ QSSGShaderCustomMaterialAdapter::StringPairList varyings)
+ {
+ // Handle d3d flipped textures
+ const bool doFlip = rhi->isYUpInNDC() && !rhi->isYUpInFramebuffer();
+ QByteArray vertexShader = doFlip ? mainVertexSnippetFlipped : mainVertexSnippet;
+
+ QSSGShaderCustomMaterialAdapter::ShaderCodeAndMetaData result;
+ QByteArray buf;
+ QSSGShaderCustomMaterialAdapter::CustomShaderPrepWorkData scratch;
+ QSSGShaderCustomMaterialAdapter::beginPrepareCustomShader(&scratch, &result, vertexShader, QSSGShaderCache::ShaderType::Vertex, false);
+ QSSGShaderCustomMaterialAdapter::finishPrepareCustomShader(&buf,
+ scratch,
+ result,
+ QSSGShaderCache::ShaderType::Vertex,
+ false,
+ uniforms,
+ { },
+ varyings,
+ { },
+ { });
+ insertVertexMainArgs(result.first);
+ return result.first + buf;
+ }
+
+ QByteArray generateFinalFragmentShaderCode(const QByteArray &baseFragmentShaderCode,
+ QSSGShaderCustomMaterialAdapter::StringPairList uniforms,
+ QSSGShaderCustomMaterialAdapter::StringPairList varyings)
+ {
+ QSSGShaderCustomMaterialAdapter::ShaderCodeAndMetaData result;
+ QByteArray buf;
+ QSSGShaderCustomMaterialAdapter::CustomShaderPrepWorkData scratch;
+ QSSGShaderCustomMaterialAdapter::beginPrepareCustomShader(&scratch, &result, baseFragmentShaderCode, QSSGShaderCache::ShaderType::Fragment, false);
+ QSSGShaderCustomMaterialAdapter::finishPrepareCustomShader(&buf,
+ scratch,
+ result,
+ QSSGShaderCache::ShaderType::Fragment,
+ false,
+ uniforms,
+ varyings,
+ { },
+ { },
+ { });
+ return result.first + buf;
+ }
+
+ QSSGRhiShaderPipelinePtr compileShader(QSSGRenderContextInterface *sgContext,
+ const QByteArray &shaderPathKey,
+ const QByteArray &vertexShader,
+ const QByteArray &fragmentShader)
+ {
+ QSSGProgramGenerator *generator = sgContext->shaderProgramGenerator().get();
+ QSSGShaderLibraryManager *shaderLib = sgContext->shaderLibraryManager().get();
+ QSSGShaderCache *shaderCache = sgContext->shaderCache().get();
+
+ generator->beginProgram();
+ auto vertex = generator->getStage(QSSGShaderGeneratorStage::Vertex);
+ vertex->addIncoming("attr_pos", "vec2");
+ vertex->addIncoming("attr_uv", "vec2");
+ vertex->append(vertexShader);
+
+ generator->getStage(QSSGShaderGeneratorStage::Fragment)->append(fragmentShader);
+
+ QSSGShaderFeatures features;
+ const QByteArray key = shaderPathKey + ':'
+ + QCryptographicHash::hash(QByteArray(vertexShader + fragmentShader), QCryptographicHash::Algorithm::Sha1)
+ .toHex();
+ return generator->compileGeneratedRhiShader(key, features, *shaderLib, *shaderCache, QSSGRhiShaderPipeline::UsedWithoutIa, { }, 1, false);
+ }
+
+ } // namespace
+
+ class QSSGQuadTextureProvider : public QSSGRenderTextureProviderExtension
+ {
+ public:
+ explicit QSSGQuadTextureProvider(QQuick3DQuadTextureProvider *ext);
+ ~QSSGQuadTextureProvider() override;
+ bool prepareData(QSSGFrameData &data) override;
+ void prepareRender(QSSGFrameData &data) override;
+ void render(QSSGFrameData &data) override;
+ void resetForFrame() override;
+
+ QQuick3DQuadTextureProvider::DirtyT dirtyFlag = 0;
+
+ QByteArray fragmentShaderSource;
+ QList<QSSGBaseTypeProperty> propertyUniforms;
+ QQuick3DTextureData::Format format = QQuick3DTextureData::Format::RGBA16F;
+ int width = 128;
+ int height = 128;
+
+ QByteArray shaderPathKey = "quad texture provider --";
+
+ private:
+ QPointer<QQuick3DQuadTextureProvider> m_ext;
+
+ QSSGRhiShaderResourceBindingList m_srbBindings;
+ QSSGRhiShaderPipelinePtr m_shaderPipeline;
+
+ std::unique_ptr<QRhiBuffer> m_vertexBuffer;
+ std::unique_ptr<QRhiBuffer> m_indexBuffer;
+
+ std::unique_ptr<QRhiTexture> m_outputTexture;
+ std::unique_ptr<QRhiTexture> m_outputTextureOld;
+ std::unique_ptr<QRhiTextureRenderTarget> m_renderTarget;
+ std::unique_ptr<QRhiRenderPassDescriptor> m_renderPassDesc;
+
+ std::unique_ptr<QRhiGraphicsPipeline> m_graphicsPipeline;
+ QRhiShaderResourceBindings* m_srb = nullptr; // not owned
+ };
+
+ QSSGQuadTextureProvider::QSSGQuadTextureProvider(QQuick3DQuadTextureProvider *ext) : m_ext(ext) { }
+
+ QSSGQuadTextureProvider::~QSSGQuadTextureProvider() { }
+
+ bool QSSGQuadTextureProvider::prepareData(QSSGFrameData &data)
+ {
+ QSSGRenderContextInterface *ctxIfx = data.contextInterface();
+ auto bufferManager = ctxIfx->bufferManager().get();
+ QSSGRhiContext *rhiCtx = ctxIfx->rhiContext().get();
+ if (!rhiCtx)
+ return false;
+
+ QSSGExtensionId extensionId = m_ext ? QQuick3DExtensionHelpers::getExtensionId(*m_ext) : QSSGExtensionId { };
+ if (QQuick3DExtensionHelpers::isNull(extensionId))
+ return false;
+
+ // TODO: should know if new properties are added or removed
+ bool needsRebuild = false;
+ if (dirtyFlag & QQuick3DQuadTextureProvider::Dirty::Dimensions)
+ needsRebuild = true;
+ if (dirtyFlag & QQuick3DQuadTextureProvider::Dirty::Format)
+ needsRebuild = true;
+ if (dirtyFlag & QQuick3DQuadTextureProvider::Dirty::FragmentShader)
+ needsRebuild = true;
+ if (m_shaderPipeline && !needsRebuild)
+ return dirtyFlag & QQuick3DQuadTextureProvider::Dirty::TrackedProperty;
+
+ if (!m_shaderPipeline || dirtyFlag & QQuick3DQuadTextureProvider::Dirty::FragmentShader) {
+ // Run through all inputs and if any texture is not created yet wait until next frame.
+ // The problem with textures not created yet is that they are assumed to be sampler2DArray in glsl but
+ // that could cause shader compilation failures so we need to know the actual type before trying to compile.
+ for (const auto &u : std::as_const(propertyUniforms)) {
+ if (u.shaderDataType == QSSGRenderShaderValue::Texture) {
+ QSSGRenderImage *image = u.value.value<QSSGRenderImage *>();
+ const QSSGRenderImageTexture texture = image ? bufferManager->loadRenderImage(image) : QSSGRenderImageTexture { };
+ if (!image || !texture.m_texture) {
+ return false;
+ }
+ }
+ }
+
+ QByteArray fragmentShaderCode = (!fragmentShaderSource.isEmpty() ? fragmentShaderSource : fallbackFragmentShaderStr)
+ + mainFragmentSnippet;
+
+ QSSGShaderCustomMaterialAdapter::StringPairList baseUniforms;
+ for (const auto &u : std::as_const(propertyUniforms))
+ baseUniforms.append({ u.typeName, u.name });
+
+ baseUniforms.append({ "vec2", "qt_outputSize" });
+
+ QSSGShaderCustomMaterialAdapter::StringPairList baseInputOutputs;
+ baseInputOutputs.append({ "vec2", "qt_inputUV" });
+
+ QByteArray vertexShader = generateFinalVertexShaderCode(rhiCtx->rhi(), baseUniforms, baseInputOutputs);
+ QByteArray fragmentShader = generateFinalFragmentShaderCode(fragmentShaderCode, baseUniforms, baseInputOutputs);
+
+ QSSGRenderContextInterface *sgContext = data.contextInterface();
+
+ m_shaderPipeline = compileShader(sgContext, shaderPathKey, vertexShader, fragmentShader);
+ // If there's an issue compiling try using the fallback fragment shader. Might be something wrong with the
+ // provided fragment shader, e.g. syntax error. This avoids asserting at runtime.
+ if (!m_shaderPipeline) {
+ fragmentShaderCode = fallbackFragmentShaderStr + mainFragmentSnippet;
+ fragmentShader = generateFinalFragmentShaderCode(fragmentShaderCode, baseUniforms, baseInputOutputs);
+ m_shaderPipeline = compileShader(sgContext, shaderPathKey, vertexShader, fragmentShader);
+ }
+ }
+
+ QRhi *rhi = rhiCtx->rhi();
+
+ if (!m_outputTexture || dirtyFlag & QQuick3DQuadTextureProvider::Dirty::Dimensions
+ || dirtyFlag & QQuick3DQuadTextureProvider::Dirty::Format) {
+ // Workaround: Preserve the previous texture until the end of the frame.
+ //
+ // QuadTextureProviders are rendered sequentially. If recreating the output
+ // texture destroys the old QRhiTexture immediately, consumers that have not
+ // rendered yet may still hold a pointer to the previous texture, resulting in
+ // a dangling reference during the current frame.
+ //
+ // By the next frame, surfaceChanged() will have propagated and consumers are
+ // expected to have updated to the new texture. The old texture is then released
+ // in resetForFrame().
+ if (m_outputTexture)
+ m_outputTextureOld = std::move(m_outputTexture);
+ m_outputTexture.reset(rhi->newTexture(rhiTextureFormatFromTextureDataFormat(format), QSize(width, height), 1, QRhiTexture::RenderTarget));
+ m_outputTexture->create();
+
+ m_renderTarget.reset(rhi->newTextureRenderTarget({ m_outputTexture.get() }));
+ m_renderPassDesc.reset(m_renderTarget->newCompatibleRenderPassDescriptor());
+ m_renderTarget->setRenderPassDescriptor(m_renderPassDesc.get());
+ m_renderTarget->create();
+
+ QSSGRenderExtensionHelpers::registerRenderResult(data, extensionId, m_outputTexture.get());
+
+ m_graphicsPipeline.reset();
+ }
+
+ return true;
+ }
+
+ void QSSGQuadTextureProvider::prepareRender(QSSGFrameData &data)
+ {
+ QSSGRenderContextInterface *ctxIfx = data.contextInterface();
+ QSSGRhiContext *rhiCtx = ctxIfx->rhiContext().get();
+ if (!rhiCtx || !m_shaderPipeline)
+ return;
+
+ QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
+ QRhi *rhi = rhiCtx->rhi();
+
+ QSSGRhiDrawCallData *dcd = &rhiCtxD->drawCallData({ (void *)this, nullptr, nullptr, 0 });
+ if (!dcd->ubuf) {
+ const int uniformStride = rhiCtx->rhi()->ubufAligned(m_shaderPipeline->ub0Size());
+ dcd->ubuf = rhiCtx->rhi()->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, uniformStride);
+ dcd->ubuf->create();
+ }
+
+ const bool trackedPropertyDirty = dirtyFlag & QQuick3DQuadTextureProvider::Dirty::TrackedProperty;
+ const bool dimensionsDirty = dirtyFlag & QQuick3DQuadTextureProvider::Dirty::Dimensions;
+ const bool pipelineDirty = !m_graphicsPipeline || (dirtyFlag & QQuick3DQuadTextureProvider::Dirty::Format)
+ || (dirtyFlag & QQuick3DQuadTextureProvider::Dirty::FragmentShader);
+ // SRB only needs rebuild when texture bindings may have changed
+ const bool srbDirty = pipelineDirty || trackedPropertyDirty || !m_srb;
+
+ // Update uniforms / textures
+ if (trackedPropertyDirty || dimensionsDirty) {
+
+ char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
+
+ if (trackedPropertyDirty) {
+ // rebuild transient texture list
+ m_shaderPipeline->resetExtraTextures();
+
+ QSSGBufferManager *bufferManager = ctxIfx->bufferManager().get();
+
+ for (const auto &u : std::as_const(propertyUniforms)) {
+ m_shaderPipeline->setShaderResources(ubufData, *bufferManager, u.name, u.value, u.shaderDataType);
+ }
+ }
+
+ if (dimensionsDirty) {
+ m_shaderPipeline->setUniformValue(ubufData, "qt_outputSize", QVector2D(width, height), QSSGRenderShaderValue::Vec2);
+ }
+ dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
+ }
+
+ // Static geometry (create once)
+ if (!m_vertexBuffer && !m_indexBuffer) {
+ // 1 quad (2 trianges), pos + uv. 4 vertices, 5 values each (x, y, z, u, v)
+ m_vertexBuffer.reset(rhi->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, 5 * 4 * sizeof(float)));
+ m_vertexBuffer->create();
+
+ // 6 indexes (2 triangles)
+ m_indexBuffer.reset(rhi->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::IndexBuffer, 6 * sizeof(uint16_t)));
+ m_indexBuffer->create();
+ QRhiResourceUpdateBatch *updates = rhi->nextResourceUpdateBatch();
+ updates->uploadStaticBuffer(m_vertexBuffer.get(), g_vertexData);
+ updates->uploadStaticBuffer(m_indexBuffer.get(), g_indexData);
+ rhiCtx->commandBuffer()->resourceUpdate(updates);
+ }
+
+ // SRB rebuild
+ if (srbDirty) {
+ rhiCtxD->releaseCachedSrb(m_srbBindings);
+ m_srbBindings = QSSGRhiShaderResourceBindingList();
+ m_srbBindings.addUniformBuffer(0, QRhiShaderResourceBinding::FragmentStage, dcd->ubuf);
+
+ // Add textures (mostly copy pasta from addOpaqueDepthPrePassBindings())
+ int maxSamplerBinding = -1;
+ QVector<QShaderDescription::InOutVariable> samplerVars = m_shaderPipeline->fragmentStage()->shader().description().combinedImageSamplers();
+ for (const QShaderDescription::InOutVariable &var :
+ m_shaderPipeline->vertexStage()->shader().description().combinedImageSamplers()) {
+ auto it = std::find_if(samplerVars.cbegin(), samplerVars.cend(), [&var](const QShaderDescription::InOutVariable &v) {
+ return var.binding == v.binding;
+ });
+ if (it == samplerVars.cend())
+ samplerVars.append(var);
+ }
+ for (const QShaderDescription::InOutVariable &var : std::as_const(samplerVars))
+ maxSamplerBinding = qMax(maxSamplerBinding, var.binding);
+
+ if (maxSamplerBinding >= 0) {
+ // custom property textures
+ int customTexCount = m_shaderPipeline->extraTextureCount();
+ for (int i = 0; i < customTexCount; ++i) {
+ const QSSGRhiTexture &t(m_shaderPipeline->extraTextureAt(i));
+ const int samplerBinding = m_shaderPipeline->bindingForTexture(t.name);
+ if (samplerBinding >= 0) {
+ QRhiSampler *sampler = rhiCtx->sampler(t.samplerDesc);
+ m_srbBindings.addTexture(samplerBinding, QRhiShaderResourceBinding::FragmentStage, t.texture, sampler);
+ }
+ }
+ }
+
+ m_srb = rhiCtxD->srb(m_srbBindings);
+ }
+
+ // Graphics pipeline rebuild
+ if (pipelineDirty) {
+
+ m_graphicsPipeline.reset(rhi->newGraphicsPipeline());
+ m_graphicsPipeline->setShaderStages({ *m_shaderPipeline->vertexStage(), *m_shaderPipeline->fragmentStage() });
+
+ // 2 Attributes, Position (vec3) + UV (vec2)
+ QRhiVertexInputLayout inputLayout;
+ inputLayout.setBindings({ { 5 * sizeof(float) } });
+ inputLayout.setAttributes({ { 0, 0, QRhiVertexInputAttribute::Float3, 0 },
+ { 0, 1, QRhiVertexInputAttribute::Float2, 3 * sizeof(float) } });
+ m_graphicsPipeline->setVertexInputLayout(inputLayout);
+ m_graphicsPipeline->setShaderResourceBindings(m_srb);
+ m_graphicsPipeline->setRenderPassDescriptor(m_renderPassDesc.get());
+
+ m_graphicsPipeline->create();
+ }
+
+ dirtyFlag = 0;
+ }
+
+ void QSSGQuadTextureProvider::render(QSSGFrameData &data)
+ {
+ const auto &ctxIfx = data.contextInterface();
+ const auto &rhiCtx = ctxIfx->rhiContext();
+ if (!rhiCtx)
+ return;
+
+ QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
+ cb->debugMarkBegin(QByteArrayLiteral("Quick3D Quad Texture Provider"));
+
+ cb->beginPass(m_renderTarget.get(), Qt::transparent, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());
+ cb->setViewport(QRhiViewport(0, 0, width, height));
+ cb->setScissor(QRhiScissor(0, 0, width, height));
+
+ cb->setGraphicsPipeline(m_graphicsPipeline.get());
+
+ QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());
+ auto srb = rhiCtxD->srb(m_srbBindings);
+ cb->setShaderResources(srb);
+
+ QRhiCommandBuffer::VertexInput vb(m_vertexBuffer.get(), 0);
+ cb->setVertexInput(0, 1, &vb, m_indexBuffer.get(), QRhiCommandBuffer::IndexFormat::IndexUInt16);
+ cb->drawIndexed(6);
+ cb->endPass();
+
+ cb->debugMarkEnd();
+
+ }
+
+ void QSSGQuadTextureProvider::resetForFrame() {
+ m_outputTextureOld.reset();
+ }
+
+ QQuick3DQuadTextureProvider::QQuick3DQuadTextureProvider(QQuick3DObject *parent)
+ : QQuick3DTextureProviderExtension(parent)
+ , QQuick3DPropertyChangedTracker(this, QQuick3DSuperClassInfo<QQuick3DQuadTextureProvider>())
+ {
+ }
+
+ QQuick3DQuadTextureProvider::~QQuick3DQuadTextureProvider() { }
+
+ QSSGRenderGraphObject *QQuick3DQuadTextureProvider::updateSpatialNode(QSSGRenderGraphObject *node)
+ {
+ auto n = static_cast<QSSGQuadTextureProvider *>(node);
+
+ if (!n) {
+ n = new QSSGQuadTextureProvider(this);
+ }
+
+ if (m_dirtyFlag & Dirty::Dimensions) {
+ n->width = m_width;
+ n->height = m_height;
+ }
+
+ if (m_dirtyFlag & Dirty::Format)
+ n->format = m_format;
+
+ if (m_dirtyFlag & Dirty::FragmentShader) {
+ const QQmlContext *context = qmlContext(this);
+ n->fragmentShaderSource = !m_fragmentShaderCode.isEmpty() ? m_fragmentShaderCode.toUtf8()
+ : !m_fragmentShader.isEmpty() ? QSSGShaderUtils::resolveShader(m_fragmentShader, context, n->shaderPathKey)
+ : QByteArray();
+ }
+
+ if (m_dirtyFlag & Dirty::TrackedProperty) {
+ n->propertyUniforms = extractProperties();
+ }
+
+ if (m_dirtyFlag != 0)
+ emit surfaceChanged();
+
+ n->dirtyFlag = m_dirtyFlag;
+ m_dirtyFlag = 0;
+
+ return n;
+ }
+
+ void QQuick3DQuadTextureProvider::markTrackedPropertyDirty(QMetaProperty property, DirtyPropertyHint hint)
+ {
+ Q_UNUSED(property);
+ Q_UNUSED(hint);
+ markDirty(Dirty::TrackedProperty);
+ }
+
+ void QQuick3DQuadTextureProvider::markDirty(Dirty v)
+ {
+ m_dirtyFlag |= v;
+ update();
+ }
+
+ QUrl QQuick3DQuadTextureProvider::fragmentShader() const
+ {
+ return m_fragmentShader;
+ }
+
+ void QQuick3DQuadTextureProvider::setFragmentShader(const QUrl &newFragmentShader)
+ {
+ if (m_fragmentShader == newFragmentShader)
+ return;
+ m_fragmentShader = newFragmentShader;
+ emit fragmentShaderChanged();
+ markDirty(Dirty::FragmentShader);
+ }
+
+ QString QQuick3DQuadTextureProvider::fragmentShaderCode() const
+ {
+ return m_fragmentShaderCode;
+ }
+
+ void QQuick3DQuadTextureProvider::setFragmentShaderCode(const QString &newFragmentShaderCode)
+ {
+ if (m_fragmentShaderCode == newFragmentShaderCode)
+ return;
+ m_fragmentShaderCode = newFragmentShaderCode;
+ emit fragmentShaderCodeChanged();
+ markDirty(Dirty::FragmentShader);
+ }
+
+
+ int QQuick3DQuadTextureProvider::width() const
+ {
+ return m_width;
+ }
+
+ void QQuick3DQuadTextureProvider::setWidth(int newWidth)
+ {
+ newWidth = qMax(1, newWidth);
+ if (m_width == newWidth)
+ return;
+ m_width = newWidth;
+ emit widthChanged();
+ markDirty(Dirty::Dimensions);
+ }
+
+ int QQuick3DQuadTextureProvider::height() const
+ {
+ return m_height;
+ }
+
+ void QQuick3DQuadTextureProvider::setHeight(int newHeight)
+ {
+ newHeight = qMax(1, newHeight);
+ if (m_height == newHeight)
+ return;
+ m_height = newHeight;
+ emit heightChanged();
+ markDirty(Dirty::Dimensions);
+ }
+
+ QQuick3DTextureData::Format QQuick3DQuadTextureProvider::format() const
+ {
+ return m_format;
+ }
+
+ void QQuick3DQuadTextureProvider::setFormat(QQuick3DTextureData::Format newFormat)
+ {
+ if (m_format == newFormat)
+ return;
+ m_format = newFormat;
+ emit formatChanged();
+ markDirty(Dirty::Format);
+ }
+
+ QT_END_NAMESPACE