qsgrhilayer.cpp - mozsearch

++ // Copyright (C) 2019 The Qt Company Ltd.

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

++ // Qt-Security score:significant reason:default

++

++ #include "qsgrhilayer_p.h"

++

++ #include <private/qqmlglobal_p.h>

++ #include <private/qsgrenderer_p.h>

++

++ QSGRhiLayer::QSGRhiLayer(QSGRenderContext *context)

++     : QSGLayer(*(new QSGTexturePrivate(this)))

++     , m_mipmap(false)

++     , m_live(true)

++     , m_recursive(false)

++     , m_dirtyTexture(true)

++     , m_multisampling(false)

++     , m_grab(false)

++     , m_mirrorHorizontal(false)

++     , m_mirrorVertical(true)

++ {

++     m_context = static_cast<QSGDefaultRenderContext *>(context);

++     m_rhi = m_context->rhi();

++     Q_ASSERT(m_rhi);

++ }

++

++ QSGRhiLayer::~QSGRhiLayer()

++ {

++     invalidated();

++ }

++

++ void QSGRhiLayer::invalidated()

++ {

++     releaseResources();

++

++     delete m_prevTexture;

++     m_prevTexture = nullptr;

++

++     delete m_renderer;

++     m_renderer = nullptr;

++ }

++

++ qint64 QSGRhiLayer::comparisonKey() const

++ {

++     return qint64(m_texture);

++ }

++

++ bool QSGRhiLayer::hasAlphaChannel() const

++ {

++     return true;

++ }

++

++ bool QSGRhiLayer::hasMipmaps() const

++ {

++     return m_mipmap;

++ }

++

++ QRhiTexture *QSGRhiLayer::rhiTexture() const

++ {

++     return m_prevTexture ? m_prevTexture : m_texture;

++ }

++

++ void QSGRhiLayer::commitTextureOperations(QRhi *rhi, QRhiResourceUpdateBatch *resourceUpdates)

++ {

++     Q_UNUSED(rhi);

++     Q_UNUSED(resourceUpdates);

++ }

++

++ bool QSGRhiLayer::updateTexture()

++ {

++     // called during the preprocess phase, outside of frame rendering -> good

++

++     bool doGrab = (m_live || m_grab) && m_dirtyTexture;

++     if (doGrab)

++         grab();

++

++     if (m_grab)

++         emit scheduledUpdateCompleted();

++

++     m_grab = false;

++     return doGrab;

++ }

++

++ void QSGRhiLayer::setHasMipmaps(bool mipmap)

++ {

++     if (mipmap == m_mipmap)

++         return;

++

++     m_mipmap = mipmap;

++     if (m_mipmap && m_texture)

++         markDirtyTexture();

++ }

++

++

++ void QSGRhiLayer::setItem(QSGNode *item)

++ {

++     if (item == m_item)

++         return;

++

++     m_item = item;

++

++     if (m_live && !m_item)

++         releaseResources();

++

++     markDirtyTexture();

++ }

++

++ void QSGRhiLayer::setRect(const QRectF &logicalRect)

++ {

++     if (logicalRect == m_logicalRect)

++         return;

++

++     m_logicalRect = logicalRect;

++     markDirtyTexture();

++ }

++

++ void QSGRhiLayer::setSize(const QSize &pixelSize)

++ {

++     if (pixelSize == m_pixelSize)

++         return;

++

++     const int textureSizeMax = m_rhi->resourceLimit(QRhi::TextureSizeMax);

++     m_pixelSize = pixelSize.boundedTo(QSize(textureSizeMax, textureSizeMax));

++

++     if (Q_UNLIKELY(m_pixelSize != pixelSize)) {

++         qWarning("QSGRhiLayer: Unsupported size requested: [%d, %d]. "

++                  "Maximum texture size: %d",

++                  pixelSize.width(),

++                  pixelSize.height(),

++                  textureSizeMax);

++     }

++

++     if (m_live && m_pixelSize.isNull())

++         releaseResources();

++

++     markDirtyTexture();

++ }

++

++ void QSGRhiLayer::setFormat(Format format)

