Revision control
++ // Copyright (C) 2008-2012 NVIDIA Corporation.
++ // Copyright (C) 2020 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++
++ #include <QtQuick3DRuntimeRender/private/qssgrhieffectsystem_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssgrenderer_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssgrhiquadrenderer_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssgrendercamera_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>
++
++ #include "qssgrendercontextcore.h"
++ #include "qssgrendershadercodegenerator_p.h"
++ #include <qtquick3d_tracepoints_p.h>
++
++ #include <QtQuick3DUtils/private/qssgassert_p.h>
++
++ #include <QtCore/qloggingcategory.h>
++
++ QT_BEGIN_NAMESPACE
++
++ Q_DECLARE_LOGGING_CATEGORY(lcEffectSystem);
++ Q_LOGGING_CATEGORY(lcEffectSystem, "qt.quick3d.effects");
++
++ struct QSSGRhiEffectTexture
++ {
++ QRhiTexture *texture = nullptr;
++ QRhiRenderPassDescriptor *renderPassDescriptor = nullptr;
++ QRhiTextureRenderTarget *renderTarget = nullptr;
++ QByteArray name;
++
++ QSSGRhiSamplerDescription desc;
++ QSSGAllocateBufferFlags flags;
++
++ ~QSSGRhiEffectTexture()
++ {
++ delete texture;
++ delete renderPassDescriptor;
++ delete renderTarget;
++ }
++ QSSGRhiEffectTexture &operator=(const QSSGRhiEffectTexture &) = delete;
++ };
++
++ QSSGRhiEffectSystem::QSSGRhiEffectSystem(const std::shared_ptr<QSSGRenderContextInterface> &sgContext)
++ : m_sgContext(sgContext)
++ {
++ }
++
++ QSSGRhiEffectSystem::~QSSGRhiEffectSystem()
++ {
++ // The uniform buffers for the effect passes are keyed on this object.
++ if (const auto &rhiCtx = m_sgContext->rhiContext(); rhiCtx && rhiCtx->isValid())
++ QSSGRhiContextPrivate::get(rhiCtx.get())->cleanupDrawCallDataForCid(this);
++ releaseResources();
++ }
++
++ void QSSGRhiEffectSystem::setup(QSize outputSize)
++ {
++ if (outputSize.isEmpty()) {
++ releaseResources();
++ return;
++ }
++ m_outSize = outputSize;
++ }
++
++ QSSGRhiEffectTexture *QSSGRhiEffectSystem::findTexture(const QByteArray &bufferName)
++ {
++ auto findTexture = [bufferName](const QSSGRhiEffectTexture *rt){ return rt->name == bufferName; };
++ const auto foundIt = std::find_if(m_textures.cbegin(), m_textures.cend(), findTexture);
++ QSSGRhiEffectTexture *result = foundIt == m_textures.cend() ? nullptr : *foundIt;
++ return result;
++ }
++
++ QSSGRhiEffectTexture *QSSGRhiEffectSystem::getTexture(const QByteArray &bufferName,
++ const QSize &size,
++ QRhiTexture::Format format,
++ bool isFinalOutput,
++ const QSSGRenderEffect *inEffect,
++ quint8 viewCount)
++ {
++ QSSGRhiEffectTexture *result = findTexture(bufferName);
++ const bool gotMatch = result != nullptr;
++
++ // If not found, look for an unused texture
++ if (!result) {
++ // ### This could be enhanced to try to find a texture with the right
++ // size/format/flags first. It is not essential because the texture will be
++ // recreated below if the size or format does not match, but it would
++ // be more optimal (for Effects with Buffers with sizeMultipliers on
++ // them, or ones that use different formats) to look for a matching
++ // size/format too instead of picking the first unused texture.
++ auto findUnused = [](const QSSGRhiEffectTexture *rt){ return rt->name.isEmpty(); };
++ const auto found = std::find_if(m_textures.cbegin(), m_textures.cend(), findUnused);
++ if (found != m_textures.cend()) {
++ result = *found;
++ result->desc = {};
++ }
++ }
++
++ if (!result) {
++ result = new QSSGRhiEffectTexture {};
++ m_textures.append(result);
++ }
++
++ const auto &rhiCtx = m_sgContext->rhiContext();
++ QRhi *rhi = rhiCtx->rhi();
++ const bool formatChanged = result->texture && result->texture->format() != format;
++ const bool needsRebuild = result->texture && (result->texture->pixelSize() != size || formatChanged);
++
++ QRhiTexture::Flags flags = QRhiTexture::RenderTarget;
++ if (isFinalOutput) // play nice with progressive/temporal AA
++ flags |= QRhiTexture::UsedAsTransferSource;
++
++ if (!result->texture) {
++ if (viewCount >= 2)
++ result->texture = rhi->newTextureArray(format, viewCount, size, 1, flags);
++ else
++ result->texture = rhi->newTexture(format, size, 1, flags);
++ result->texture->create();
++ } else if (needsRebuild) {
++ result->texture->setFlags(flags);
++ result->texture->setPixelSize(size);
++ result->texture->setFormat(format);
++ result->texture->create();
++ }
++
++ if (!result->renderTarget) {
++ QRhiColorAttachment colorAttachment(result->texture);
++ colorAttachment.setMultiViewCount(viewCount);
++ QRhiTextureRenderTargetDescription desc(colorAttachment);
++ result->renderTarget = rhi->newTextureRenderTarget(desc);
++ result->renderPassDescriptor = result->renderTarget->newCompatibleRenderPassDescriptor();
++ result->renderTarget->setRenderPassDescriptor(result->renderPassDescriptor);
++ result->renderTarget->create();
++ m_pendingClears.insert(result->renderTarget);
++ } else if (needsRebuild) {
++ if (formatChanged) {
++ delete result->renderPassDescriptor;
++ result->renderPassDescriptor = result->renderTarget->newCompatibleRenderPassDescriptor();
++ result->renderTarget->setRenderPassDescriptor(result->renderPassDescriptor);
++ }
++ result->renderTarget->create();
++ m_pendingClears.insert(result->renderTarget);
++ }
++
++ if (!gotMatch) {
++ QByteArray rtName = inEffect->debugObjectName.toLatin1();
++ rtName += QByteArrayLiteral(" effect pass ");
++ rtName += bufferName;
++ result->renderTarget->setName(rtName);
++ }
++
++ result->name = bufferName;
++ return result;
++ }
++
++ void QSSGRhiEffectSystem::releaseTexture(QSSGRhiEffectTexture *texture)
++ {
++ // Mark as unused by setting the name to empty, unless the Buffer had scene
++ // lifetime on it (then it needs to live on for ever).
++ if (!texture->flags.isSceneLifetime())
++ texture->name = {};
++ }
++
++ void QSSGRhiEffectSystem::releaseTextures()
++ {
++ for (auto *t : std::as_const(m_textures))
++ releaseTexture(t);
++ }
++
++ QRhiTexture *QSSGRhiEffectSystem::process(const QSSGRenderLayer &layer,
++ QRhiTexture *inTexture,
++ QRhiTexture *inDepthTexture,
++ QRhiTexture *inNormalTexture,
++ QRhiTexture *inMotionVectorTexture)
++ {
++ QSSG_ASSERT(m_sgContext != nullptr, return inTexture);
++ QSSG_ASSERT(layer.firstEffect != nullptr, return inTexture);
++ const auto &rhiContext = m_sgContext->rhiContext();
++ const auto &renderer = m_sgContext->renderer();
++ QSSG_ASSERT(rhiContext && renderer, return inTexture);
++
++ const auto viewCount = layer.viewCount;
++
++ m_depthTexture = inDepthTexture;
++ m_normalTexture = inNormalTexture;
++ m_motionVectorTexture = inMotionVectorTexture;
++ m_cameraClipRange = layer.renderedCameras[0]->clipPlanes;
++
++ bool usesProjectionMatrix = false;
++ bool usesViewMatrix = false;
++ for (const QSSGRenderEffect *eff = layer.firstEffect; eff; eff = eff->m_nextEffect) {
++ if (eff->testFlag(QSSGRenderEffect::Flags::UsesProjectionMatrix)
++ || eff->testFlag(QSSGRenderEffect::Flags::UsesInverseProjectionMatrix))
++ {
++ usesProjectionMatrix = true;
++ }
++ if (eff->testFlag(QSSGRenderEffect::Flags::UsesViewMatrix))
++ usesViewMatrix = true;
++ }
++
++ if (usesProjectionMatrix) {
++ m_projectionMatrices.resize(viewCount);
++ const QMatrix4x4 clipSpaceCorrMatrix = rhiContext->rhi()->clipSpaceCorrMatrix();
++ for (int viewIndex = 0; viewIndex < viewCount; ++viewIndex)
++ m_projectionMatrices[viewIndex] = clipSpaceCorrMatrix * layer.renderedCameras[viewIndex]->projection;
++ }
++
++ if (usesViewMatrix) {
++ QMatrix4x4 camGlobalTransforms[2] { QMatrix4x4{Qt::Uninitialized}, QMatrix4x4{Qt::Uninitialized} };
++ for (int viewIndex = 0; viewIndex < viewCount; ++viewIndex)
++ camGlobalTransforms[viewIndex] = layer.renderData->getGlobalTransform(*layer.renderedCameras[viewIndex]);
++ m_viewMatrices.resize(viewCount);
++ for (int viewIndex = 0; viewIndex < viewCount; ++viewIndex)
++ m_viewMatrices[viewIndex] = camGlobalTransforms[viewIndex].inverted();
++ }
++
++ m_currentUbufIndex = 0;
++ // FIXME: Keeping the change minimal for now, but we should avoid the need for this cast.
++ QSSGRenderEffect *currentEffect = const_cast<QSSGRenderEffect *>(layer.firstEffect);
++ QSSGRhiEffectTexture firstTex{ inTexture, nullptr, nullptr, {}, {}, {} };
++ auto *latestOutput = doRenderEffect(currentEffect, &firstTex, viewCount);
++ firstTex.texture = nullptr; // make sure we don't delete inTexture when we go out of scope
++
++ while ((currentEffect = currentEffect->m_nextEffect)) {
++ QSSGRhiEffectTexture *effectOut = doRenderEffect(currentEffect, latestOutput, viewCount);
++ releaseTexture(latestOutput);
++ latestOutput = effectOut;
++ }
++
++ releaseTextures();
++ return latestOutput ? latestOutput->texture : nullptr;
++ }
++
++ void QSSGRhiEffectSystem::releaseResources()
++ {
++ qDeleteAll(m_textures);
++ m_textures.clear();
++
++ m_shaderPipelines.clear();
++ }
++
++ QSSGRenderTextureFormat::Format QSSGRhiEffectSystem::overriddenOutputFormat(const QSSGRenderEffect *inEffect)
++ {
++ QSSGRenderTextureFormat::Format format = QSSGRenderTextureFormat::Unknown;
++ for (const QSSGCommand *cmd : inEffect->commands) {
++ if (cmd->m_type == CommandType::BindTarget) {
++ const QSSGBindTarget *targetCmd = static_cast<const QSSGBindTarget *>(cmd);
++ format = targetCmd->m_outputFormat == QSSGRenderTextureFormat::Unknown
++ ? inEffect->outputFormat : targetCmd->m_outputFormat.format;
++ }
++ }
++ return format;
++ }
++
++ QSSGRhiEffectTexture *QSSGRhiEffectSystem::doRenderEffect(const QSSGRenderEffect *inEffect,
++ QSSGRhiEffectTexture *inTexture,
++ quint8 viewCount)
++ {
++ // Run through the effect commands and render the effect.
++ qCDebug(lcEffectSystem) << "START effect " << inEffect->className;
++ QSSGRhiEffectTexture *finalOutputTexture = nullptr;
++ QSSGRhiEffectTexture *currentOutput = nullptr;
++ QSSGRhiEffectTexture *currentInput = inTexture;
++ for (const QSSGCommand *theCommand : inEffect->commands) {
++ qCDebug(lcEffectSystem).noquote() << " >" << theCommand->typeAsString() << "--" << theCommand->debugString();
++
++ switch (theCommand->m_type) {
++ case CommandType::AllocateBuffer:
++ allocateBufferCmd(static_cast<const QSSGAllocateBuffer *>(theCommand), inTexture, inEffect, viewCount);
++ break;
++
++ case CommandType::ApplyBufferValue: {
++ auto *applyCommand = static_cast<const QSSGApplyBufferValue *>(theCommand);
++
++ /*
++ BufferInput { buffer: buf }
++ -> INPUT (qt_inputTexture) in the shader samples the texture for Buffer buf in the pass
++ BufferInput { sampler: "ttt" }
++ -> ttt in the shader samples the input texture for the pass
++ (ttt also needs to be a TextureInput with a Texture{} to get the sampler declared in the shader code,
++ beware that without the BufferInput the behavior would change: ttt would then sample a dummy texture)
++ BufferInput { buffer: buf; sampler: "ttt" }
++ -> ttt in the shader samples the texture for Buffer buf in the pass
++ */
++
++ auto *buffer = applyCommand->m_bufferName.isEmpty() ? inTexture : findTexture(applyCommand->m_bufferName);
++ if (applyCommand->m_samplerName.isEmpty())
++ currentInput = buffer;
++ else
++ addTextureToShaderPipeline(applyCommand->m_samplerName, buffer->texture, buffer->desc);
++ break;
++ }
++
++ case CommandType::ApplyInstanceValue:
++ applyInstanceValueCmd(static_cast<const QSSGApplyInstanceValue *>(theCommand), inEffect);
++ break;
++
++ case CommandType::ApplyValue:
++ applyValueCmd(static_cast<const QSSGApplyValue *>(theCommand), inEffect);
++ break;
++
++ case CommandType::BindBuffer: {
++ auto *bindCmd = static_cast<const QSSGBindBuffer *>(theCommand);
++ currentOutput = findTexture(bindCmd->m_bufferName);
++ break;
++ }
++
++ case CommandType::BindShader:
++ bindShaderCmd(static_cast<const QSSGBindShader *>(theCommand), inEffect, viewCount);
++ break;
++
++ case CommandType::BindTarget: {
++ auto targetCmd = static_cast<const QSSGBindTarget*>(theCommand);
++ // matches overriddenOutputFormat()
++ QSSGRenderTextureFormat::Format f = targetCmd->m_outputFormat == QSSGRenderTextureFormat::Unknown ?
++ inEffect->outputFormat : targetCmd->m_outputFormat.format;
++ // f is now either Unknown (common case), or if the effect overrides the output format, then that
++ QRhiTexture::Format rhiFormat = f == QSSGRenderTextureFormat::Unknown ?
++ currentInput->texture->format() : QSSGBufferManager::toRhiFormat(f);
++ qCDebug(lcEffectSystem) << " Target format override" << QSSGBaseTypeHelpers::toString(f) << "Effective RHI format" << rhiFormat;
++ // Make sure we use different names for each effect inside one frame
++ QByteArray tmpName = QByteArrayLiteral("__output_").append(QByteArray::number(m_currentUbufIndex));
++ currentOutput = getTexture(tmpName, m_outSize, rhiFormat, true, inEffect, viewCount);
++ finalOutputTexture = currentOutput;
++ break;
++ }
++
++ case CommandType::Render:
++ renderCmd(inEffect, currentInput, currentOutput, viewCount);
++ currentInput = inTexture; // default input for each new pass is defined to be original input
++ break;
++
++ default:
++ qWarning() << "Effect command" << theCommand->typeAsString() << "not implemented";
++ break;
++ }
++ }
++ // TODO: release textures used by this effect now, instead of after processing all the effects
++ qCDebug(lcEffectSystem) << "END effect " << inEffect->className;
++ return finalOutputTexture;
++ }
++
++ void QSSGRhiEffectSystem::allocateBufferCmd(const QSSGAllocateBuffer *inCmd,
++ QSSGRhiEffectTexture *inTexture,
++ const QSSGRenderEffect *inEffect,
++ quint8 viewCount)
++ {
++ // Note: Allocate is used both to allocate new, and refer to buffer created earlier
++ QSize bufferSize(m_outSize * qreal(inCmd->m_sizeMultiplier));
++
++ QSSGRenderTextureFormat f = inCmd->m_format;
++ QRhiTexture::Format rhiFormat = (f == QSSGRenderTextureFormat::Unknown) ? inTexture->texture->format()
++ : QSSGBufferManager::toRhiFormat(f);
++
++ QSSGRhiEffectTexture *buf = getTexture(inCmd->m_name, bufferSize, rhiFormat, false, inEffect, viewCount);
++ auto filter = QSSGRhiHelpers::toRhi(inCmd->m_filterOp);
++ auto tiling = QSSGRhiHelpers::toRhi(inCmd->m_texCoordOp);
++ buf->desc = { filter, filter, QRhiSampler::None, tiling, tiling, QRhiSampler::Repeat };
++ buf->flags = inCmd->m_bufferFlags;
++ }
++
++ void QSSGRhiEffectSystem::applyInstanceValueCmd(const QSSGApplyInstanceValue *inCmd, const QSSGRenderEffect *inEffect)
++ {
++ if (!m_currentShaderPipeline)
++ return;
++
++ const bool setAll = inCmd->m_propertyName.isEmpty();
++ for (const QSSGRenderEffect::Property &property : std::as_const(inEffect->properties)) {
++ if (setAll || property.name == inCmd->m_propertyName) {
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, property.name, property.value, property.shaderDataType);
++ //qCDebug(lcEffectSystem) << "setUniformValue" << property.name << toString(property.shaderDataType) << "to" << property.value;
++ }
++ }
++ for (const QSSGRenderEffect::TextureProperty &textureProperty : std::as_const(inEffect->textureProperties)) {
++ if (setAll || textureProperty.name == inCmd->m_propertyName) {
++ bool texAdded = false;
++ QSSGRenderImage *image = textureProperty.texImage;
++ if (image) {
++ const auto &theBufferManager(m_sgContext->bufferManager());
++ const QSSGRenderImageTexture texture = theBufferManager->loadRenderImage(image);
++ if (texture.m_texture) {
++ const QSSGRhiSamplerDescription desc{
++ QSSGRhiHelpers::toRhi(textureProperty.minFilterType),
++ QSSGRhiHelpers::toRhi(textureProperty.magFilterType),
++ textureProperty.mipFilterType != QSSGRenderTextureFilterOp::None ? QSSGRhiHelpers::toRhi(textureProperty.mipFilterType) : QRhiSampler::None,
++ QSSGRhiHelpers::toRhi(textureProperty.horizontalClampType),
++ QSSGRhiHelpers::toRhi(textureProperty.verticalClampType),
++ QSSGRhiHelpers::toRhi(textureProperty.zClampType)
++ };
++ addTextureToShaderPipeline(textureProperty.name, texture.m_texture, desc);
++ texAdded = true;
++ }
++ }
++ if (!texAdded) {
++ // Something went wrong, e.g. image file not found. Still need to add a dummy texture for the shader
++ qCDebug(lcEffectSystem) << "Using dummy texture for property" << textureProperty.name;
++ addTextureToShaderPipeline(textureProperty.name, nullptr, {});
++ }
++ }
++ }
++ }
++
++ void QSSGRhiEffectSystem::applyValueCmd(const QSSGApplyValue *inCmd, const QSSGRenderEffect *inEffect)
++ {
++ if (!m_currentShaderPipeline)
++ return;
++
++ const auto &properties = inEffect->properties;
++ const auto foundIt = std::find_if(properties.cbegin(), properties.cend(), [inCmd](const QSSGRenderEffect::Property &prop) {
++ return (prop.name == inCmd->m_propertyName);
++ });
++
++ if (foundIt != properties.cend())
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, inCmd->m_propertyName, inCmd->m_value, foundIt->shaderDataType);
++ else
++ qWarning() << "Could not find effect property" << inCmd->m_propertyName;
++ }
++
++ static const char *effect_builtin_textureMapUV =
++ "vec2 qt_effectTextureMapUV(vec2 uv)\n"
++ "{\n"
++ " return uv;\n"
++ "}\n";
++
++ static const char *effect_builtin_textureMapUVFlipped =
++ "vec2 qt_effectTextureMapUV(vec2 uv)\n"
++ "{\n"
++ " return vec2(uv.x, 1.0 - uv.y);\n"
++ "}\n";
++
++ QSSGRhiShaderPipelinePtr QSSGRhiEffectSystem::buildShaderForEffect(const QSSGBindShader &inCmd,
++ QSSGProgramGenerator &generator,
++ QSSGShaderLibraryManager &shaderLib,
++ QSSGShaderCache &shaderCache,
++ bool isYUpInFramebuffer,
++ int viewCount)
++ {
++ const auto &key = inCmd.m_shaderPathKey;
++ qCDebug(lcEffectSystem) << " generating new shader pipeline for: " << key;
++
++ generator.beginProgram();
++
++ {
++ const QByteArray src = shaderLib.getShaderSource(inCmd.m_shaderPathKey, QSSGShaderCache::ShaderType::Vertex);
++ QSSGStageGeneratorBase *vStage = generator.getStage(QSSGShaderGeneratorStage::Vertex);
++ // The variation based on isYUpInFramebuffer is captured in 'key' as
++ // well, so it is safe to vary the source code here.
++ vStage->append(isYUpInFramebuffer ? effect_builtin_textureMapUV : effect_builtin_textureMapUVFlipped);
++ vStage->append(src);
++ }
++ {
++ const QByteArray src = shaderLib.getShaderSource(inCmd.m_shaderPathKey, QSSGShaderCache::ShaderType::Fragment);
++ QSSGStageGeneratorBase *fStage = generator.getStage(QSSGShaderGeneratorStage::Fragment);
++ fStage->append(src);
++ }
++
++ return generator.compileGeneratedRhiShader(key,
++ shaderLib.getShaderMetaData(inCmd.m_shaderPathKey, QSSGShaderCache::ShaderType::Fragment).features,
++ shaderLib,
++ shaderCache,
++ QSSGRhiShaderPipeline::UsedWithoutIa,
++ {},
++ viewCount,
++ false);
++ }
++
++ void QSSGRhiEffectSystem::bindShaderCmd(const QSSGBindShader *inCmd, const QSSGRenderEffect *inEffect, quint8 viewCount)
++ {
++ QElapsedTimer timer;
++ timer.start();
++
++ m_currentTextures.clear();
++ m_pendingClears.clear();
++ m_currentShaderPipeline = nullptr;
++
++ const auto &rhiCtx = m_sgContext->rhiContext();
++ QRhi *rhi = rhiCtx->rhi();
++ const auto &shaderLib = m_sgContext->shaderLibraryManager();
++ const auto &shaderCache = m_sgContext->shaderCache();
++
++ // Now we need a proper unique key (unique in the scene), the filenames are
++ // not sufficient. This means that using the same shader source files in
++ // multiple Effects in the same scene will work. It wouldn't if all those
++ // Effects reused the same QSSGRhiShaderPipeline (i.e. if the only cache
++ // key was the m_shaderPathKey).
++ QSSGEffectSceneCacheKey cacheKey;
++ cacheKey.m_shaderPathKey = inCmd->m_shaderPathKey;
++ cacheKey.m_cmd = quintptr(inCmd);
++ cacheKey.m_ubufIndex = m_currentUbufIndex;
++ cacheKey.updateHashCode();
++
++ // look for a runtime pipeline
++ const auto it = m_shaderPipelines.constFind(cacheKey);
++ if (it != m_shaderPipelines.cend())
++ m_currentShaderPipeline = (*it).get();
++
++ QByteArray qsbcKey;
++ QSSGShaderFeatures features;
++ if (!m_currentShaderPipeline) { // don't spend time if already got the pipeline
++ features = shaderLib->getShaderMetaData(inCmd->m_shaderPathKey, QSSGShaderCache::ShaderType::Fragment).features;
++ qsbcKey = QQsbCollection::EntryDesc::generateSha(inCmd->m_shaderPathKey, QQsbCollection::toFeatureSet(features));
++ }
++
++ // Check if there's a build-time generated entry for this effect
++ if (!m_currentShaderPipeline && !shaderLib->m_preGeneratedShaderEntries.isEmpty()) {
++ const QQsbCollection::EntryMap &pregenEntries = shaderLib->m_preGeneratedShaderEntries;
++ const auto foundIt = pregenEntries.constFind(QQsbCollection::Entry(qsbcKey));
++ if (foundIt != pregenEntries.cend()) {
++ // The result here is always a new QSSGRhiShaderPipeline, which
++ // fulfills the requirements of our local cache (cmd/ubufIndex in
++ // cacheKey, not needed here since the result is a new object).
++ const auto &shader = shaderCache->newPipelineFromPregenerated(inCmd->m_shaderPathKey,
++ features,
++ *foundIt,
++ *inEffect,
++ QSSGRhiShaderPipeline::UsedWithoutIa);
++ m_shaderPipelines.insert(cacheKey, shader);
++ m_currentShaderPipeline = shader.get();
++ }
++ }
++
++ if (!m_currentShaderPipeline) {
++ // Try the persistent (disk-based) cache then. The result here is
++ // always a new QSSGRhiShaderPipeline, which fulfills the requirements
++ // of our local cache (cmd/ubufIndex in cacheKey, not needed here since
++ // the result is a new object). Alternatively, the result may be null
++ // if there was no hit.
++ const auto &shaderPipeline = shaderCache->tryNewPipelineFromPersistentCache(qsbcKey,
++ inCmd->m_shaderPathKey,
++ features,
++ QSSGRhiShaderPipeline::UsedWithoutIa);
++ if (shaderPipeline) {
++ m_shaderPipelines.insert(cacheKey, shaderPipeline);
++ m_currentShaderPipeline = shaderPipeline.get();
++ }
++ }
++
++ if (!m_currentShaderPipeline) {
++ // Final option, generate the shader pipeline
++ Q_TRACE_SCOPE(QSSG_generateShader);
++ Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DGenerateShader);
++ const auto &generator = m_sgContext->shaderProgramGenerator();
++ if (auto stages = buildShaderForEffect(*inCmd, *generator, *shaderLib, *shaderCache, rhi->isYUpInFramebuffer(), viewCount)) {
++ m_shaderPipelines.insert(cacheKey, stages);
++ m_currentShaderPipeline = stages.get();
++ }
++ Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DGenerateShader, 0, inEffect->profilingId);
++ }
++
++ const auto &rhiContext = m_sgContext->rhiContext();
++
++ if (m_currentShaderPipeline) {
++ const void *cacheKey1 = reinterpret_cast<const void *>(this);
++ const void *cacheKey2 = reinterpret_cast<const void *>(qintptr(m_currentUbufIndex));
++ QSSGRhiDrawCallData &dcd = QSSGRhiContextPrivate::get(rhiContext.get())->drawCallData({ cacheKey1, cacheKey2,
++ nullptr, nullptr, 0 });
++ m_currentShaderPipeline->ensureCombinedUniformBuffer(&dcd.ubuf);
++ m_currentUBufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
++ } else {
++ m_currentUBufData = nullptr;
++ }
++
++ QSSGRhiContextStats::get(*rhiContext).registerEffectShaderGenerationTime(timer.elapsed());
++ }
++
++ void QSSGRhiEffectSystem::renderCmd(const QSSGRenderEffect *inEffect, QSSGRhiEffectTexture *inTexture, QSSGRhiEffectTexture *target, quint8 viewCount)
++ {
++ if (!m_currentShaderPipeline)
++ return;
++
++ if (!target) {
++ qWarning("No effect render target?");
++ return;
++ }
++
++ // the shader only uses one of these (or none)
++ addTextureToShaderPipeline(QByteArrayLiteral("qt_inputTexture"), inTexture->texture, inTexture->desc);
++ addTextureToShaderPipeline(QByteArrayLiteral("qt_inputTextureArray"), inTexture->texture, inTexture->desc);
++
++ const auto &rhiContext = m_sgContext->rhiContext();
++ const auto &renderer = m_sgContext->renderer();
++
++ QRhiCommandBuffer *cb = rhiContext->commandBuffer();
++ cb->debugMarkBegin(QByteArrayLiteral("Post-processing effect"));
++ Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
++
++ for (QRhiTextureRenderTarget *rt : std::as_const(m_pendingClears)) {
++ // Effects like motion blur use an accumulator texture that should
++ // start out empty (and they are sampled in the first pass), so such
++ // textures need an explicit clear. It is not applicable for the common
++ // case of outputting into a texture because that will get a clear
++ // anyway when rendering the quad.
++ if (rt != target->renderTarget) {
++ cb->beginPass(rt, Qt::transparent, { 1.0f, 0 }, nullptr, rhiContext->commonPassFlags());
++ QSSGRHICTX_STAT(rhiContext, beginRenderPass(rt));
++ cb->endPass();
++ QSSGRHICTX_STAT(rhiContext, endRenderPass());
++ }
++ }
++ m_pendingClears.clear();
++
++ const QSize inputSize = inTexture->texture->pixelSize();
++ const QSize outputSize = target->texture->pixelSize();
++ addCommonEffectUniforms(inEffect, inputSize, outputSize, viewCount);
++
++ QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiContext.get());
++
++ const void *cacheKey1 = reinterpret_cast<const void *>(this);
++ const void *cacheKey2 = reinterpret_cast<const void *>(qintptr(m_currentUbufIndex));
++ QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData({ cacheKey1, cacheKey2, nullptr, nullptr, 0 });
++ dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
++ m_currentUBufData = nullptr;
++
++ QRhiResourceUpdateBatch *rub = rhiContext->rhi()->nextResourceUpdateBatch();
++ renderer->rhiQuadRenderer()->prepareQuad(rhiContext.get(), rub);
++
++ // do resource bindings
++ const QRhiShaderResourceBinding::StageFlags VISIBILITY_ALL =
++ QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage;
++ QSSGRhiShaderResourceBindingList bindings;
++ for (const QSSGRhiTexture &rhiTex : std::as_const(m_currentTextures)) {
++ int binding = m_currentShaderPipeline->bindingForTexture(rhiTex.name);
++ if (binding < 0) // may not be used in the shader (think qt_inputTexture, it's not given a shader samples INPUT)
++ continue;
++ qCDebug(lcEffectSystem) << " -> texture binding" << binding << "for" << rhiTex.name;
++ // Make sure to bind all samplers even if the texture is missing, otherwise we can get crash on some graphics APIs
++ QRhiTexture *texture = rhiTex.texture ? rhiTex.texture : rhiContext->dummyTexture({}, rub);
++ bindings.addTexture(binding,
++ QRhiShaderResourceBinding::FragmentStage,
++ texture,
++ rhiContext->sampler(rhiTex.samplerDesc));
++ }
++ bindings.addUniformBuffer(0, VISIBILITY_ALL, dcd.ubuf);
++
++ QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings);
++
++ QSSGRhiGraphicsPipelineState ps;
++ ps.viewport = QRhiViewport(0, 0, float(outputSize.width()), float(outputSize.height()));
++ ps.samples = target->renderTarget->sampleCount();
++ ps.viewCount = viewCount;
++ QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, m_currentShaderPipeline);
++
++ renderer->rhiQuadRenderer()->recordRenderQuadPass(rhiContext.get(), &ps, srb, target->renderTarget, QSSGRhiQuadRenderer::UvCoords);
++ m_currentUbufIndex++;
++ cb->debugMarkEnd();
++ Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("post_processing_effect"));
++ }
++
++ void QSSGRhiEffectSystem::addCommonEffectUniforms(const QSSGRenderEffect *inEffect, const QSize &inputSize, const QSize &outputSize, quint8 viewCount)
++ {
++ const auto &rhiContext = m_sgContext->rhiContext();
++ QRhi *rhi = rhiContext->rhi();
++
++ QMatrix4x4 mvp;
++ if (rhi->isYUpInFramebuffer() != rhi->isYUpInNDC())
++ mvp.data()[5] = -1.0f;
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_modelViewProjection", mvp, QSSGRenderShaderValue::Matrix4x4);
++
++ const bool usesProjectionMatrix = inEffect->testFlag(QSSGRenderEffect::Flags::UsesProjectionMatrix);
++ const bool usesInverseProjectionMatrix = inEffect->testFlag(QSSGRenderEffect::Flags::UsesInverseProjectionMatrix);
++ if (usesProjectionMatrix || usesInverseProjectionMatrix) {
++ if (viewCount < 2) {
++ if (usesProjectionMatrix)
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_projectionMatrix", m_projectionMatrices[0], QSSGRenderShaderValue::Matrix4x4);
++ if (usesInverseProjectionMatrix)
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_inverseProjectionMatrix", m_projectionMatrices[0].inverted(), QSSGRenderShaderValue::Matrix4x4);
++ } else {
++ if (usesProjectionMatrix)
++ m_currentShaderPipeline->setUniformArray(m_currentUBufData, "qt_projectionMatrix", m_projectionMatrices.constData(), viewCount, QSSGRenderShaderValue::Matrix4x4);
++ if (usesInverseProjectionMatrix) {
++ QVarLengthArray<QMatrix4x4, 2> invertedProjections(viewCount);
++ for (quint8 viewIndex = 0; viewIndex < viewCount; ++viewIndex)
++ invertedProjections[viewIndex] = m_projectionMatrices[viewIndex].inverted();
++ m_currentShaderPipeline->setUniformArray(m_currentUBufData, "qt_inverseProjectionMatrix", invertedProjections.constData(), viewCount, QSSGRenderShaderValue::Matrix4x4);
++ }
++ }
++ }
++
++ if (inEffect->testFlag(QSSGRenderEffect::Flags::UsesViewMatrix)) {
++ if (viewCount < 2)
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_viewMatrix", m_viewMatrices[0], QSSGRenderShaderValue::Matrix4x4);
++ else
++ m_currentShaderPipeline->setUniformArray(m_currentUBufData, "qt_viewMatrix", m_viewMatrices.constData(), viewCount, QSSGRenderShaderValue::Matrix4x4);
++ }
++
++ QVector2D size(inputSize.width(), inputSize.height());
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_inputSize", size, QSSGRenderShaderValue::Vec2);
++
++ size = QVector2D(outputSize.width(), outputSize.height());
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_outputSize", size, QSSGRenderShaderValue::Vec2);
++
++ float fc = float(m_sgContext->renderer()->frameCount());
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_frame_num", fc, QSSGRenderShaderValue::Float);
++
++ // Bames and values for uniforms that are also used by default and/or
++ // custom materials must always match, effects must not deviate.
++
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_cameraProperties", m_cameraClipRange, QSSGRenderShaderValue::Vec2);
++
++ float vp = rhi->isYUpInFramebuffer() ? 1.0f : -1.0f;
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_normalAdjustViewportFactor", vp, QSSGRenderShaderValue::Float);
++
++ const float nearClip = rhi->isClipDepthZeroToOne() ? 0.0f : -1.0f;
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_nearClipValue", nearClip, QSSGRenderShaderValue::Float);
++
++ const QVector4D rhiProperties(
++ rhi->isYUpInFramebuffer() ? 1.0f : -1.0f,
++ rhi->isYUpInNDC() ? 1.0f : -1.0f,
++ rhi->isClipDepthZeroToOne() ? 0.0f : -1.0f,
++ 0.0f // unused
++ );
++ m_currentShaderPipeline->setUniformValue(m_currentUBufData, "qt_rhi_properties", rhiProperties, QSSGRenderShaderValue::Vec4);
++
++ if (m_depthTexture) {
++ static const QSSGRhiSamplerDescription depthSamplerDesc {
++ QRhiSampler::Nearest, QRhiSampler::Nearest,
++ QRhiSampler::None,
++ QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat
++ };
++ addTextureToShaderPipeline("qt_depthTexture", m_depthTexture, depthSamplerDesc);
++ addTextureToShaderPipeline("qt_depthTextureArray", m_depthTexture, depthSamplerDesc);
++ }
++
++ if (m_normalTexture) {
++ static const QSSGRhiSamplerDescription normalSamplerDesc {
++ QRhiSampler::Nearest, QRhiSampler::Nearest,
++ QRhiSampler::None,
++ QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat
++ };
++ addTextureToShaderPipeline("qt_normalTexture", m_normalTexture, normalSamplerDesc);
++ }
++ if (m_motionVectorTexture) {
++ static const QSSGRhiSamplerDescription motionVectorSamplerDesc {
++ QRhiSampler::Linear, QRhiSampler::Linear,
++ QRhiSampler::None,
++ QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat
++ };
++ addTextureToShaderPipeline("qt_motionVectorTexture", m_motionVectorTexture, motionVectorSamplerDesc);
++ }
++ }
++
++ void QSSGRhiEffectSystem::addTextureToShaderPipeline(const QByteArray &name,
++ QRhiTexture *texture,
++ const QSSGRhiSamplerDescription &samplerDescription)
++ {
++ if (!m_currentShaderPipeline)
++ return;
++
++ static const QSSGRhiSamplerDescription defaultDescription { QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
++ QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat };
++ bool validDescription = samplerDescription.magFilter != QRhiSampler::None;
++
++ // This is a map for a reason: there can be multiple calls to this function
++ // for the same 'name', with a different 'texture', take the last value
++ // into account only.
++ m_currentTextures.insert(name, { name, texture, validDescription ? samplerDescription : defaultDescription});
++ }
++
++ QT_END_NAMESPACE