qrhi_p.h - mozsearch

qt/qtbase/src/gui/rhi/qrhi_p.h (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2023 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

#ifndef QRHI_P_H

#define QRHI_P_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 <rhi/qrhi.h>

#include <QBitArray>

#include <QAtomicInt>

#include <QElapsedTimer>

#include <QLoggingCategory>

#include <QtCore/qhash.h>

#include <QtCore/qset.h>

#include <QtCore/qvarlengtharray.h>

#include <algorithm>

#include <utility>

QT_BEGIN_NAMESPACE

#define QRHI_RES(t, x) static_cast<t *>(x)

#define QRHI_RES_RHI(t) t *rhiD = static_cast<t *>(m_rhi)

Q_DECLARE_LOGGING_CATEGORY(QRHI_LOG_INFO)

Q_DECLARE_LOGGING_CATEGORY(QRHI_LOG_RUB)

class QRhiImplementation

public:

    virtual ~QRhiImplementation();

    virtual bool create(QRhi::Flags flags) = 0;

    virtual void destroy() = 0;

    virtual QRhi::AdapterList enumerateAdaptersBeforeCreate(QRhiNativeHandles *nativeHandles) const;

    virtual QRhiGraphicsPipeline *createGraphicsPipeline() = 0;

    virtual QRhiComputePipeline *createComputePipeline() = 0;

    virtual QRhiShaderResourceBindings *createShaderResourceBindings() = 0;

    virtual QRhiBuffer *createBuffer(QRhiBuffer::Type type,

                                     QRhiBuffer::UsageFlags usage,

                                     quint32 size) = 0;

    virtual QRhiRenderBuffer *createRenderBuffer(QRhiRenderBuffer::Type type,

                                                 const QSize &pixelSize,

                                                 int sampleCount,

                                                 QRhiRenderBuffer::Flags flags,

                                                 QRhiTexture::Format backingFormatHint) = 0;

    virtual QRhiTexture *createTexture(QRhiTexture::Format format,

                                       const QSize &pixelSize,

                                       int depth,

                                       int arraySize,

                                       int sampleCount,

                                       QRhiTexture::Flags flags) = 0;

    virtual QRhiSampler *createSampler(QRhiSampler::Filter magFilter,

                                       QRhiSampler::Filter minFilter,

                                       QRhiSampler::Filter mipmapMode,

                                       QRhiSampler:: AddressMode u,

                                       QRhiSampler::AddressMode v,

                                       QRhiSampler::AddressMode w) = 0;

    virtual QRhiTextureRenderTarget *createTextureRenderTarget(const QRhiTextureRenderTargetDescription &desc,

                                                               QRhiTextureRenderTarget::Flags flags) = 0;

    virtual QRhiShadingRateMap *createShadingRateMap() = 0;

    virtual QRhiIndirectCommandBuffer *createIndirectCommandBuffer(QRhiIndirectCommandBuffer::Type type,

                                                                   quint32 maxCommandCount);

    virtual void buildIndirect(QRhiCommandBuffer *cb, QRhiIndirectCommandBuffer *icb,

                               const QRhiIndirectCommandBufferBuildInfo &info);

    virtual void executeIndirect(QRhiCommandBuffer *cb, QRhiIndirectCommandBuffer *icb,

                                 quint32 firstCommand, quint32 commandCount);

    virtual void commitIndirectCommandBuffer(QRhiResourceUpdateBatch *u,

                                             QRhiIndirectCommandBuffer *icb);

    virtual QRhiSwapChain *createSwapChain() = 0;

    virtual QRhi::FrameOpResult beginFrame(QRhiSwapChain *swapChain, QRhi::BeginFrameFlags flags) = 0;

    virtual QRhi::FrameOpResult endFrame(QRhiSwapChain *swapChain, QRhi::EndFrameFlags flags) = 0;

    virtual QRhi::FrameOpResult beginOffscreenFrame(QRhiCommandBuffer **cb, QRhi::BeginFrameFlags flags) = 0;

    virtual QRhi::FrameOpResult endOffscreenFrame(QRhi::EndFrameFlags flags) = 0;

    virtual QRhi::FrameOpResult finish() = 0;

    virtual void resourceUpdate(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resourceUpdates) = 0;

    virtual void beginPass(QRhiCommandBuffer *cb,

                           QRhiRenderTarget *rt,

                           const QColor &colorClearValue,

                           const QRhiDepthStencilClearValue &depthStencilClearValue,

                           QRhiResourceUpdateBatch *resourceUpdates,

                           QRhiCommandBuffer::BeginPassFlags flags) = 0;

    virtual void endPass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resourceUpdates) = 0;

    virtual void setGraphicsPipeline(QRhiCommandBuffer *cb,

                                     QRhiGraphicsPipeline *ps) = 0;

    virtual void setShaderResources(QRhiCommandBuffer *cb,

                                    QRhiShaderResourceBindings *srb,

                                    int dynamicOffsetCount,

                                    const QRhiCommandBuffer::DynamicOffset *dynamicOffsets) = 0;

    virtual void setVertexInput(QRhiCommandBuffer *cb,

                                int startBinding, int bindingCount, const QRhiCommandBuffer::VertexInput *bindings,

                                QRhiBuffer *indexBuf, quint32 indexOffset,

                                QRhiCommandBuffer::IndexFormat indexFormat) = 0;

    virtual void setViewport(QRhiCommandBuffer *cb, const QRhiViewport &viewport) = 0;

    virtual void setScissor(QRhiCommandBuffer *cb, const QRhiScissor &scissor) = 0;

    virtual void setBlendConstants(QRhiCommandBuffer *cb, const QColor &c) = 0;

    virtual void setStencilRef(QRhiCommandBuffer *cb, quint32 refValue) = 0;

    virtual void setPushConstants(QRhiCommandBuffer *cb, quint32 offset, quint32 size, const void *data) = 0;

    virtual void setShadingRate(QRhiCommandBuffer *cb, const QSize &coarsePixelSize) = 0;

    virtual void draw(QRhiCommandBuffer *cb, quint32 vertexCount,

                      quint32 instanceCount, quint32 firstVertex, quint32 firstInstance) = 0;

    virtual void drawIndexed(QRhiCommandBuffer *cb, quint32 indexCount,

                             quint32 instanceCount, quint32 firstIndex,

                             qint32 vertexOffset, quint32 firstInstance) = 0;

    virtual void drawIndirect(QRhiCommandBuffer *cb, QRhiBuffer *indirectBuffer,

                              quint32 offset, quint32 drawCount, quint32 stride) = 0;

    virtual void drawIndexedIndirect(QRhiCommandBuffer *cb, QRhiBuffer *indirectBuffer,

                                     quint32 offset, quint32 drawCount, quint32 stride) = 0;

    virtual void drawIndirectCount(QRhiCommandBuffer *cb,

                                   QRhiBuffer *indirectBuffer, quint32 indirectBufferOffset,

                                   QRhiBuffer *countBuffer, quint32 countBufferOffset,

                                   quint32 maxDrawCount, quint32 stride) = 0;

    virtual void drawIndexedIndirectCount(QRhiCommandBuffer *cb,

                                          QRhiBuffer *indirectBuffer, quint32 indirectBufferOffset,

                                          QRhiBuffer *countBuffer, quint32 countBufferOffset,

                                          quint32 maxDrawCount, quint32 stride) = 0;

    virtual void debugMarkBegin(QRhiCommandBuffer *cb, const QByteArray &name) = 0;

    virtual void debugMarkEnd(QRhiCommandBuffer *cb) = 0;

    virtual void debugMarkMsg(QRhiCommandBuffer *cb, const QByteArray &msg) = 0;

    virtual void beginComputePass(QRhiCommandBuffer *cb,

                                  QRhiResourceUpdateBatch *resourceUpdates,

                                  QRhiCommandBuffer::BeginPassFlags flags) = 0;

    virtual void endComputePass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resourceUpdates) = 0;

    virtual void setComputePipeline(QRhiCommandBuffer *cb, QRhiComputePipeline *ps) = 0;

    virtual void dispatch(QRhiCommandBuffer *cb, int x, int y, int z) = 0;

    virtual void dispatchIndirect(QRhiCommandBuffer *cb, QRhiBuffer *indirectBuffer,

                                  quint32 offset) = 0;

    virtual const QRhiNativeHandles *nativeHandles(QRhiCommandBuffer *cb) = 0;

    virtual void beginExternal(QRhiCommandBuffer *cb) = 0;

    virtual void endExternal(QRhiCommandBuffer *cb) = 0;

    virtual double lastCompletedGpuTime(QRhiCommandBuffer *cb) = 0;

    virtual QList<int> supportedSampleCounts() const = 0;

    virtual int ubufAlignment() const = 0;

    virtual QList<QSize> supportedShadingRates(int sampleCount) const = 0;

    virtual bool isYUpInFramebuffer() const = 0;

    virtual bool isYUpInNDC() const = 0;

    virtual bool isClipDepthZeroToOne() const = 0;

    virtual QMatrix4x4 clipSpaceCorrMatrix() const = 0;

    virtual bool isTextureFormatSupported(QRhiTexture::Format format, QRhiTexture::Flags flags) const = 0;

    virtual bool isFeatureSupported(QRhi::Feature feature) const = 0;

    virtual int resourceLimit(QRhi::ResourceLimit limit) const = 0;

    virtual const QRhiNativeHandles *nativeHandles() = 0;

    virtual QRhiDriverInfo driverInfo() const = 0;

    virtual QRhiStats statistics() = 0;

    virtual bool makeThreadLocalNativeContextCurrent() = 0;

    virtual void setQueueSubmitParams(QRhiNativeHandles *params) = 0;

    virtual void releaseCachedResources() = 0;

    virtual bool isDeviceLost() const = 0;

    virtual QByteArray pipelineCacheData() = 0;

    virtual void setPipelineCacheData(const QByteArray &data) = 0;

    static QRhiImplementation *newInstance(QRhi::Implementation impl, QRhiInitParams *params, QRhiNativeHandles *importDevice);

    void prepareForCreate(QRhi *rhi, QRhi::Implementation impl, QRhi::Flags flags, QRhiAdapter *adapter);

    bool isCompressedFormat(QRhiTexture::Format format) const;

    bool compressedFormatInfo(QRhiTexture::Format format, const QSize &size,

                              quint32 *bpl, quint32 *byteSize,

                              QSize *blockDim) const;

    bool textureFormatInfo(QRhiTexture::Format format, const QSize &size,

                           quint32 *bpl, quint32 *byteSize, quint32 *bytesPerPixel) const;

    bool isStencilSupportingFormat(QRhiTexture::Format format) const;

    void registerResource(QRhiResource *res, bool ownsNativeResources = true)

        // The ownsNativeResources is relevant for the (graphics resource) leak

        // check in ~QRhiImplementation; when false, the registration's sole

        // purpose is to automatically null out the resource's m_rhi pointer in

        // case the rhi goes away first. (which should not happen in

        // well-written applications but we try to be graceful)

        resources.insert(res, ownsNativeResources);

    void unregisterResource(QRhiResource *res)

        resources.remove(res);

    void addDeleteLater(QRhiResource *res)

        if (inFrame)

            pendingDeleteResources.insert(res);

        else

            delete res;

    void addCleanupCallback(const QRhi::CleanupCallback &callback)

        cleanupCallbacks.append(callback);

    void addCleanupCallback(const void *key, const QRhi::CleanupCallback &callback)

        keyedCleanupCallbacks[key] = callback;

    void removeCleanupCallback(const void *key)

        keyedCleanupCallbacks.remove(key);

    bool sanityCheckGraphicsPipeline(QRhiGraphicsPipeline *ps);

    bool sanityCheckShaderResourceBindings(QRhiShaderResourceBindings *srb);

    bool sanityCheckResourceOwnership(QRhiResource *maybeResource);

    void updateLayoutDesc(QRhiShaderResourceBindings *srb);

    quint32 pipelineCacheRhiId() const

        const quint32 ver = (QT_VERSION_MAJOR << 16) | (QT_VERSION_MINOR << 8) | (QT_VERSION_PATCH);

        return (quint32(implType) << 24) | ver;

    void pipelineCreationStart()

        pipelineCreationTimer.start();

    void pipelineCreationEnd()

        accumulatedPipelineCreationTime += pipelineCreationTimer.elapsed();

    qint64 totalPipelineCreationTime() const

        return accumulatedPipelineCreationTime;

    QRhiVertexInputAttribute::Format shaderDescVariableFormatToVertexInputFormat(QShaderDescription::VariableType type) const;

    quint32 byteSizePerVertexForVertexInputFormat(QRhiVertexInputAttribute::Format format) const;

    static const QRhiShaderResourceBinding::Data *shaderResourceBindingData(const QRhiShaderResourceBinding &binding)

        return &binding.d;

    static QRhiShaderResourceBinding::Data *shaderResourceBindingData(QRhiShaderResourceBinding &binding)

        return &binding.d;

    static bool sortedBindingLessThan(const QRhiShaderResourceBinding &a, const QRhiShaderResourceBinding &b)

        return a.d.binding < b.d.binding;

    int effectiveSampleCount(int sampleCount) const;

    QSize clampedSubResourceUploadSize(QSize size, QPoint dstPos, int level, QSize textureSizeAtLevelZero, bool warn = true);

    QSize clampedSubResourceUploadSizeForSourceData(QSize size, quint32 bpl, quint32 bytesPerPixel,

                                                    qsizetype dataSize, bool warn = true);

    void runCleanup();

    QRhi *q;

    static const int MAX_SHADER_CACHE_ENTRIES = 128;

    static const quint32 MAX_BINARY_CACHE_BYTES = 16 * 1024 * 1024;

    bool debugMarkers = false;

    bool timestamps = false;

    int currentFrameSlot = 0; // for vk, mtl, and similar. unused by gl and d3d11.

    bool inFrame = false;

    QRhiCommandBuffer *currentOffscreenCb = nullptr;

    QRhiAdapter *requestedRhiAdapter = nullptr;

    QHash<QRhiResource *, bool> resources;