++ {

++     QRhiTexture::Format rhiFormat = QRhiTexture::RGBA8;

++     switch (format) {

++     case RGBA16F:

++         rhiFormat = QRhiTexture::RGBA16F;

++         break;

++     case RGBA32F:

++         rhiFormat = QRhiTexture::RGBA32F;

++         break;

++     default:

++         break;

++     }

++

++     if (rhiFormat == m_format)

++         return;

++

++     if (m_rhi->isTextureFormatSupported(rhiFormat)) {

++         m_format = rhiFormat;

++         markDirtyTexture();

++     } else {

++         qWarning("QSGRhiLayer: Attempted to set unsupported texture format %d", int(rhiFormat));

++     }

++ }

++

++ void QSGRhiLayer::setLive(bool live)

++ {

++     if (live == m_live)

++         return;

++

++     m_live = live;

++

++     if (m_live && (!m_item || m_pixelSize.isNull()))

++         releaseResources();

++

++     markDirtyTexture();

++ }

++

++ void QSGRhiLayer::scheduleUpdate()

++ {

++     if (m_grab)

++         return;

++

++     m_grab = true;

++     if (m_dirtyTexture)

++         emit updateRequested();

++ }

++

++ void QSGRhiLayer::setRecursive(bool recursive)

++ {

++     m_recursive = recursive;

++ }

++

++ void QSGRhiLayer::setMirrorHorizontal(bool mirror)

++ {

++     m_mirrorHorizontal = mirror;

++ }

++

++ void QSGRhiLayer::setMirrorVertical(bool mirror)

++ {

++     m_mirrorVertical = mirror;

++ }

++

++ void QSGRhiLayer::markDirtyTexture()

++ {

++     m_dirtyTexture = true;

++     if (m_live || m_grab)

++         emit updateRequested();

++ }

++

++ void QSGRhiLayer::releaseResources()

++ {

++     delete m_rt;

++     m_rt = nullptr;

++

++     delete m_rtRp;

++     m_rtRp = nullptr;

++

++     m_ds.clear();

++

++     delete m_msaaColorBuffer;

++     m_msaaColorBuffer = nullptr;

++

++     if (m_prevTexture != m_texture)

++         delete m_texture;

++

++     m_texture = nullptr;

++

++     delete m_secondaryTexture;

++     m_secondaryTexture = nullptr;

++ }

++

++ void QSGRhiLayer::clearMainTexture()

++ {

++     std::unique_ptr<QRhiTextureRenderTarget> tempRt(m_rhi->newTextureRenderTarget({ m_texture }));

++     std::unique_ptr<QRhiRenderPassDescriptor> tempRp(tempRt->newCompatibleRenderPassDescriptor());

++     tempRt->setRenderPassDescriptor(tempRp.get());

++     if (tempRt->create()) {

++         m_context->currentFrameCommandBuffer()->beginPass(tempRt.get(), Qt::transparent, { 1.0f, 0 });

++         m_context->currentFrameCommandBuffer()->endPass();

++         // Keep the objects alive until a later frame, because the current frame

++         // is only going to be submitted (endFrame) by the scenegraph at a

++         // later point.

++         tempRt.release()->deleteLater();

++         tempRp.release()->deleteLater();

++     } else {

++         qWarning("Failed to clear layer main texture in recursive mode");

++     }

++ }

++

++ void QSGRhiLayer::grab()

++ {

++     if (!m_item || m_pixelSize.isEmpty()) {

++         releaseResources();

++         m_dirtyTexture = false;

++         return;

++     }

++

++     int effectiveSamples = m_samples;

++     // if no layer.samples was provided use the window's msaa setting

++     if (effectiveSamples <= 1)

++         effectiveSamples = m_context->msaaSampleCount();

++

++     const bool needsNewRt = !m_rt || m_rt->pixelSize() != m_pixelSize || (m_recursive && !m_secondaryTexture) || (m_texture && m_texture->format() != m_format);

++     const bool mipmapSettingChanged = m_texture && m_texture->flags().testFlag(QRhiTexture::MipMapped) != m_mipmap;

++     const bool msaaSettingChanged = (effectiveSamples > 1 && !m_msaaColorBuffer) || (effectiveSamples <= 1 && m_msaaColorBuffer);

++

++     if (needsNewRt ||mipmapSettingChanged || msaaSettingChanged) {

++         if (effectiveSamples <= 1) {

++             m_multisampling = false;

++         } else {

++             m_multisampling = m_rhi->isFeatureSupported(QRhi::MultisampleRenderBuffer);

++             if (!m_multisampling)

++                 qWarning("Layer requested %d samples but multisample renderbuffers are not supported", effectiveSamples);

++         }

++

++         QRhiTexture::Flags textureFlags = QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource;

++         if (m_mipmap)

++             textureFlags |= QRhiTexture::MipMapped | QRhiTexture::UsedWithGenerateMips;

++

++         // Not the same as m_context->useDepthBufferFor2D(), only the env.var

++         // is to be checked here. Consider a layer with a non-offscreen View3D

++         // in it. That still needs a depth buffer, even when the 2D content

++         // renders without relying on it (i.e. RenderMode2DNoDepthBuffer does

++         // not imply not having a depth/stencil attachment for the render

++         // target! The env.var serves as a hard switch, on the other hand, and

++         // that will likely break 3D for instance but that's fine)

++         static bool depthBufferEnabled = qEnvironmentVariableIsEmpty("QSG_NO_DEPTH_BUFFER");

++

++         if (m_recursive && m_texture) {

++             if (m_prevTexture != m_texture)

++                 delete m_prevTexture;

++             m_prevTexture = m_texture;

++         }

++

++         releaseResources();

++

++         if (m_multisampling) {

++             m_msaaColorBuffer = m_rhi->newRenderBuffer(QRhiRenderBuffer::Color, m_pixelSize, effectiveSamples);

++             if (!m_msaaColorBuffer->create()) {

++                 qWarning("Failed to build multisample color buffer for layer of size %dx%d, sample count %d",

++                          m_pixelSize.width(), m_pixelSize.height(), effectiveSamples);

++                 releaseResources();

++                 return;

++             }

++             m_texture = m_rhi->newTexture(m_format, m_pixelSize, 1, textureFlags);

++             if (!m_texture->create()) {

++                 qWarning("Failed to build texture for layer of size %dx%d", m_pixelSize.width(), m_pixelSize.height());

++                 releaseResources();

++                 return;

++             }

++             if (depthBufferEnabled) {

++                 m_ds = m_context->getDepthStencilBuffer(m_pixelSize, effectiveSamples);

++                 if (!m_ds) {

++                     releaseResources();

++                     return;

++                 }

++             }

++             QRhiTextureRenderTargetDescription desc;

++             QRhiColorAttachment color0(m_msaaColorBuffer);

++             if (m_recursive) {

++                 m_secondaryTexture = m_rhi->newTexture(m_format, m_pixelSize, 1, textureFlags);

++                 if (!m_secondaryTexture->create()) {

++                     qWarning("Failed to build secondary texture for layer of size %dx%d", m_pixelSize.width(), m_pixelSize.height());

++                     releaseResources();

++                     return;

++                 }

++                 color0.setResolveTexture(m_secondaryTexture);

++                 if (!m_prevTexture)

++                     clearMainTexture();

++             } else {

++                 color0.setResolveTexture(m_texture);

++             }

++             desc.setColorAttachments({ color0 });

++             if (depthBufferEnabled)

++                 desc.setDepthStencilBuffer(m_ds->ds);

++             m_rt = m_rhi->newTextureRenderTarget(desc);

++             m_rtRp = m_rt->newCompatibleRenderPassDescriptor();

++             if (!m_rtRp) {

++                 qWarning("Failed to build render pass descriptor for layer");

++                 releaseResources();

++                 return;

++             }

++             m_rt->setRenderPassDescriptor(m_rtRp);

++             if (!m_rt->create()) {

++                 qWarning("Failed to build texture render target for layer");

++                 releaseResources();

++                 return;

++             }

++         } else {

++             m_texture = m_rhi->newTexture(m_format, m_pixelSize, 1, textureFlags);

++             if (!m_texture->create()) {

++                 qWarning("Failed to build texture for layer of size %dx%d", m_pixelSize.width(), m_pixelSize.height());

++                 releaseResources();

++                 return;

++             }

++             if (depthBufferEnabled) {

++                 m_ds = m_context->getDepthStencilBuffer(m_pixelSize, 1);

++                 if (!m_ds) {

++                     releaseResources();

++                     return;

++                 }

++             }

++             QRhiColorAttachment color0(m_texture);

++             if (m_recursive) {

++                 // Here rt is associated with m_secondaryTexture instead of m_texture.

++                 // We will issue a copy to m_texture afterwards.

++                 m_secondaryTexture = m_rhi->newTexture(m_format, m_pixelSize, 1, textureFlags);

++                 if (!m_secondaryTexture->create()) {

++                     qWarning("Failed to build texture for layer of size %dx%d", m_pixelSize.width(), m_pixelSize.height());

++                     releaseResources();

++                     return;

++                 }

++                 color0.setTexture(m_secondaryTexture);

++                 if (!m_prevTexture)

++                     clearMainTexture();

++             }

++             QRhiTextureRenderTargetDescription desc({ color0 });

++             if (depthBufferEnabled)

++                 desc.setDepthStencilBuffer(m_ds->ds);

++             m_rt = m_rhi->newTextureRenderTarget(desc);

++             m_rtRp = m_rt->newCompatibleRenderPassDescriptor();

++             if (!m_rtRp) {

++                 qWarning("Failed to build render pass descriptor for layer");

++                 releaseResources();

++                 return;

++             }

++             m_rt->setRenderPassDescriptor(m_rtRp);

++             if (!m_rt->create()) {

++                 qWarning("Failed to build texture render target for layer");

++                 releaseResources();

++                 return;

++             }

++         }

++     }

++

++     QSGNode *root = m_item;

++     while (root->firstChild() && root->type() != QSGNode::RootNodeType)

++         root = root->firstChild();

++     if (root->type() != QSGNode::RootNodeType)

++         return;

++

++     if (!m_renderer) {

++         const bool useDepth = m_context->useDepthBufferFor2D();

++         const QSGRendererInterface::RenderMode renderMode = useDepth ? QSGRendererInterface::RenderMode2D

++                                                                      : QSGRendererInterface::RenderMode2DNoDepthBuffer;

++         m_renderer = m_context->createRenderer(renderMode);

++         connect(m_renderer, SIGNAL(sceneGraphChanged()), this, SLOT(markDirtyTexture()));

++     }

++     m_renderer->setRootNode(static_cast<QSGRootNode *>(root));

++     root->markDirty(QSGNode::DirtyForceUpdate); // Force matrix, clip and opacity update.

++     m_renderer->nodeChanged(root, QSGNode::DirtyForceUpdate); // Force render list update.

++

++     // This must not be moved. The flag must be reset only after the

++     // nodeChanged otherwise we end up with constantly updating even when the

++     // layer contents do not change.

++     m_dirtyTexture = false;

++

++     // The texture is essentially a virtual screen with a dpr == m_pixelSize / m_logicalRect

++     // For automatic texture sizes this factor will be equal to m_dpr.

++     // If the texture size is manually set, we need to know the actual ratio. This only

++     // works correctly for uniform rects, but this is already the prerequisite everywhere this

++     // factor is used.

++     if (m_logicalRect.isValid() && !m_pixelSize.isNull()) {

++         qreal actualDpr = std::max(m_pixelSize.width() / m_logicalRect.width(),

++                                    m_pixelSize.height() / m_logicalRect.height());

++         m_renderer->setDevicePixelRatio(actualDpr);

++     } else {

++         m_renderer->setDevicePixelRatio(m_dpr);

++     }

++     m_renderer->setDeviceRect(m_pixelSize);

++     m_renderer->setViewportRect(m_pixelSize);

++

++     QRectF mirrored; // in logical coordinates (no dpr) since this gets passed to setProjectionMatrixToRect()

++

++     // In the unlikely event of back/front face culling used by a custom

++     // material or effect in the layer, the default front face setting may be

++     // wrong. Rather, it needs to invert based on what the vertex shader does,

++     // and so on the rect (and so matrix) generated here.

++     bool frontFaceSwap = false;

++

++     if (m_rhi->isYUpInFramebuffer()) { // basically OpenGL

++         mirrored = QRectF(m_mirrorHorizontal ? m_logicalRect.right() : m_logicalRect.left(),

++                           m_mirrorVertical ? m_logicalRect.bottom() : m_logicalRect.top(),

++                           m_mirrorHorizontal ? -m_logicalRect.width() : m_logicalRect.width(),

++                           m_mirrorVertical ? -m_logicalRect.height() : m_logicalRect.height());

++         if (m_mirrorHorizontal)

++             frontFaceSwap = !frontFaceSwap;

++         if (m_mirrorVertical)

++             frontFaceSwap = !frontFaceSwap;

++     } else { // APIs other than OpenGL

++         mirrored = QRectF(m_mirrorHorizontal ? m_logicalRect.right() : m_logicalRect.left(),

++                           m_mirrorVertical ? m_logicalRect.top() : m_logicalRect.bottom(),

++                           m_mirrorHorizontal ? -m_logicalRect.width() : m_logicalRect.width(),

++                           m_mirrorVertical ? m_logicalRect.height() : -m_logicalRect.height());

++         if (m_mirrorHorizontal)

++             frontFaceSwap = !frontFaceSwap;

++         if (!m_mirrorVertical)

++             frontFaceSwap = !frontFaceSwap;

++     }

++

++     QSGAbstractRenderer::MatrixTransformFlags matrixFlags;

++     if (!m_rhi->isYUpInNDC())

++         matrixFlags |= QSGAbstractRenderer::MatrixTransformFlipY;

++

++     m_renderer->setProjectionMatrixToRect(mirrored, matrixFlags);

++     m_renderer->setInvertFrontFace(frontFaceSwap);

++     m_renderer->setClearColor(Qt::transparent);

++     m_renderer->setRenderTarget({ m_rt, m_rtRp, m_context->currentFrameCommandBuffer() });

++

++     QRhiResourceUpdateBatch *resourceUpdates = nullptr;

++

++     // render with our own "sub-renderer" (this will just add a render pass to the command buffer)

++     if (m_recursive) {

++         m_context->renderNextFrame(m_renderer);

++         if (!resourceUpdates)

++             resourceUpdates = m_rhi->nextResourceUpdateBatch();

++         resourceUpdates->copyTexture(m_texture, m_secondaryTexture);

++         if (m_prevTexture) {

++             delete m_prevTexture;

++             m_prevTexture = nullptr;

++         }

++     } else {

++         m_context->renderNextFrame(m_renderer);

++     }

++

++     if (m_mipmap) {

++         if (!resourceUpdates)

++             resourceUpdates = m_rhi->nextResourceUpdateBatch();

++         // going to be expensive - if done every frame - but the user asked for it...

++         resourceUpdates->generateMips(m_texture);

++     }

++

++     // Do not defer committing the resource updates to the main pass - with

++     // multiple layers there can be dependencies, so the texture should be

++     // usable once we return.

++     m_context->currentFrameCommandBuffer()->resourceUpdate(resourceUpdates);

++

++     root->markDirty(QSGNode::DirtyForceUpdate); // Force matrix, clip, opacity and render list update.

++

++     if (m_recursive)

++         markDirtyTexture(); // Continuously update if 'live' and 'recursive'.

++ }