private:

    QRhi::Implementation implType;

    QThread *implThread;

    QVarLengthArray<QRhiResourceUpdateBatch *, 4> resUpdPool;

    quint64 resUpdPoolMap = 0;

    int lastResUpdIdx = -1;

    QSet<QRhiResource *> pendingDeleteResources;

    QVarLengthArray<QRhi::CleanupCallback, 4> cleanupCallbacks;

    QHash<const void *, QRhi::CleanupCallback> keyedCleanupCallbacks;

    QElapsedTimer pipelineCreationTimer;

    qint64 accumulatedPipelineCreationTime = 0;

    friend class QRhi;

    friend class QRhiResourceUpdateBatchPrivate;

    friend class QRhiBufferData;

};

inline quint32 qrhiBinaryCacheEntryByteSize(const QByteArray &data)

    return quint32(data.size());

template <typename Key, typename Value,

          quint32 MaxBytes = QRhiImplementation::MAX_BINARY_CACHE_BYTES>

struct QRhiBinaryCache

    explicit QRhiBinaryCache(const char *name) : name(name) { }

    QHash<Key, Value> data;

    quint32 dataByteSize = 0;

    const char *name;

    void clear()

        data.clear();

        dataByteSize = 0;

    void insertWithCapacityLimit(const Key &key, const Value &value)

        const quint32 entrySize = qrhiBinaryCacheEntryByteSize(value);

        // Replacing an entry must not make the running total drift. This does

        // happen in practice: trySaveToPipelineCache() in the OpenGL backend

        // replaces the existing entry when forced to.

        auto it = data.find(key);

        if (it != data.end()) {

            dataByteSize -= qrhiBinaryCacheEntryByteSize(*it);

            *it = value;

            dataByteSize += entrySize;

            return;

        if (dataByteSize + entrySize > MaxBytes) {

            // Use the simplest strategy: too much cached data -> drop it all.

            // An entry larger than the entire budget is still inserted, so the

            // cache can hold up to the budget plus one entry.

            qCDebug(QRHI_LOG_INFO, "%s would exceed %u bytes, dropping all %d entries (%u bytes)",

                    name, MaxBytes, int(data.count()), dataByteSize);

            clear();

        data.insert(key, value);

        dataByteSize += entrySize;

};

struct QRhiDebugHooks

    void (*frameEnd)(QRhiImplementation *d, QRhiSwapChain *swapChain, QRhiCommandBuffer *cb) = nullptr;

    void (*rhiAboutToBeDestroyed)(QRhiImplementation *d) = nullptr;

};