++

++ QImage QSGRhiLayer::toImage() const

++ {

++     if (!m_texture)

++         return QImage();

++

++     QRhiCommandBuffer *cb = m_context->currentFrameCommandBuffer();

++     QRhiResourceUpdateBatch *resourceUpdates = m_rhi->nextResourceUpdateBatch();

++     QRhiReadbackResult result;

++     QRhiReadbackDescription readbackDesc(m_texture);

++     resourceUpdates->readBackTexture(readbackDesc, &result);

++

++     cb->resourceUpdate(resourceUpdates);

++

++     // Inefficient but what can you do. We need the results right away. This is

++     // not something that occurs in a normal rendering process anyway. (used by

++     // QQuickItem's grabToImage).

++     m_rhi->finish();

++

++     if (result.data.isEmpty()) {

++         qWarning("Layer grab failed");

++         return QImage();

++     }

++

++     // There is little room for negotiation here, the texture is one of the formats from setFormat.

++     // Also, Quick is always premultiplied alpha.

++     QImage::Format imageFormat = QImage::Format_RGBA8888_Premultiplied;

++     if (m_format == QRhiTexture::RGBA16F)

++         imageFormat = QImage::Format_RGBA16FPx4_Premultiplied;

++     else if (m_format == QRhiTexture::RGBA32F)

++         imageFormat = QImage::Format_RGBA32FPx4_Premultiplied;

++

++     const uchar *p = reinterpret_cast<const uchar *>(result.data.constData());

++     return QImage(p, result.pixelSize.width(), result.pixelSize.height(), imageFormat).flipped();

++ }

++

++ QRectF QSGRhiLayer::normalizedTextureSubRect() const

++ {

++     return QRectF(m_mirrorHorizontal ? 1 : 0,

++                   m_mirrorVertical ? 0 : 1,

++                   m_mirrorHorizontal ? -1 : 1,

++                   m_mirrorVertical ? 1 : -1);

++ }

++

++ #include "moc_qsgrhilayer_p.cpp"

Revision control