Q_GUI_EXPORT extern QRhiDebugHooks qrhiDebugHooks;

class QRhiBufferBackedIndirectCommandBuffer : public QRhiIndirectCommandBuffer

public:

    QRhiBufferBackedIndirectCommandBuffer(QRhiImplementation *rhi, Type type, quint32 maxCommandCount);

    ~QRhiBufferBackedIndirectCommandBuffer();

    void destroy() override;

    bool create() override;

    // no-op if uploadedGeneration matches the current one, so safe to call regularly

    void enqueueUpload(QRhiResourceUpdateBatch *u);

    void execute(QRhiCommandBuffer *cb, quint32 firstCommand, quint32 commandCount);

    void build(const QRhiIndirectCommandBufferBuildInfo &info);

    bool valid = false;

    QRhiBuffer *buffer = nullptr;

    quint64 uploadedGeneration = 0;

    QRhiIndirectCommandBufferBuildInfo buildInfo;

};

enum QRhiTargetRectBoundMode

    UnBounded,

    Bounded

};

template<QRhiTargetRectBoundMode boundingMode, typename T, size_t N>

bool qrhi_toTopLeftRenderTargetRect(const QSize &outputSize, const std::array<T, N> &r,

                                    T *x, T *y, T *w, T *h)

    // x,y are bottom-left in QRhiScissor and QRhiViewport but top-left in

    // Vulkan/Metal/D3D. Our input is an OpenGL-style scissor rect where both

    // negative x or y, and partly or completely out of bounds rects are

    // allowed. The only thing the input here cannot have is a negative width

    // or height. We must handle all other input gracefully, clamping to a zero

    // width or height rect in the worst case, and ensuring the resulting rect

    // is inside the rendertarget's bounds because some APIs' validation/debug

    // layers are allergic to out of bounds scissor rects.

    const T outputWidth = outputSize.width();

    const T outputHeight = outputSize.height();

    const T inputWidth = r[2];

    const T inputHeight = r[3];

    if (inputWidth < 0 || inputHeight < 0)

        return false;

    *x = r[0];

    *y = outputHeight - (r[1] + inputHeight);

    *w = inputWidth;

    *h = inputHeight;

    if (boundingMode == Bounded) {

        const T widthOffset = *x < 0 ? -*x : 0;

        const T heightOffset = *y < 0 ? -*y : 0;

        *w = *x < outputWidth ? qMax<T>(0, inputWidth - widthOffset) : 0;

        *h = *y < outputHeight ? qMax<T>(0, inputHeight - heightOffset) : 0;

        if (outputWidth > 0)

            *x = qBound<T>(0, *x, outputWidth - 1);

        if (outputHeight > 0)

            *y = qBound<T>(0, *y, outputHeight - 1);

        if (*x + *w > outputWidth)

            *w = qMax<T>(0, outputWidth - *x);

        if (*y + *h > outputHeight)

            *h = qMax<T>(0, outputHeight - *y);

    return true;

struct QRhiBufferDataPrivate

    Q_DISABLE_COPY_MOVE(QRhiBufferDataPrivate)

    QRhiBufferDataPrivate() { } // don't value-initialize smallData

    int ref = 1;

    quint32 size = 0;

    QByteArray largeData;

    static constexpr quint32 SMALL_DATA_SIZE = 1024;

    char smallData[SMALL_DATA_SIZE];

};

// no detach-with-contents, no atomic refcount, no shrink

class QRhiBufferData

public:

    QRhiBufferData() = default;

    ~QRhiBufferData()

        if (d && !--d->ref)

            delete d;

    QRhiBufferData(const QRhiBufferData &other)

        : d(other.d)

        if (d)

            d->ref += 1;

    QRhiBufferData &operator=(const QRhiBufferData &other)

        if (d == other.d)

            return *this;

        if (other.d)

            other.d->ref += 1;

        if (d && !--d->ref)

            delete d;

        d = other.d;

        return *this;

    const char *constData() const

        return d ? (d->size <= QRhiBufferDataPrivate::SMALL_DATA_SIZE ? d->smallData : d->largeData.constData()) : nullptr;

    quint32 size() const

        return d ? d->size : 0;

    quint32 largeAlloc() const

        return d ? d->largeData.size() : 0;

    void assign(const char *s, quint32 size)

        if (!d) {

            d = new QRhiBufferDataPrivate;

        } else if (d->ref != 1) {

            if (QRHI_LOG_RUB().isDebugEnabled())

                qDebug("[rub] QRhiBufferData %p/%p new backing due to no-copy detach, ref was %d", this, d, d->ref);

            d->ref -= 1;

            d = new QRhiBufferDataPrivate;

        d->size = size;

        if (size <= QRhiBufferDataPrivate::SMALL_DATA_SIZE) {

            memcpy(d->smallData, s, size);

        } else {

            if (QRHI_LOG_RUB().isDebugEnabled() && largeAlloc() < size)

                qDebug("[rub] QRhiBufferData %p/%p new large data allocation %u -> %u", this, d, largeAlloc(), size);

            d->largeData.assign(QByteArrayView(s, size)); // keeps capacity

    void assign(QByteArray data)

        if (!d) {

            d = new QRhiBufferDataPrivate;

        } else if (d->ref != 1) {

            if (QRHI_LOG_RUB().isDebugEnabled())

                qDebug("[rub] QRhiBufferData %p/%p new backing due to no-copy detach, ref was %d", this, d, d->ref);

            d->ref -= 1;

            d = new QRhiBufferDataPrivate;

        d->size = data.size();

        if (d->size <= QRhiBufferDataPrivate::SMALL_DATA_SIZE) {

            memcpy(d->smallData, data.constData(), data.size());

        } else {

            d->largeData = std::move(data);

private:

    QRhiBufferDataPrivate *d = nullptr;

};

Q_DECLARE_TYPEINFO(QRhiBufferData, Q_RELOCATABLE_TYPE);

class QRhiResourceUpdateBatchPrivate

public:

    struct BufferOp {

        enum Type {

            DynamicUpdate,

            StaticUpload,

            Read,

            Copy,

            Clear

};

        Type type;

        QRhiBuffer *buf;

        quint32 offset;

        QRhiBufferData data;

        quint32 readSize; // also the number of bytes to copy with Copy, or to fill with Clear

        QRhiReadbackResult *result;

        QRhiBuffer *src;

        quint32 srcOffset;

        quint8 fillValue;

        static BufferOp dynamicUpdate(QRhiBuffer *buf, quint32 offset, quint32 size, const void *data)

            BufferOp op = {};

            changeToDynamicUpdate(&op, buf, offset, size, data);

            return op;

        static void changeToDynamicUpdate(BufferOp *op, QRhiBuffer *buf, quint32 offset, quint32 size, const void *data)

            op->type = DynamicUpdate;

            op->buf = buf;

            op->offset = offset;

            const int effectiveSize = size ? size : buf->size();

            op->data.assign(reinterpret_cast<const char *>(data), effectiveSize);

        static BufferOp dynamicUpdate(QRhiBuffer *buf, quint32 offset, QByteArray data)

            BufferOp op = {};

            changeToDynamicUpdate(&op, buf, offset, std::move(data));

            return op;

        static void changeToDynamicUpdate(BufferOp *op, QRhiBuffer *buf, quint32 offset, QByteArray data)

            op->type = DynamicUpdate;

            op->buf = buf;

            op->offset = offset;

            op->data.assign(std::move(data));

        static BufferOp staticUpload(QRhiBuffer *buf, quint32 offset, quint32 size, const void *data)

            BufferOp op = {};

            changeToStaticUpload(&op, buf, offset, size, data);

            return op;

        static void changeToStaticUpload(BufferOp *op, QRhiBuffer *buf, quint32 offset, quint32 size, const void *data)

            op->type = StaticUpload;

            op->buf = buf;

            op->offset = offset;

            const int effectiveSize = size ? size : buf->size();

            op->data.assign(reinterpret_cast<const char *>(data), effectiveSize);

        static BufferOp staticUpload(QRhiBuffer *buf, quint32 offset, QByteArray data)

            BufferOp op = {};

            changeToStaticUpload(&op, buf, offset, std::move(data));

            return op;

        static void changeToStaticUpload(BufferOp *op, QRhiBuffer *buf, quint32 offset, QByteArray data)

            op->type = StaticUpload;

            op->buf = buf;

            op->offset = offset;

            op->data.assign(std::move(data));

        static BufferOp read(QRhiBuffer *buf, quint32 offset, quint32 size, QRhiReadbackResult *result)

            BufferOp op = {};

            op.type = Read;

            op.buf = buf;

            op.offset = offset;

            op.readSize = size;

            op.result = result;

            return op;

        static BufferOp copy(QRhiBuffer *dst, QRhiBuffer *src, quint32 dstOffset,

                             quint32 srcOffset, quint32 size)

            BufferOp op = {};

            op.type = Copy;

            op.buf = dst;

            op.offset = dstOffset;

            op.readSize = size;

            op.src = src;

            op.srcOffset = srcOffset;

            return op;

        static BufferOp clear(QRhiBuffer *buf, quint32 offset, quint32 size, quint8 value)

            BufferOp op = {};

            op.type = Clear;

            op.buf = buf;

            op.offset = offset;

            op.readSize = size;

            op.fillValue = value;

            return op;

        // For the APIs that clear in units of 32 bits: fillValue repeated in

        // all four bytes of the word, e.g. 0xAB becomes 0xABABABAB.

        quint32 fillValue32() const

            return quint32(fillValue) * 0x01010101u;

};

    struct TextureOp {

        enum Type {

            Upload,

            Copy,

            Read,

            GenMips

};

        Type type;

        QRhiTexture *dst;

        // Specifying multiple uploads for a subresource must be supported.

        // In the backend this can then end up, where applicable, as a

        // single, batched copy operation with only one set of barriers.

        // This helps when doing for example glyph cache fills.

//

        // Stored as a flat list sorted by layer, then level, preserving the

        // submission order within a subresource. (a dense layer x level grid

        // of containers costs kilobytes per op even when empty, and there

        // are dozens of ops preallocated in each batch)

        struct SubresourceUpload {

            int layer;

            int level;

            QRhiTextureSubresourceUploadDescription desc;

};

        QVarLengthArray<SubresourceUpload, 4> subresDesc;

        QRhiTexture *src;

        QRhiTextureCopyDescription desc;

        QRhiReadbackDescription rb;

        QRhiReadbackResult *result;

        static TextureOp upload(QRhiTexture *tex, const QRhiTextureUploadDescription &desc)

            TextureOp op = {};

            op.type = Upload;

            op.dst = tex;

            for (auto it = desc.cbeginEntries(), itEnd = desc.cendEntries(); it != itEnd; ++it)

                op.subresDesc.append({ it->layer(), it->level(), it->description() });

            std::stable_sort(op.subresDesc.begin(), op.subresDesc.end(),

                             [](const SubresourceUpload &a, const SubresourceUpload &b) {

                                 return a.layer != b.layer ? a.layer < b.layer : a.level < b.level;

});

            return op;

        static TextureOp copy(QRhiTexture *dst, QRhiTexture *src, const QRhiTextureCopyDescription &desc)

            TextureOp op = {};

            op.type = Copy;

            op.dst = dst;

            op.src = src;

            op.desc = desc;

            return op;

        static TextureOp read(const QRhiReadbackDescription &rb, QRhiReadbackResult *result)

            TextureOp op = {};

            op.type = Read;

            op.rb = rb;

            op.result = result;

            return op;

        static TextureOp genMips(QRhiTexture *tex)

            TextureOp op = {};

            op.type = GenMips;

            op.dst = tex;

            return op;

};

    int activeBufferOpCount = 0; // this is the real number of used elements in bufferOps, not bufferOps.count()

    static const int BUFFER_OPS_STATIC_ALLOC = 64;

    QVarLengthArray<BufferOp, BUFFER_OPS_STATIC_ALLOC> bufferOps;

    int activeTextureOpCount = 0; // this is the real number of used elements in textureOps, not textureOps.count()

    static const int TEXTURE_OPS_STATIC_ALLOC = 32;

    QVarLengthArray<TextureOp, TEXTURE_OPS_STATIC_ALLOC> textureOps;

    QRhiResourceUpdateBatch *q = nullptr;

    QRhiImplementation *rhi = nullptr;

    int poolIndex = -1;

    void free();

    void merge(QRhiResourceUpdateBatchPrivate *other);

    bool hasOptimalCapacity() const;

    void trimOpLists();

    static QRhiResourceUpdateBatchPrivate *get(QRhiResourceUpdateBatch *b) { return b->d; }

};

template<typename T>

struct QRhiBatchedBindings

    void feed(int binding, T resource) { // binding must be strictly increasing

        if (curBinding == -1 || binding > curBinding + 1) {

            finish();

            curBatch.startBinding = binding;

            curBatch.resources.clear();

            curBatch.resources.append(resource);

        } else {

            Q_ASSERT(binding == curBinding + 1);

            curBatch.resources.append(resource);

        curBinding = binding;

    bool finish() {

        if (!curBatch.resources.isEmpty())

            batches.append(curBatch);

        return !batches.isEmpty();

    void clear() {

        batches.clear();

        curBatch.resources.clear();

        curBinding = -1;

    struct Batch {

        uint startBinding;

        QVector<T> resources;

        bool operator==(const Batch &other) const

            return startBinding == other.startBinding && resources == other.resources;

        bool operator!=(const Batch &other) const

            return !operator==(other);

};

    // some backends make copies of QRhiBatchedBindings -> implicit sharing and

    // not having a (possibly wasted) prealloc are beneficial -> use QVector

    // instead of QVLA

    QVector<Batch> batches; // sorted by startBinding

    bool operator==(const QRhiBatchedBindings<T> &other) const

        return batches == other.batches;

    bool operator!=(const QRhiBatchedBindings<T> &other) const

        return !operator==(other);

private:

    Batch curBatch;

    int curBinding = -1;

};

class QRhiGlobalObjectIdGenerator

public:

#ifdef Q_ATOMIC_INT64_IS_SUPPORTED

    using Type = quint64;

#else

    using Type = quint32;

#endif

    static Type newId();

};

// The tracked resources of a pass, in the order the pass first used them.

// Neither QHash nor QVarLengthFlatMap is suitable on its own. Most passes track

// a handful of resources, which a QHash would allocate for. But a pass can also

// track thousands, such as the vertex and index buffers of thousands of draw

// calls, and a flat map keeps its keys sorted, so each insertion shifts half

// the entries, which is quadratic in the number of resources. So the entries are

// appended to a QVarLengthArray and searched linearly while there are few, and

// indexed by a QHash once there are more.

template <typename Key, typename T, qsizetype Prealloc>

class QRhiPassResourceMap

public:

    using value_type = std::pair<Key, T>;

    using iterator = value_type *;

    using const_iterator = const value_type *;

    iterator begin() { return m_entries.begin(); }

    iterator end() { return m_entries.end(); }

    const_iterator begin() const { return m_entries.cbegin(); }

    const_iterator end() const { return m_entries.cend(); }

    const_iterator cbegin() const { return m_entries.cbegin(); }

    const_iterator cend() const { return m_entries.cend(); }

    bool isEmpty() const { return m_entries.isEmpty(); }

    qsizetype size() const { return m_entries.size(); }

    void clear()

        m_entries.clear();

        m_index.clear();

    const_iterator find(Key key) const

        if (m_index.isEmpty()) {

            return std::find_if(m_entries.cbegin(), m_entries.cend(),

                                [key](const value_type &entry) { return entry.first == key; });

        const auto it = m_index.constFind(key);

        return it == m_index.cend() ? m_entries.cend() : m_entries.cbegin() + it.value();

    iterator find(Key key)

        const const_iterator it = std::as_const(*this).find(key);

        return m_entries.begin() + (it - m_entries.cbegin());

    bool contains(Key key) const { return find(key) != cend(); }

    // The key must not be in the map yet.

    void append(Key key, const T &value)

        m_entries.append({ key, value });

        if (!m_index.isEmpty()) {

            m_index.insert(key, m_entries.size() - 1);

        } else if (m_entries.size() > LinearSearchLimit) {

            m_index.reserve(m_entries.size() * 2);

            for (qsizetype i = 0; i < m_entries.size(); ++i)

                m_index.insert(m_entries[i].first, i);

private:

    static constexpr qsizetype LinearSearchLimit = 32;

    QVarLengthArray<value_type, Prealloc> m_entries;

    QHash<Key, qsizetype> m_index;

};

class QRhiPassResourceTracker

public:

    bool isEmpty() const;

    void reset();

    struct UsageState {

        int layout;

        int access;

        int stage;

};

    enum BufferStage {

        BufIndirectDrawStage,

        BufVertexInputStage,

        BufVertexStage,

        BufTCStage,

        BufTEStage,

        BufFragmentStage,

        BufComputeStage,

        BufGeometryStage

};

    enum BufferAccess {

        BufIndirectDraw,

        BufVertexInput,

        BufIndexRead,

        BufUniformRead,

        BufStorageLoad,

        BufStorageStore,

        BufStorageLoadStore

};

    void registerBuffer(QRhiBuffer *buf, int slot, BufferAccess *access, BufferStage *stage,

                        const UsageState &state);

    enum TextureStage {

        TexVertexStage,

        TexTCStage,

        TexTEStage,

        TexFragmentStage,

        TexColorOutputStage,

        TexDepthOutputStage,

        TexComputeStage,

        TexGeometryStage

};

    enum TextureAccess {

        TexSample,

        TexColorOutput,

        TexDepthOutput,

        TexDepthResolveOutput,

        TexStorageLoad,

        TexStorageStore,

        TexStorageLoadStore,

        TexShadingRate

};

    void registerTexture(QRhiTexture *tex, TextureAccess *access, TextureStage *stage,

                         const UsageState &state);

    struct Buffer {

        int slot;

        BufferAccess access;

        BufferStage stage;

        UsageState stateAtPassBegin;

};

    const QRhiPassResourceMap<QRhiBuffer *, Buffer, 12> &buffers() const { return m_buffers; }

    struct Texture {

        TextureAccess access;

        TextureStage stage;

        UsageState stateAtPassBegin;

};

    const QRhiPassResourceMap<QRhiTexture *, Texture, 12> &textures() const { return m_textures; }

    static BufferStage toPassTrackerBufferStage(QRhiShaderResourceBinding::StageFlags stages);

    static TextureStage toPassTrackerTextureStage(QRhiShaderResourceBinding::StageFlags stages);

private:

    QRhiPassResourceMap<QRhiBuffer *, Buffer, 12> m_buffers;

    QRhiPassResourceMap<QRhiTexture *, Texture, 12> m_textures;

};

Q_DECLARE_TYPEINFO(QRhiPassResourceTracker::Buffer, Q_RELOCATABLE_TYPE);

Q_DECLARE_TYPEINFO(QRhiPassResourceTracker::Texture, Q_RELOCATABLE_TYPE);

template<typename T, int GROW = 1024>

class QRhiBackendCommandList

public:

    QRhiBackendCommandList() = default;

    ~QRhiBackendCommandList() { delete[] v; }

    inline void reset() { p = 0; }

    inline bool isEmpty() const { return p == 0; }

    inline T &get() {

        if (p == a) {

            a += GROW;

            T *nv = new T[a];

            if (v) {

                memcpy(nv, v, p * sizeof(T));

                delete[] v;

            v = nv;

        return v[p++];

    inline void unget() { --p; }

    inline T *cbegin() const { return v; }

    inline T *cend() const { return v + p; }

    inline T *begin() { return v; }

    inline T *end() { return v + p; }

private:

    Q_DISABLE_COPY(QRhiBackendCommandList)

    T *v = nullptr;

    int a = 0;

    int p = 0;

};

struct QRhiRenderTargetAttachmentTracker

    struct ResId { quint64 id; uint generation; };

    using ResIdList = QVarLengthArray<ResId, 8 * 2 + 1>; // color, resolve, ds

    template<typename TexType, typename RenderBufferType>

    static void updateResIdList(const QRhiTextureRenderTargetDescription &desc, ResIdList *dst);

    template<typename TexType, typename RenderBufferType>

    static bool isUpToDate(const QRhiTextureRenderTargetDescription &desc, const ResIdList &currentResIdList);

};

inline bool operator==(const QRhiRenderTargetAttachmentTracker::ResId &a, const QRhiRenderTargetAttachmentTracker::ResId &b)

    return a.id == b.id && a.generation == b.generation;

inline bool operator!=(const QRhiRenderTargetAttachmentTracker::ResId &a, const QRhiRenderTargetAttachmentTracker::ResId &b)

    return !(a == b);

template<typename TexType, typename RenderBufferType>

void QRhiRenderTargetAttachmentTracker::updateResIdList(const QRhiTextureRenderTargetDescription &desc, ResIdList *dst)

    const bool hasDepthStencil = desc.depthStencilBuffer() || desc.depthTexture();

    dst->resize(desc.colorAttachmentCount() * 2 + (hasDepthStencil ? 1 : 0));

    int n = 0;

    for (auto it = desc.cbeginColorAttachments(), itEnd = desc.cendColorAttachments(); it != itEnd; ++it, ++n) {

        const QRhiColorAttachment &colorAtt(*it);

        if (colorAtt.texture()) {

            TexType *texD = QRHI_RES(TexType, colorAtt.texture());

            (*dst)[n] = { texD->globalResourceId(), texD->generation };

        } else if (colorAtt.renderBuffer()) {

            RenderBufferType *rbD = QRHI_RES(RenderBufferType, colorAtt.renderBuffer());

            (*dst)[n] = { rbD->globalResourceId(), rbD->generation };

        } else {

            (*dst)[n] = { 0, 0 };

        ++n;

        if (colorAtt.resolveTexture()) {

            TexType *texD = QRHI_RES(TexType, colorAtt.resolveTexture());

            (*dst)[n] = { texD->globalResourceId(), texD->generation };

        } else {

            (*dst)[n] = { 0, 0 };

    if (hasDepthStencil) {

        if (desc.depthTexture()) {

            TexType *depthTexD = QRHI_RES(TexType, desc.depthTexture());

            (*dst)[n] = { depthTexD->globalResourceId(), depthTexD->generation };

        } else if (desc.depthStencilBuffer()) {

            RenderBufferType *depthRbD = QRHI_RES(RenderBufferType, desc.depthStencilBuffer());

            (*dst)[n] = { depthRbD->globalResourceId(), depthRbD->generation };

        } else {

            (*dst)[n] = { 0, 0 };

template<typename TexType, typename RenderBufferType>

bool QRhiRenderTargetAttachmentTracker::isUpToDate(const QRhiTextureRenderTargetDescription &desc, const ResIdList &currentResIdList)

    // Just as setShaderResources() recognizes if an srb's referenced

    // resources have been rebuilt (got a create() since the srb's

    // create()), we should do the same for the textures and renderbuffers

    // referenced from the rendertarget. It is not uncommon that a texture

    // or ds buffer gets resized due to following a window size in some

    // form, which involves a create() on them. It is then nice if the

    // render target auto-rebuilds in beginPass().

    ResIdList resIdList;

    updateResIdList<TexType, RenderBufferType>(desc, &resIdList);

    return resIdList == currentResIdList;

template<typename T>

inline T *qrhi_objectFromProxyData(QRhiSwapChainProxyData *pd, QWindow *window, QRhi::Implementation impl, uint objectIndex)

    Q_ASSERT(objectIndex < std::size(pd->reserved));

    if (!pd->reserved[objectIndex]) // // was not set, no other choice, do it here, whatever thread this is

        *pd = QRhi::updateSwapChainProxyData(impl, window);

    return static_cast<T *>(pd->reserved[objectIndex]);

class QRhiPipelineCacheDataReader

public:

    QRhiPipelineCacheDataReader(const char *data, quint32 size)

        : m_p(data), m_end(data + size)

    bool readUInt32(quint32 *dst)

        if (m_end - m_p < qptrdiff(sizeof(quint32)))

            return false;

        memcpy(dst, m_p, sizeof(quint32));

        m_p += sizeof(quint32);

        return true;

    // Reads a 32-bit length, followed by that many bytes.

    bool readByteArray(QByteArray *dst)

        quint32 len = 0;

        if (!readUInt32(&len))

            return false;

        if (quint64(m_end - m_p) < len)

            return false;

        *dst = QByteArray(m_p, qsizetype(len));

        m_p += len;

        return true;

private:

    const char *m_p;

    const char *m_end;

};

QT_END_NAMESPACE

#endif