qrhi.cpp

Go to the documentation of this file.

// 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
 
#include "qrhi_p.h"
#include <qmath.h>
#include <QLoggingCategory>
 
#include "qrhinull_p.h"
#ifndef QT_NO_OPENGL
#include "qrhigles2_p.h"
#endif
#if QT_CONFIG(vulkan)
#include "qrhivulkan_p.h"
#endif
#ifdef Q_OS_WIN
#include "qrhid3d11_p.h"
#include "qrhid3d12_p.h"
#endif
#if QT_CONFIG(metal)
#include "qrhimetal_p.h"
#endif
 
#include <memory>
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(QRHI_LOG_INFO, "qt.rhi.general")
 
 
QRhiDepthStencilClearValue::QRhiDepthStencilClearValue(float d, quint32 s)
    : m_d(d),
      m_s(s)
{
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiDepthStencilClearValue &v)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiDepthStencilClearValue(depth-clear=" << v.depthClearValue()
                  << " stencil-clear=" << v.stencilClearValue()
                  << ')';
    return dbg;
}
#endif
 
QRhiViewport::QRhiViewport(float x, float y, float w, float h, float minDepth, float maxDepth)
    : m_rect { { x, y, w, h } },
      m_minDepth(minDepth),
      m_maxDepth(maxDepth)
{
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiViewport &v)
{
    QDebugStateSaver saver(dbg);
    const std::array<float, 4> r = v.viewport();
    dbg.nospace() << "QRhiViewport(bottom-left-x=" << r[0]
                  << " bottom-left-y=" << r[1]
                  << " width=" << r[2]
                  << " height=" << r[3]
                  << " minDepth=" << v.minDepth()
                  << " maxDepth=" << v.maxDepth()
                  << ')';
    return dbg;
}
#endif
 
QRhiScissor::QRhiScissor(int x, int y, int w, int h)
    : m_rect { { x, y, w, h } }
{
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiScissor &s)
{
    QDebugStateSaver saver(dbg);
    const std::array<int, 4> r = s.scissor();
    dbg.nospace() << "QRhiScissor(bottom-left-x=" << r[0]
                  << " bottom-left-y=" << r[1]
                  << " width=" << r[2]
                  << " height=" << r[3]
                  << ')';
    return dbg;
}
#endif
 
QRhiVertexInputBinding::QRhiVertexInputBinding(quint32 stride, Classification cls, quint32 stepRate)
    : m_stride(stride),
      m_classification(cls),
      m_instanceStepRate(stepRate)
{
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiVertexInputBinding &b)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiVertexInputBinding(stride=" << b.stride()
                  << " cls=" << b.classification()
                  << " step-rate=" << b.instanceStepRate()
                  << ')';
    return dbg;
}
#endif
 
QRhiVertexInputAttribute::QRhiVertexInputAttribute(int binding, int location, Format format, quint32 offset, int matrixSlice)
    : m_binding(binding),
      m_location(location),
      m_format(format),
      m_offset(offset),
      m_matrixSlice(matrixSlice)
{
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiVertexInputAttribute &a)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiVertexInputAttribute(binding=" << a.binding()
                  << " location=" << a.location()
                  << " format=" << a.format()
                  << " offset=" << a.offset()
                  << ')';
    return dbg;
}
#endif
 
QRhiVertexInputAttribute::Format QRhiImplementation::shaderDescVariableFormatToVertexInputFormat(QShaderDescription::VariableType type) const
{
    switch (type) {
    case QShaderDescription::Vec4:
        return QRhiVertexInputAttribute::Float4;
    case QShaderDescription::Vec3:
        return QRhiVertexInputAttribute::Float3;
    case QShaderDescription::Vec2:
        return QRhiVertexInputAttribute::Float2;
    case QShaderDescription::Float:
        return QRhiVertexInputAttribute::Float;
 
    case QShaderDescription::Int4:
        return QRhiVertexInputAttribute::SInt4;
    case QShaderDescription::Int3:
        return QRhiVertexInputAttribute::SInt3;
    case QShaderDescription::Int2:
        return QRhiVertexInputAttribute::SInt2;
    case QShaderDescription::Int:
        return QRhiVertexInputAttribute::SInt;
 
    case QShaderDescription::Uint4:
        return QRhiVertexInputAttribute::UInt4;
    case QShaderDescription::Uint3:
        return QRhiVertexInputAttribute::UInt3;
    case QShaderDescription::Uint2:
        return QRhiVertexInputAttribute::UInt2;
    case QShaderDescription::Uint:
        return QRhiVertexInputAttribute::UInt;
 
    case QShaderDescription::Half4:
        return QRhiVertexInputAttribute::Half4;
    case QShaderDescription::Half3:
        return QRhiVertexInputAttribute::Half3;
    case QShaderDescription::Half2:
        return QRhiVertexInputAttribute::Half2;
    case QShaderDescription::Half:
        return QRhiVertexInputAttribute::Half;
 
    default:
        Q_UNREACHABLE_RETURN(QRhiVertexInputAttribute::Float);
    }
}
 
quint32 QRhiImplementation::byteSizePerVertexForVertexInputFormat(QRhiVertexInputAttribute::Format format) const
{
    switch (format) {
    case QRhiVertexInputAttribute::Float4:
        return 4 * sizeof(float);
    case QRhiVertexInputAttribute::Float3:
        return 4 * sizeof(float); // vec3 still takes 16 bytes
    case QRhiVertexInputAttribute::Float2:
        return 2 * sizeof(float);
    case QRhiVertexInputAttribute::Float:
        return sizeof(float);
 
    case QRhiVertexInputAttribute::UNormByte4:
        return 4 * sizeof(quint8);
    case QRhiVertexInputAttribute::UNormByte2:
        return 2 * sizeof(quint8);
    case QRhiVertexInputAttribute::UNormByte:
        return sizeof(quint8);
 
    case QRhiVertexInputAttribute::UInt4:
        return 4 * sizeof(quint32);
    case QRhiVertexInputAttribute::UInt3:
        return 4 * sizeof(quint32); // ivec3 still takes 16 bytes
    case QRhiVertexInputAttribute::UInt2:
        return 2 * sizeof(quint32);
    case QRhiVertexInputAttribute::UInt:
        return sizeof(quint32);
 
    case QRhiVertexInputAttribute::SInt4:
        return 4 * sizeof(qint32);
    case QRhiVertexInputAttribute::SInt3:
        return 4 * sizeof(qint32); // uvec3 still takes 16 bytes
    case QRhiVertexInputAttribute::SInt2:
        return 2 * sizeof(qint32);
    case QRhiVertexInputAttribute::SInt:
        return sizeof(qint32);
 
    case QRhiVertexInputAttribute::Half4:
        return 4 * sizeof(qfloat16);
    case QRhiVertexInputAttribute::Half3:
        return 4 * sizeof(qfloat16); // half3 still takes 8 bytes
    case QRhiVertexInputAttribute::Half2:
        return 2 * sizeof(qfloat16);
    case QRhiVertexInputAttribute::Half:
        return sizeof(qfloat16);
 
    case QRhiVertexInputAttribute::UShort4:
        return 4 * sizeof(quint16);
    case QRhiVertexInputAttribute::UShort3:
        return 4 * sizeof(quint16); // ivec3 still takes 8 bytes
    case QRhiVertexInputAttribute::UShort2:
        return 2 * sizeof(quint16);
    case QRhiVertexInputAttribute::UShort:
        return sizeof(quint16);
 
    case QRhiVertexInputAttribute::SShort4:
        return 4 * sizeof(qint16);
    case QRhiVertexInputAttribute::SShort3:
        return 4 * sizeof(qint16); // uvec3 still takes 8 bytes
    case QRhiVertexInputAttribute::SShort2:
        return 2 * sizeof(qint16);
    case QRhiVertexInputAttribute::SShort:
        return sizeof(qint16);
 
    default:
        Q_UNREACHABLE_RETURN(1);
    }
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiVertexInputLayout &v)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiVertexInputLayout(bindings=" << v.m_bindings
                  << " attributes=" << v.m_attributes
                  << ')';
    return dbg;
}
#endif
 
QRhiShaderStage::QRhiShaderStage(Type type, const QShader &shader, QShader::Variant v)
    : m_type(type),
      m_shader(shader),
      m_shaderVariant(v)
{
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiShaderStage &s)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiShaderStage(type=" << s.type()
                  << " shader=" << s.shader()
                  << " variant=" << s.shaderVariant()
                  << ')';
    return dbg;
}
#endif
 
QRhiColorAttachment::QRhiColorAttachment(QRhiTexture *texture)
    : m_texture(texture)
{
}
 
QRhiColorAttachment::QRhiColorAttachment(QRhiRenderBuffer *renderBuffer)
    : m_renderBuffer(renderBuffer)
{
}
 
QRhiTextureRenderTargetDescription::QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment)
{
    m_colorAttachments.append(colorAttachment);
}
 
QRhiTextureRenderTargetDescription::QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment,
                                                                       QRhiRenderBuffer *depthStencilBuffer)
    : m_depthStencilBuffer(depthStencilBuffer)
{
    m_colorAttachments.append(colorAttachment);
}
 
QRhiTextureRenderTargetDescription::QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment,
                                                                       QRhiTexture *depthTexture)
    : m_depthTexture(depthTexture)
{
    m_colorAttachments.append(colorAttachment);
}
 
QRhiTextureSubresourceUploadDescription::QRhiTextureSubresourceUploadDescription(const QImage &image)
    : m_image(image)
{
}
 
QRhiTextureSubresourceUploadDescription::QRhiTextureSubresourceUploadDescription(const void *data, quint32 size)
    : m_data(reinterpret_cast<const char *>(data), size)
{
}
 
QRhiTextureSubresourceUploadDescription::QRhiTextureSubresourceUploadDescription(const QByteArray &data)
    : m_data(data)
{
}
 
QRhiTextureUploadEntry::QRhiTextureUploadEntry(int layer, int level,
                                               const QRhiTextureSubresourceUploadDescription &desc)
    : m_layer(layer),
      m_level(level),
      m_desc(desc)
{
}
 
QRhiTextureUploadDescription::QRhiTextureUploadDescription(const QRhiTextureUploadEntry &entry)
{
    m_entries.append(entry);
}
 
QRhiTextureUploadDescription::QRhiTextureUploadDescription(std::initializer_list<QRhiTextureUploadEntry> list)
    : m_entries(list)
{
}
 
QRhiReadbackDescription::QRhiReadbackDescription(QRhiTexture *texture)
    : m_texture(texture)
{
}
 
QRhiResource::QRhiResource(QRhiImplementation *rhi)
    : m_rhi(rhi)
{
    m_id = QRhiGlobalObjectIdGenerator::newId();
}
 
QRhiResource::~QRhiResource()
{
    // destroy() cannot be called here, due to virtuals; it is up to the
    // subclasses to do that.
}
 
void QRhiResource::deleteLater()
{
    if (m_rhi)
        m_rhi->addDeleteLater(this);
    else
        delete this;
}
 
QByteArray QRhiResource::name() const
{
    return m_objectName;
}
 
void QRhiResource::setName(const QByteArray &name)
{
    m_objectName = name;
}
 
quint64 QRhiResource::globalResourceId() const
{
    return m_id;
}
 
QRhi *QRhiResource::rhi() const
{
    return m_rhi ? m_rhi->q : nullptr;
}
 
QRhiBuffer::QRhiBuffer(QRhiImplementation *rhi, Type type_, UsageFlags usage_, quint32 size_)
    : QRhiResource(rhi),
      m_type(type_), m_usage(usage_), m_size(size_)
{
}
 
QRhiResource::Type QRhiBuffer::resourceType() const
{
    return Buffer;
}
 
QRhiBuffer::NativeBuffer QRhiBuffer::nativeBuffer()
{
    return {};
}
 
char *QRhiBuffer::beginFullDynamicBufferUpdateForCurrentFrame()
{
    return nullptr;
}
 
void QRhiBuffer::endFullDynamicBufferUpdateForCurrentFrame()
{
}
 
QRhiRenderBuffer::QRhiRenderBuffer(QRhiImplementation *rhi, Type type_, const QSize &pixelSize_,
                                   int sampleCount_, Flags flags_,
                                   QRhiTexture::Format backingFormatHint_)
    : QRhiResource(rhi),
      m_type(type_), m_pixelSize(pixelSize_), m_sampleCount(sampleCount_), m_flags(flags_),
      m_backingFormatHint(backingFormatHint_)
{
}
 
QRhiResource::Type QRhiRenderBuffer::resourceType() const
{
    return RenderBuffer;
}
 
bool QRhiRenderBuffer::createFrom(NativeRenderBuffer src)
{
    Q_UNUSED(src);
    return false;
}
 
QRhiTexture::QRhiTexture(QRhiImplementation *rhi, Format format_, const QSize &pixelSize_, int depth_,
                         int arraySize_, int sampleCount_, Flags flags_)
    : QRhiResource(rhi),
      m_format(format_), m_pixelSize(pixelSize_), m_depth(depth_),
      m_arraySize(arraySize_), m_sampleCount(sampleCount_), m_flags(flags_)
{
}
 
QRhiResource::Type QRhiTexture::resourceType() const
{
    return Texture;
}
 
QRhiTexture::NativeTexture QRhiTexture::nativeTexture()
{
    return {};
}
 
bool QRhiTexture::createFrom(QRhiTexture::NativeTexture src)
{
    Q_UNUSED(src);
    return false;
}
 
void QRhiTexture::setNativeLayout(int layout)
{
    Q_UNUSED(layout);
}
 
QRhiSampler::QRhiSampler(QRhiImplementation *rhi,
                         Filter magFilter_, Filter minFilter_, Filter mipmapMode_,
                         AddressMode u_, AddressMode v_, AddressMode w_)
    : QRhiResource(rhi),
      m_magFilter(magFilter_), m_minFilter(minFilter_), m_mipmapMode(mipmapMode_),
      m_addressU(u_), m_addressV(v_), m_addressW(w_),
      m_compareOp(QRhiSampler::Never)
{
}
 
QRhiResource::Type QRhiSampler::resourceType() const
{
    return Sampler;
}
 
QRhiRenderPassDescriptor::QRhiRenderPassDescriptor(QRhiImplementation *rhi)
    : QRhiResource(rhi)
{
}
 
QRhiResource::Type QRhiRenderPassDescriptor::resourceType() const
{
    return RenderPassDescriptor;
}
 
const QRhiNativeHandles *QRhiRenderPassDescriptor::nativeHandles()
{
    return nullptr;
}
 
QRhiRenderTarget::QRhiRenderTarget(QRhiImplementation *rhi)
    : QRhiResource(rhi)
{
}
 
QRhiSwapChainRenderTarget::QRhiSwapChainRenderTarget(QRhiImplementation *rhi, QRhiSwapChain *swapchain_)
    : QRhiRenderTarget(rhi),
      m_swapchain(swapchain_)
{
}
 
QRhiResource::Type QRhiSwapChainRenderTarget::resourceType() const
{
    return SwapChainRenderTarget;
}
 
QRhiTextureRenderTarget::QRhiTextureRenderTarget(QRhiImplementation *rhi,
                                                 const QRhiTextureRenderTargetDescription &desc_,
                                                 Flags flags_)
    : QRhiRenderTarget(rhi),
      m_desc(desc_),
      m_flags(flags_)
{
}
 
QRhiResource::Type QRhiTextureRenderTarget::resourceType() const
{
    return TextureRenderTarget;
}
 
QRhiShaderResourceBindings::QRhiShaderResourceBindings(QRhiImplementation *rhi)
    : QRhiResource(rhi)
{
    m_layoutDesc.reserve(BINDING_PREALLOC * QRhiShaderResourceBinding::LAYOUT_DESC_ENTRIES_PER_BINDING);
}
 
QRhiResource::Type QRhiShaderResourceBindings::resourceType() const
{
    return ShaderResourceBindings;
}
 
bool QRhiShaderResourceBindings::isLayoutCompatible(const QRhiShaderResourceBindings *other) const
{
    if (other == this)
        return true;
 
    if (!other)
        return false;
 
    // This can become a hot code path. Therefore we do not iterate and call
    // isLayoutCompatible() on m_bindings, but rather check a pre-calculated
    // hash code and then, if the hash matched, do a uint array comparison
    // (that's still more cache friendly).
 
    return m_layoutDescHash == other->m_layoutDescHash
            && m_layoutDesc == other->m_layoutDesc;
}
 
void QRhiImplementation::updateLayoutDesc(QRhiShaderResourceBindings *srb)
{
    srb->m_layoutDescHash = 0;
    srb->m_layoutDesc.clear();
    auto layoutDescAppender = std::back_inserter(srb->m_layoutDesc);
    for (const QRhiShaderResourceBinding &b : std::as_const(srb->m_bindings)) {
        const QRhiShaderResourceBinding::Data *d = &b.d;
        srb->m_layoutDescHash ^= uint(d->binding) ^ uint(d->stage) ^ uint(d->type)
            ^ uint(d->arraySize());
        layoutDescAppender = d->serialize(layoutDescAppender);
    }
}
 
bool QRhiShaderResourceBinding::isLayoutCompatible(const QRhiShaderResourceBinding &other) const
{
    // everything that goes into a VkDescriptorSetLayoutBinding must match
    return d.binding == other.d.binding
            && d.stage == other.d.stage
            && d.type == other.d.type
            && d.arraySize() == other.d.arraySize();
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::uniformBuffer(
        int binding, StageFlags stage, QRhiBuffer *buf)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = UniformBuffer;
    b.d.u.ubuf.buf = buf;
    b.d.u.ubuf.offset = 0;
    b.d.u.ubuf.maybeSize = 0; // entire buffer
    b.d.u.ubuf.hasDynamicOffset = false;
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::uniformBuffer(
        int binding, StageFlags stage, QRhiBuffer *buf, quint32 offset, quint32 size)
{
    Q_ASSERT(size > 0);
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = UniformBuffer;
    b.d.u.ubuf.buf = buf;
    b.d.u.ubuf.offset = offset;
    b.d.u.ubuf.maybeSize = size;
    b.d.u.ubuf.hasDynamicOffset = false;
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::uniformBufferWithDynamicOffset(
        int binding, StageFlags stage, QRhiBuffer *buf, quint32 size)
{
    Q_ASSERT(size > 0);
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = UniformBuffer;
    b.d.u.ubuf.buf = buf;
    b.d.u.ubuf.offset = 0;
    b.d.u.ubuf.maybeSize = size;
    b.d.u.ubuf.hasDynamicOffset = true;
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::sampledTexture(
        int binding, StageFlags stage, QRhiTexture *tex, QRhiSampler *sampler)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = SampledTexture;
    b.d.u.stex.count = 1;
    b.d.u.stex.texSamplers[0] = { tex, sampler };
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::sampledTextures(
        int binding, StageFlags stage, int count, const TextureAndSampler *texSamplers)
{
    Q_ASSERT(count >= 1 && count <= Data::MAX_TEX_SAMPLER_ARRAY_SIZE);
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = SampledTexture;
    b.d.u.stex.count = count;
    for (int i = 0; i < count; ++i) {
        if (texSamplers)
            b.d.u.stex.texSamplers[i] = texSamplers[i];
        else
            b.d.u.stex.texSamplers[i] = { nullptr, nullptr };
    }
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::texture(int binding, StageFlags stage, QRhiTexture *tex)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = Texture;
    b.d.u.stex.count = 1;
    b.d.u.stex.texSamplers[0] = { tex, nullptr };
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::textures(int binding, StageFlags stage, int count, QRhiTexture **tex)
{
    Q_ASSERT(count >= 1 && count <= Data::MAX_TEX_SAMPLER_ARRAY_SIZE);
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = Texture;
    b.d.u.stex.count = count;
    for (int i = 0; i < count; ++i) {
        if (tex)
            b.d.u.stex.texSamplers[i] = { tex[i], nullptr };
        else
            b.d.u.stex.texSamplers[i] = { nullptr, nullptr };
    }
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::sampler(int binding, StageFlags stage, QRhiSampler *sampler)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = Sampler;
    b.d.u.stex.count = 1;
    b.d.u.stex.texSamplers[0] = { nullptr, sampler };
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::imageLoad(
        int binding, StageFlags stage, QRhiTexture *tex, int level)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = ImageLoad;
    b.d.u.simage.tex = tex;
    b.d.u.simage.level = level;
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::imageStore(
        int binding, StageFlags stage, QRhiTexture *tex, int level)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = ImageStore;
    b.d.u.simage.tex = tex;
    b.d.u.simage.level = level;
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::imageLoadStore(
        int binding, StageFlags stage, QRhiTexture *tex, int level)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = ImageLoadStore;
    b.d.u.simage.tex = tex;
    b.d.u.simage.level = level;
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::bufferLoad(
        int binding, StageFlags stage, QRhiBuffer *buf)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = BufferLoad;
    b.d.u.sbuf.buf = buf;
    b.d.u.sbuf.offset = 0;
    b.d.u.sbuf.maybeSize = 0; // entire buffer
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::bufferLoad(
        int binding, StageFlags stage, QRhiBuffer *buf, quint32 offset, quint32 size)
{
    Q_ASSERT(size > 0);
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = BufferLoad;
    b.d.u.sbuf.buf = buf;
    b.d.u.sbuf.offset = offset;
    b.d.u.sbuf.maybeSize = size;
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::bufferStore(
        int binding, StageFlags stage, QRhiBuffer *buf)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = BufferStore;
    b.d.u.sbuf.buf = buf;
    b.d.u.sbuf.offset = 0;
    b.d.u.sbuf.maybeSize = 0; // entire buffer
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::bufferStore(
        int binding, StageFlags stage, QRhiBuffer *buf, quint32 offset, quint32 size)
{
    Q_ASSERT(size > 0);
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = BufferStore;
    b.d.u.sbuf.buf = buf;
    b.d.u.sbuf.offset = offset;
    b.d.u.sbuf.maybeSize = size;
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::bufferLoadStore(
        int binding, StageFlags stage, QRhiBuffer *buf)
{
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = BufferLoadStore;
    b.d.u.sbuf.buf = buf;
    b.d.u.sbuf.offset = 0;
    b.d.u.sbuf.maybeSize = 0; // entire buffer
    return b;
}
 
QRhiShaderResourceBinding QRhiShaderResourceBinding::bufferLoadStore(
        int binding, StageFlags stage, QRhiBuffer *buf, quint32 offset, quint32 size)
{
    Q_ASSERT(size > 0);
    QRhiShaderResourceBinding b;
    b.d.binding = binding;
    b.d.stage = stage;
    b.d.type = BufferLoadStore;
    b.d.u.sbuf.buf = buf;
    b.d.u.sbuf.offset = offset;
    b.d.u.sbuf.maybeSize = size;
    return b;
}
 
bool operator==(const QRhiShaderResourceBinding &a, const QRhiShaderResourceBinding &b) noexcept
{
    const QRhiShaderResourceBinding::Data *da = QRhiImplementation::shaderResourceBindingData(a);
    const QRhiShaderResourceBinding::Data *db = QRhiImplementation::shaderResourceBindingData(b);
 
    if (da == db)
        return true;
 
 
    if (da->binding != db->binding
            || da->stage != db->stage
            || da->type != db->type)
    {
        return false;
    }
 
    switch (da->type) {
    case QRhiShaderResourceBinding::UniformBuffer:
        if (da->u.ubuf.buf != db->u.ubuf.buf
                || da->u.ubuf.offset != db->u.ubuf.offset
                || da->u.ubuf.maybeSize != db->u.ubuf.maybeSize)
        {
            return false;
        }
        break;
    case QRhiShaderResourceBinding::SampledTexture:
        if (da->u.stex.count != db->u.stex.count)
            return false;
        for (int i = 0; i < da->u.stex.count; ++i) {
            if (da->u.stex.texSamplers[i].tex != db->u.stex.texSamplers[i].tex
                    || da->u.stex.texSamplers[i].sampler != db->u.stex.texSamplers[i].sampler)
            {
                return false;
            }
        }
        break;
    case QRhiShaderResourceBinding::Texture:
        if (da->u.stex.count != db->u.stex.count)
            return false;
        for (int i = 0; i < da->u.stex.count; ++i) {
            if (da->u.stex.texSamplers[i].tex != db->u.stex.texSamplers[i].tex)
                return false;
        }
        break;
    case QRhiShaderResourceBinding::Sampler:
        if (da->u.stex.texSamplers[0].sampler != db->u.stex.texSamplers[0].sampler)
            return false;
        break;
    case QRhiShaderResourceBinding::ImageLoad:
    case QRhiShaderResourceBinding::ImageStore:
    case QRhiShaderResourceBinding::ImageLoadStore:
        if (da->u.simage.tex != db->u.simage.tex
                || da->u.simage.level != db->u.simage.level)
        {
            return false;
        }
        break;
    case QRhiShaderResourceBinding::BufferLoad:
    case QRhiShaderResourceBinding::BufferStore:
    case QRhiShaderResourceBinding::BufferLoadStore:
        if (da->u.sbuf.buf != db->u.sbuf.buf
                || da->u.sbuf.offset != db->u.sbuf.offset
                || da->u.sbuf.maybeSize != db->u.sbuf.maybeSize)
        {
            return false;
        }
        break;
    default:
        Q_UNREACHABLE_RETURN(false);
    }
 
    return true;
}
 
bool operator!=(const QRhiShaderResourceBinding &a, const QRhiShaderResourceBinding &b) noexcept
{
    return !(a == b);
}
 
size_t qHash(const QRhiShaderResourceBinding &b, size_t seed) noexcept
{
    const QRhiShaderResourceBinding::Data *d = QRhiImplementation::shaderResourceBindingData(b);
    QtPrivate::QHashCombine hash;
    seed = hash(seed, d->binding);
    seed = hash(seed, d->stage);
    seed = hash(seed, d->type);
    switch (d->type) {
    case QRhiShaderResourceBinding::UniformBuffer:
        seed = hash(seed, reinterpret_cast<quintptr>(d->u.ubuf.buf));
        break;
    case QRhiShaderResourceBinding::SampledTexture:
        seed = hash(seed, reinterpret_cast<quintptr>(d->u.stex.texSamplers[0].tex));
        seed = hash(seed, reinterpret_cast<quintptr>(d->u.stex.texSamplers[0].sampler));
        break;
    case QRhiShaderResourceBinding::Texture:
        seed = hash(seed, reinterpret_cast<quintptr>(d->u.stex.texSamplers[0].tex));
        break;
    case QRhiShaderResourceBinding::Sampler:
        seed = hash(seed, reinterpret_cast<quintptr>(d->u.stex.texSamplers[0].sampler));
        break;
    case QRhiShaderResourceBinding::ImageLoad:
    case QRhiShaderResourceBinding::ImageStore:
    case QRhiShaderResourceBinding::ImageLoadStore:
        seed = hash(seed, reinterpret_cast<quintptr>(d->u.simage.tex));
        break;
    case QRhiShaderResourceBinding::BufferLoad:
    case QRhiShaderResourceBinding::BufferStore:
    case QRhiShaderResourceBinding::BufferLoadStore:
        seed = hash(seed, reinterpret_cast<quintptr>(d->u.sbuf.buf));
        break;
    }
    return seed;
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiShaderResourceBinding &b)
{
    QDebugStateSaver saver(dbg);
    const QRhiShaderResourceBinding::Data *d = QRhiImplementation::shaderResourceBindingData(b);
    dbg.nospace() << "QRhiShaderResourceBinding("
                  << "binding=" << d->binding
                  << " stage=" << d->stage
                  << " type=" << d->type;
    switch (d->type) {
    case QRhiShaderResourceBinding::UniformBuffer:
        dbg.nospace() << " UniformBuffer("
                      << "buffer=" << d->u.ubuf.buf
                      << " offset=" << d->u.ubuf.offset
                      << " maybeSize=" << d->u.ubuf.maybeSize
                      << ')';
        break;
    case QRhiShaderResourceBinding::SampledTexture:
        dbg.nospace() << " SampledTextures("
                      << "count=" << d->u.stex.count;
        for (int i = 0; i < d->u.stex.count; ++i) {
            dbg.nospace() << " texture=" << d->u.stex.texSamplers[i].tex
                          << " sampler=" << d->u.stex.texSamplers[i].sampler;
        }
        dbg.nospace() << ')';
        break;
    case QRhiShaderResourceBinding::Texture:
        dbg.nospace() << " Textures("
                      << "count=" << d->u.stex.count;
        for (int i = 0; i < d->u.stex.count; ++i)
            dbg.nospace() << " texture=" << d->u.stex.texSamplers[i].tex;
        dbg.nospace() << ')';
        break;
    case QRhiShaderResourceBinding::Sampler:
        dbg.nospace() << " Sampler("
                      << " sampler=" << d->u.stex.texSamplers[0].sampler
                      << ')';
        break;
    case QRhiShaderResourceBinding::ImageLoad:
        dbg.nospace() << " ImageLoad("
                      << "texture=" << d->u.simage.tex
                      << " level=" << d->u.simage.level
                      << ')';
        break;
    case QRhiShaderResourceBinding::ImageStore:
        dbg.nospace() << " ImageStore("
                      << "texture=" << d->u.simage.tex
                      << " level=" << d->u.simage.level
                      << ')';
        break;
    case QRhiShaderResourceBinding::ImageLoadStore:
        dbg.nospace() << " ImageLoadStore("
                      << "texture=" << d->u.simage.tex
                      << " level=" << d->u.simage.level
                      << ')';
        break;
    case QRhiShaderResourceBinding::BufferLoad:
        dbg.nospace() << " BufferLoad("
                      << "buffer=" << d->u.sbuf.buf
                      << " offset=" << d->u.sbuf.offset
                      << " maybeSize=" << d->u.sbuf.maybeSize
                      << ')';
        break;
    case QRhiShaderResourceBinding::BufferStore:
        dbg.nospace() << " BufferStore("
                      << "buffer=" << d->u.sbuf.buf
                      << " offset=" << d->u.sbuf.offset
                      << " maybeSize=" << d->u.sbuf.maybeSize
                      << ')';
        break;
    case QRhiShaderResourceBinding::BufferLoadStore:
        dbg.nospace() << " BufferLoadStore("
                      << "buffer=" << d->u.sbuf.buf
                      << " offset=" << d->u.sbuf.offset
                      << " maybeSize=" << d->u.sbuf.maybeSize
                      << ')';
        break;
    default:
        dbg.nospace() << " UNKNOWN()";
        break;
    }
    dbg.nospace() << ')';
    return dbg;
}
#endif
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiShaderResourceBindings &srb)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiShaderResourceBindings("
                  << srb.m_bindings
                  << ')';
    return dbg;
}
#endif
 
QRhiGraphicsPipeline::QRhiGraphicsPipeline(QRhiImplementation *rhi)
    : QRhiResource(rhi)
{
}
 
QRhiResource::Type QRhiGraphicsPipeline::resourceType() const
{
    return GraphicsPipeline;
}
 
QRhiSwapChain::QRhiSwapChain(QRhiImplementation *rhi)
    : QRhiResource(rhi)
{
}
 
QRhiResource::Type QRhiSwapChain::resourceType() const
{
    return SwapChain;
}
 
QRhiRenderTarget *QRhiSwapChain::currentFrameRenderTarget(StereoTargetBuffer targetBuffer)
{
    Q_UNUSED(targetBuffer);
    return currentFrameRenderTarget();
}
 
QRhiSwapChainHdrInfo QRhiSwapChain::hdrInfo()
{
    QRhiSwapChainHdrInfo info;
    info.limitsType = QRhiSwapChainHdrInfo::LuminanceInNits;
    info.limits.luminanceInNits.minLuminance = 0.0f;
    info.limits.luminanceInNits.maxLuminance = 1000.0f;
    info.luminanceBehavior = QRhiSwapChainHdrInfo::SceneReferred;
    info.sdrWhiteLevel = 200.0f;
    return info;
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiSwapChainHdrInfo &info)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiSwapChainHdrInfo(";
    switch (info.limitsType) {
    case QRhiSwapChainHdrInfo::LuminanceInNits:
        dbg.nospace() << " minLuminance=" << info.limits.luminanceInNits.minLuminance
                      << " maxLuminance=" << info.limits.luminanceInNits.maxLuminance;
        break;
    case QRhiSwapChainHdrInfo::ColorComponentValue:
        dbg.nospace() << " maxColorComponentValue=" << info.limits.colorComponentValue.maxColorComponentValue;
        dbg.nospace() << " maxPotentialColorComponentValue=" << info.limits.colorComponentValue.maxPotentialColorComponentValue;
        break;
    }
    switch (info.luminanceBehavior) {
    case QRhiSwapChainHdrInfo::SceneReferred:
        dbg.nospace() << " scene-referred, SDR white level=" << info.sdrWhiteLevel;
        break;
    case QRhiSwapChainHdrInfo::DisplayReferred:
        dbg.nospace() << " display-referred";
        break;
    }
    dbg.nospace() << ')';
    return dbg;
}
#endif
 
QRhiResource::Type QRhiComputePipeline::resourceType() const
{
    return ComputePipeline;
}
 
QRhiComputePipeline::QRhiComputePipeline(QRhiImplementation *rhi)
    : QRhiResource(rhi)
{
}
 
QRhiCommandBuffer::QRhiCommandBuffer(QRhiImplementation *rhi)
    : QRhiResource(rhi)
{
}
 
QRhiResource::Type QRhiCommandBuffer::resourceType() const
{
    return CommandBuffer;
}
 
static const char *resourceTypeStr(const QRhiResource *res)
{
    switch (res->resourceType()) {
    case QRhiResource::Buffer:
        return "Buffer";
    case QRhiResource::Texture:
        return "Texture";
    case QRhiResource::Sampler:
        return "Sampler";
    case QRhiResource::RenderBuffer:
        return "RenderBuffer";
    case QRhiResource::RenderPassDescriptor:
        return "RenderPassDescriptor";
    case QRhiResource::SwapChainRenderTarget:
        return "SwapChainRenderTarget";
    case QRhiResource::TextureRenderTarget:
        return "TextureRenderTarget";
    case QRhiResource::ShaderResourceBindings:
        return "ShaderResourceBindings";
    case QRhiResource::GraphicsPipeline:
        return "GraphicsPipeline";
    case QRhiResource::SwapChain:
        return "SwapChain";
    case QRhiResource::ComputePipeline:
        return "ComputePipeline";
    case QRhiResource::CommandBuffer:
        return "CommandBuffer";
    }
 
    Q_UNREACHABLE_RETURN("");
}
 
QRhiImplementation::~QRhiImplementation()
{
    qDeleteAll(resUpdPool);
 
    // Be nice and show something about leaked stuff. Though we may not get
    // this far with some backends where the allocator or the api may check
    // and freak out for unfreed graphics objects in the derived dtor already.
#ifndef QT_NO_DEBUG
    // debug builds: just do it always
    static bool leakCheck = true;
#else
    // release builds: opt-in
    static bool leakCheck = qEnvironmentVariableIntValue("QT_RHI_LEAK_CHECK");
#endif
    if (!resources.isEmpty()) {
        if (leakCheck) {
            qWarning("QRhi %p going down with %d unreleased resources that own native graphics objects. This is not nice.",
                     q, int(resources.size()));
        }
        for (auto it = resources.cbegin(), end = resources.cend(); it != end; ++it) {
            QRhiResource *res = it.key();
            const bool ownsNativeResources = it.value();
            if (leakCheck && ownsNativeResources)
                qWarning("  %s resource %p (%s)", resourceTypeStr(res), res, res->m_objectName.constData());
 
            // Null out the resource's rhi pointer. This is why it makes sense to do null
            // checks in the destroy() implementations of the various resource types. It
            // allows to survive in bad applications that somehow manage to destroy a
            // resource of a QRhi after the QRhi itself.
            res->m_rhi = nullptr;
        }
    }
}
 
bool QRhiImplementation::isCompressedFormat(QRhiTexture::Format format) const
{
    return (format >= QRhiTexture::BC1 && format <= QRhiTexture::BC7)
            || (format >= QRhiTexture::ETC2_RGB8 && format <= QRhiTexture::ETC2_RGBA8)
            || (format >= QRhiTexture::ASTC_4x4 && format <= QRhiTexture::ASTC_12x12);
}
 
void QRhiImplementation::compressedFormatInfo(QRhiTexture::Format format, const QSize &size,
                                              quint32 *bpl, quint32 *byteSize,
                                              QSize *blockDim) const
{
    int xdim = 4;
    int ydim = 4;
    quint32 blockSize = 0;
 
    switch (format) {
    case QRhiTexture::BC1:
        blockSize = 8;
        break;
    case QRhiTexture::BC2:
        blockSize = 16;
        break;
    case QRhiTexture::BC3:
        blockSize = 16;
        break;
    case QRhiTexture::BC4:
        blockSize = 8;
        break;
    case QRhiTexture::BC5:
        blockSize = 16;
        break;
    case QRhiTexture::BC6H:
        blockSize = 16;
        break;
    case QRhiTexture::BC7:
        blockSize = 16;
        break;
 
    case QRhiTexture::ETC2_RGB8:
        blockSize = 8;
        break;
    case QRhiTexture::ETC2_RGB8A1:
        blockSize = 8;
        break;
    case QRhiTexture::ETC2_RGBA8:
        blockSize = 16;
        break;
 
    case QRhiTexture::ASTC_4x4:
        blockSize = 16;
        break;
    case QRhiTexture::ASTC_5x4:
        blockSize = 16;
        xdim = 5;
        break;
    case QRhiTexture::ASTC_5x5:
        blockSize = 16;
        xdim = ydim = 5;
        break;
    case QRhiTexture::ASTC_6x5:
        blockSize = 16;
        xdim = 6;
        ydim = 5;
        break;
    case QRhiTexture::ASTC_6x6:
        blockSize = 16;
        xdim = ydim = 6;
        break;
    case QRhiTexture::ASTC_8x5:
        blockSize = 16;
        xdim = 8;
        ydim = 5;
        break;
    case QRhiTexture::ASTC_8x6:
        blockSize = 16;
        xdim = 8;
        ydim = 6;
        break;
    case QRhiTexture::ASTC_8x8:
        blockSize = 16;
        xdim = ydim = 8;
        break;
    case QRhiTexture::ASTC_10x5:
        blockSize = 16;
        xdim = 10;
        ydim = 5;
        break;
    case QRhiTexture::ASTC_10x6:
        blockSize = 16;
        xdim = 10;
        ydim = 6;
        break;
    case QRhiTexture::ASTC_10x8:
        blockSize = 16;
        xdim = 10;
        ydim = 8;
        break;
    case QRhiTexture::ASTC_10x10:
        blockSize = 16;
        xdim = ydim = 10;
        break;
    case QRhiTexture::ASTC_12x10:
        blockSize = 16;
        xdim = 12;
        ydim = 10;
        break;
    case QRhiTexture::ASTC_12x12:
        blockSize = 16;
        xdim = ydim = 12;
        break;
 
    default:
        Q_UNREACHABLE();
        break;
    }
 
    const quint32 wblocks = uint((size.width() + xdim - 1) / xdim);
    const quint32 hblocks = uint((size.height() + ydim - 1) / ydim);
 
    if (bpl)
        *bpl = wblocks * blockSize;
    if (byteSize)
        *byteSize = wblocks * hblocks * blockSize;
    if (blockDim)
        *blockDim = QSize(xdim, ydim);
}
 
void QRhiImplementation::textureFormatInfo(QRhiTexture::Format format, const QSize &size,
                                           quint32 *bpl, quint32 *byteSize, quint32 *bytesPerPixel) const
{
    if (isCompressedFormat(format)) {
        compressedFormatInfo(format, size, bpl, byteSize, nullptr);
        return;
    }
 
    quint32 bpc = 0;
    switch (format) {
    case QRhiTexture::RGBA8:
        bpc = 4;
        break;
    case QRhiTexture::BGRA8:
        bpc = 4;
        break;
    case QRhiTexture::R8:
        bpc = 1;
        break;
    case QRhiTexture::RG8:
        bpc = 2;
        break;
    case QRhiTexture::R16:
        bpc = 2;
        break;
    case QRhiTexture::RG16:
        bpc = 4;
        break;
    case QRhiTexture::RED_OR_ALPHA8:
        bpc = 1;
        break;
 
    case QRhiTexture::RGBA16F:
        bpc = 8;
        break;
    case QRhiTexture::RGBA32F:
        bpc = 16;
        break;
    case QRhiTexture::R16F:
        bpc = 2;
        break;
    case QRhiTexture::R32F:
        bpc = 4;
        break;
 
    case QRhiTexture::RGB10A2:
        bpc = 4;
        break;
 
    case QRhiTexture::D16:
        bpc = 2;
        break;
    case QRhiTexture::D24:
    case QRhiTexture::D24S8:
    case QRhiTexture::D32F:
        bpc = 4;
        break;
 
    default:
        Q_UNREACHABLE();
        break;
    }
 
    if (bpl)
        *bpl = uint(size.width()) * bpc;
    if (byteSize)
        *byteSize = uint(size.width() * size.height()) * bpc;
    if (bytesPerPixel)
        *bytesPerPixel = bpc;
}
 
bool QRhiImplementation::isStencilSupportingFormat(QRhiTexture::Format format) const
{
    switch (format) {
    case QRhiTexture::D24S8:
        return true;
    default:
        break;
    }
    return false;
}
 
bool QRhiImplementation::sanityCheckGraphicsPipeline(QRhiGraphicsPipeline *ps)
{
    if (ps->cbeginShaderStages() == ps->cendShaderStages()) {
        qWarning("Cannot build a graphics pipeline without any stages");
        return false;
    }
 
    bool hasVertexStage = false;
    for (auto it = ps->cbeginShaderStages(), itEnd = ps->cendShaderStages(); it != itEnd; ++it) {
        if (!it->shader().isValid()) {
            qWarning("Empty shader passed to graphics pipeline");
            return false;
        }
        if (it->type() == QRhiShaderStage::Vertex)
            hasVertexStage = true;
    }
    if (!hasVertexStage) {
        qWarning("Cannot build a graphics pipeline without a vertex stage");
        return false;
    }
 
    if (!ps->renderPassDescriptor()) {
        qWarning("Cannot build a graphics pipeline without a QRhiRenderPassDescriptor");
        return false;
    }
 
    if (!ps->shaderResourceBindings()) {
        qWarning("Cannot build a graphics pipeline without QRhiShaderResourceBindings");
        return false;
    }
 
    return true;
}
 
bool QRhiImplementation::sanityCheckShaderResourceBindings(QRhiShaderResourceBindings *srb)
{
#ifndef QT_NO_DEBUG
    bool bindingsOk = true;
    const int CHECKED_BINDINGS_COUNT = 64;
    bool bindingSeen[CHECKED_BINDINGS_COUNT] = {};
    for (auto it = srb->cbeginBindings(), end = srb->cendBindings(); it != end; ++it) {
        const int binding = shaderResourceBindingData(*it)->binding;
        if (binding >= CHECKED_BINDINGS_COUNT)
            continue;
        if (binding < 0) {
            qWarning("Invalid binding number %d", binding);
            bindingsOk = false;
            continue;
        }
        switch (shaderResourceBindingData(*it)->type) {
        case QRhiShaderResourceBinding::UniformBuffer:
            if (!bindingSeen[binding]) {
                bindingSeen[binding] = true;
            } else {
                qWarning("Uniform buffer duplicates an existing binding number %d", binding);
                bindingsOk = false;
            }
            break;
        case QRhiShaderResourceBinding::SampledTexture:
            if (!bindingSeen[binding]) {
                bindingSeen[binding] = true;
            } else {
                qWarning("Combined image sampler duplicates an existing binding number %d", binding);
                bindingsOk = false;
            }
            break;
        case QRhiShaderResourceBinding::Texture:
            if (!bindingSeen[binding]) {
                bindingSeen[binding] = true;
            } else {
                qWarning("Texture duplicates an existing binding number %d", binding);
                bindingsOk = false;
            }
            break;
        case QRhiShaderResourceBinding::Sampler:
            if (!bindingSeen[binding]) {
                bindingSeen[binding] = true;
            } else {
                qWarning("Sampler duplicates an existing binding number %d", binding);
                bindingsOk = false;
            }
            break;
        case QRhiShaderResourceBinding::ImageLoad:
        case QRhiShaderResourceBinding::ImageStore:
        case QRhiShaderResourceBinding::ImageLoadStore:
            if (!bindingSeen[binding]) {
                bindingSeen[binding] = true;
            } else {
                qWarning("Image duplicates an existing binding number %d", binding);
                bindingsOk = false;
            }
            break;
        case QRhiShaderResourceBinding::BufferLoad:
        case QRhiShaderResourceBinding::BufferStore:
        case QRhiShaderResourceBinding::BufferLoadStore:
            if (!bindingSeen[binding]) {
                bindingSeen[binding] = true;
            } else {
                qWarning("Buffer duplicates an existing binding number %d", binding);
                bindingsOk = false;
            }
            break;
        default:
            qWarning("Unknown binding type %d", int(shaderResourceBindingData(*it)->type));
            bindingsOk = false;
            break;
        }
    }
 
    if (!bindingsOk) {
        qWarning() << *srb;
        return false;
    }
#else
    Q_UNUSED(srb);
#endif
    return true;
}
 
int QRhiImplementation::effectiveSampleCount(int sampleCount) const
{
    // Stay compatible with QSurfaceFormat and friends where samples == 0 means the same as 1.
    const int s = qBound(1, sampleCount, 64);
    const QList<int> supported = supportedSampleCounts();
    int result = 1;
 
    // Stay compatible with Qt 5 in that requesting an unsupported sample count
    // is not an error (although we still do a categorized debug print about
    // this), and rather a supported value, preferably a close one, not just 1,
    // is used instead. This is actually deviating from Qt 5 as that performs a
    // clamping only and does not handle cases such as when sample count 2 is
    // not supported but 4 is. (OpenGL handles things like that gracefully,
    // other APIs may not, so improve this by picking the next largest, or in
    // absence of that, the largest value; this with the goal to not reduce
    // quality by rather picking a larger-than-requested value than a smaller one)
 
    for (int i = 0, ie = supported.count(); i != ie; ++i) {
        // assumes the 'supported' list is sorted
        if (supported[i] >= s) {
            result = supported[i];
            break;
        }
    }
 
    if (result != s) {
        if (result == 1 && !supported.isEmpty())
            result = supported.last();
        qCDebug(QRHI_LOG_INFO, "Attempted to set unsupported sample count %d, using %d instead",
                sampleCount, result);
    }
 
    return result;
}
 
QRhi::QRhi()
{
}
 
QRhi::~QRhi()
{
    if (!d)
        return;
 
    runCleanup();
 
    qDeleteAll(d->pendingDeleteResources);
    d->pendingDeleteResources.clear();
 
    d->destroy();
    delete d;
}
 
void QRhiImplementation::prepareForCreate(QRhi *rhi, QRhi::Implementation impl, QRhi::Flags flags)
{
    q = rhi;
 
    // Play nice with QSG_INFO since that is still the most commonly used
    // way to get graphics info printed from Qt Quick apps, and the Quick
    // scenegraph is our primary user.
    if (qEnvironmentVariableIsSet("QSG_INFO"))
        const_cast<QLoggingCategory &>(QRHI_LOG_INFO()).setEnabled(QtDebugMsg, true);
 
    debugMarkers = flags.testFlag(QRhi::EnableDebugMarkers);
 
    implType = impl;
    implThread = QThread::currentThread();
}
 
QRhi *QRhi::create(Implementation impl, QRhiInitParams *params, Flags flags, QRhiNativeHandles *importDevice)
{
    std::unique_ptr<QRhi> r(new QRhi);
 
    switch (impl) {
    case Null:
        r->d = new QRhiNull(static_cast<QRhiNullInitParams *>(params));
        break;
    case Vulkan:
#if QT_CONFIG(vulkan)
        r->d = new QRhiVulkan(static_cast<QRhiVulkanInitParams *>(params),
                              static_cast<QRhiVulkanNativeHandles *>(importDevice));
        break;
#else
        Q_UNUSED(importDevice);
        qWarning("This build of Qt has no Vulkan support");
        break;
#endif
    case OpenGLES2:
#ifndef QT_NO_OPENGL
        r->d = new QRhiGles2(static_cast<QRhiGles2InitParams *>(params),
                             static_cast<QRhiGles2NativeHandles *>(importDevice));
        break;
#else
        qWarning("This build of Qt has no OpenGL support");
        break;
#endif
    case D3D11:
#ifdef Q_OS_WIN
        r->d = new QRhiD3D11(static_cast<QRhiD3D11InitParams *>(params),
                             static_cast<QRhiD3D11NativeHandles *>(importDevice));
        break;
#else
        qWarning("This platform has no Direct3D 11 support");
        break;
#endif
    case Metal:
#if QT_CONFIG(metal)
        r->d = new QRhiMetal(static_cast<QRhiMetalInitParams *>(params),
                             static_cast<QRhiMetalNativeHandles *>(importDevice));
        break;
#else
        qWarning("This platform has no Metal support");
        break;
#endif
    case D3D12:
#ifdef Q_OS_WIN
#ifdef QRHI_D3D12_AVAILABLE
        r->d = new QRhiD3D12(static_cast<QRhiD3D12InitParams *>(params),
                             static_cast<QRhiD3D12NativeHandles *>(importDevice));
        break;
#else
        qWarning("Qt was built without Direct3D 12 support. "
                 "This is likely due to having ancient SDK headers (such as d3d12.h) in the Qt build environment. "
                 "Rebuild Qt with an SDK supporting D3D12 features introduced in Windows 10 version 1703, "
                 "or use an MSVC build as those typically are built with more up-to-date SDKs.");
        break;
#endif
#else
        qWarning("This platform has no Direct3D 12 support");
        break;
#endif
    }
 
    if (r->d) {
        r->d->prepareForCreate(r.get(), impl, flags);
        if (r->d->create(flags))
            return r.release();
    }
 
    return nullptr;
}
 
bool QRhi::probe(QRhi::Implementation impl, QRhiInitParams *params)
{
    bool ok = false;
 
    // The only place currently where this makes sense is Metal, where the API
    // is simple enough so that a special probing function - doing nothing but
    // a MTLCreateSystemDefaultDevice - is reasonable. Elsewhere, just call
    // create() and then drop the result.
 
    if (impl == Metal) {
#if QT_CONFIG(metal)
        ok = QRhiMetal::probe(static_cast<QRhiMetalInitParams *>(params));
#endif
    } else {
        QRhi *rhi = create(impl, params);
        ok = rhi != nullptr;
        delete rhi;
    }
    return ok;
}
 
QRhiSwapChainProxyData QRhi::updateSwapChainProxyData(QRhi::Implementation impl, QWindow *window)
{
#if QT_CONFIG(metal)
    if (impl == Metal)
        return QRhiMetal::updateSwapChainProxyData(window);
#else
    Q_UNUSED(impl);
    Q_UNUSED(window);
#endif
    return {};
}
 
QRhi::Implementation QRhi::backend() const
{
    return d->implType;
}
 
const char *QRhi::backendName(Implementation impl)
{
    switch (impl) {
    case QRhi::Null:
        return "Null";
    case QRhi::Vulkan:
        return "Vulkan";
    case QRhi::OpenGLES2:
        return "OpenGL";
    case QRhi::D3D11:
        return "D3D11";
    case QRhi::Metal:
        return "Metal";
    case QRhi::D3D12:
        return "D3D12";
    }
 
    Q_UNREACHABLE_RETURN("Unknown");
}
 
const char *QRhi::backendName() const
{
    return backendName(d->implType);
}
 
#ifndef QT_NO_DEBUG_STREAM
static inline const char *deviceTypeStr(QRhiDriverInfo::DeviceType type)
{
    switch (type) {
    case QRhiDriverInfo::UnknownDevice:
        return "Unknown";
    case QRhiDriverInfo::IntegratedDevice:
        return "Integrated";
    case QRhiDriverInfo::DiscreteDevice:
        return "Discrete";
    case QRhiDriverInfo::ExternalDevice:
        return "External";
    case QRhiDriverInfo::VirtualDevice:
        return "Virtual";
    case QRhiDriverInfo::CpuDevice:
        return "Cpu";
    }
 
    Q_UNREACHABLE_RETURN(nullptr);
}
QDebug operator<<(QDebug dbg, const QRhiDriverInfo &info)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiDriverInfo(deviceName=" << info.deviceName
                  << " deviceId=0x" << Qt::hex << info.deviceId
                  << " vendorId=0x" << info.vendorId
                  << " deviceType=" << deviceTypeStr(info.deviceType)
                  << ')';
    return dbg;
}
#endif
 
QRhiDriverInfo QRhi::driverInfo() const
{
    return d->driverInfo();
}
 
QThread *QRhi::thread() const
{
    return d->implThread;
}
 
void QRhi::addCleanupCallback(const CleanupCallback &callback)
{
    d->addCleanupCallback(callback);
}
 
void QRhi::addCleanupCallback(const void *key, const CleanupCallback &callback)
{
    d->addCleanupCallback(key, callback);
}
 
void QRhi::removeCleanupCallback(const void *key)
{
    d->removeCleanupCallback(key);
}
 
void QRhi::runCleanup()
{
    for (const CleanupCallback &f : std::as_const(d->cleanupCallbacks))
        f(this);
 
    d->cleanupCallbacks.clear();
 
    for (auto it = d->keyedCleanupCallbacks.cbegin(), end = d->keyedCleanupCallbacks.cend(); it != end; ++it)
        it.value()(this);
 
    d->keyedCleanupCallbacks.clear();
}
 
QRhiResourceUpdateBatch::QRhiResourceUpdateBatch(QRhiImplementation *rhi)
    : d(new QRhiResourceUpdateBatchPrivate)
{
    d->q = this;
    d->rhi = rhi;
}
 
QRhiResourceUpdateBatch::~QRhiResourceUpdateBatch()
{
    delete d;
}
 
void QRhiResourceUpdateBatch::release()
{
    d->free();
}
 
void QRhiResourceUpdateBatch::merge(QRhiResourceUpdateBatch *other)
{
    d->merge(other->d);
}
 
bool QRhiResourceUpdateBatch::hasOptimalCapacity() const
{
    return d->hasOptimalCapacity();
}
 
void QRhiResourceUpdateBatch::updateDynamicBuffer(QRhiBuffer *buf, quint32 offset, quint32 size, const void *data)
{
    if (size > 0) {
        const int idx = d->activeBufferOpCount++;
        const int opListSize = d->bufferOps.size();
        if (idx < opListSize)
            QRhiResourceUpdateBatchPrivate::BufferOp::changeToDynamicUpdate(&d->bufferOps[idx], buf, offset, size, data);
        else
            d->bufferOps.append(QRhiResourceUpdateBatchPrivate::BufferOp::dynamicUpdate(buf, offset, size, data));
    }
}
 
void QRhiResourceUpdateBatch::uploadStaticBuffer(QRhiBuffer *buf, quint32 offset, quint32 size, const void *data)
{
    if (size > 0) {
        const int idx = d->activeBufferOpCount++;
        if (idx < d->bufferOps.size())
            QRhiResourceUpdateBatchPrivate::BufferOp::changeToStaticUpload(&d->bufferOps[idx], buf, offset, size, data);
        else
            d->bufferOps.append(QRhiResourceUpdateBatchPrivate::BufferOp::staticUpload(buf, offset, size, data));
    }
}
 
void QRhiResourceUpdateBatch::uploadStaticBuffer(QRhiBuffer *buf, const void *data)
{
    if (buf->size() > 0) {
        const int idx = d->activeBufferOpCount++;
        if (idx < d->bufferOps.size())
            QRhiResourceUpdateBatchPrivate::BufferOp::changeToStaticUpload(&d->bufferOps[idx], buf, 0, 0, data);
        else
            d->bufferOps.append(QRhiResourceUpdateBatchPrivate::BufferOp::staticUpload(buf, 0, 0, data));
    }
}
 
void QRhiResourceUpdateBatch::readBackBuffer(QRhiBuffer *buf, quint32 offset, quint32 size, QRhiReadbackResult *result)
{
    const int idx = d->activeBufferOpCount++;
    if (idx < d->bufferOps.size())
        d->bufferOps[idx] = QRhiResourceUpdateBatchPrivate::BufferOp::read(buf, offset, size, result);
    else
        d->bufferOps.append(QRhiResourceUpdateBatchPrivate::BufferOp::read(buf, offset, size, result));
}
 
void QRhiResourceUpdateBatch::uploadTexture(QRhiTexture *tex, const QRhiTextureUploadDescription &desc)
{
    if (desc.cbeginEntries() != desc.cendEntries()) {
        const int idx = d->activeTextureOpCount++;
        if (idx < d->textureOps.size())
            d->textureOps[idx] = QRhiResourceUpdateBatchPrivate::TextureOp::upload(tex, desc);
        else
            d->textureOps.append(QRhiResourceUpdateBatchPrivate::TextureOp::upload(tex, desc));
    }
}
 
void QRhiResourceUpdateBatch::uploadTexture(QRhiTexture *tex, const QImage &image)
{
    uploadTexture(tex,
                  QRhiTextureUploadEntry(0, 0, QRhiTextureSubresourceUploadDescription(image)));
}
 
void QRhiResourceUpdateBatch::copyTexture(QRhiTexture *dst, QRhiTexture *src, const QRhiTextureCopyDescription &desc)
{
    const int idx = d->activeTextureOpCount++;
    if (idx < d->textureOps.size())
        d->textureOps[idx] = QRhiResourceUpdateBatchPrivate::TextureOp::copy(dst, src, desc);
    else
        d->textureOps.append(QRhiResourceUpdateBatchPrivate::TextureOp::copy(dst, src, desc));
}
 
void QRhiResourceUpdateBatch::readBackTexture(const QRhiReadbackDescription &rb, QRhiReadbackResult *result)
{
    const int idx = d->activeTextureOpCount++;
    if (idx < d->textureOps.size())
        d->textureOps[idx] = QRhiResourceUpdateBatchPrivate::TextureOp::read(rb, result);
    else
        d->textureOps.append(QRhiResourceUpdateBatchPrivate::TextureOp::read(rb, result));
}
 
void QRhiResourceUpdateBatch::generateMips(QRhiTexture *tex)
{
    const int idx = d->activeTextureOpCount++;
    if (idx < d->textureOps.size())
        d->textureOps[idx] = QRhiResourceUpdateBatchPrivate::TextureOp::genMips(tex);
    else
        d->textureOps.append(QRhiResourceUpdateBatchPrivate::TextureOp::genMips(tex));
}
 
QRhiResourceUpdateBatch *QRhi::nextResourceUpdateBatch()
{
    // By default we prefer spreading out the utilization of the 64 batches as
    // much as possible, meaning we won't pick the first one even if it's free,
    // but prefer picking one after the last picked one. Relevant due to how
    // QVLA and QRhiBufferData allocations behind the bufferOps are reused; in
    // typical Qt Quick scenes this leads to a form of (eventually) seeding all
    // the 64 resource batches with buffer operation data allocations which are
    // then reused in subsequent frames. This comes at the expense of using
    // more memory, but has proven good results when (CPU) profiling typical
    // Quick/Quick3D apps.
    //
    // Prefering memory over performance means that we always pick the first
    // free batch, and triggering the aggressive deallocating of all backing
    // memory (see trimOpLists) before returning it.
    static const bool preferMemoryOverPerformance = qEnvironmentVariableIntValue("QT_RHI_MINIMIZE_POOLS");
 
    auto nextFreeBatch = [this]() -> QRhiResourceUpdateBatch * {
        auto isFree = [this](int i) -> QRhiResourceUpdateBatch * {
            const quint64 mask = 1ULL << quint64(i);
            if (!(d->resUpdPoolMap & mask)) {
                d->resUpdPoolMap |= mask;
                QRhiResourceUpdateBatch *u = d->resUpdPool[i];
                QRhiResourceUpdateBatchPrivate::get(u)->poolIndex = i;
                if (!preferMemoryOverPerformance)
                    d->lastResUpdIdx = i;
                return u;
            }
            return nullptr;
        };
        const int poolSize = d->resUpdPool.size();
        for (int i = d->lastResUpdIdx + 1; i < poolSize; ++i) {
            if (QRhiResourceUpdateBatch *u = isFree(i))
                return u;
        }
        for (int i = 0; i <= d->lastResUpdIdx; ++i) {
            if (QRhiResourceUpdateBatch *u = isFree(i))
                return u;
        }
        return nullptr;
    };
 
    QRhiResourceUpdateBatch *u = nextFreeBatch();
    if (!u) {
        const int oldSize = d->resUpdPool.size();
        const int newSize = oldSize + qMin(4, qMax(0, 64 - oldSize));
        d->resUpdPool.resize(newSize);
        for (int i = oldSize; i < newSize; ++i)
            d->resUpdPool[i] = new QRhiResourceUpdateBatch(d);
        u = nextFreeBatch();
        if (!u)
            qWarning("Resource update batch pool exhausted (max is 64)");
    }
 
    if (preferMemoryOverPerformance && u)
        u->d->trimOpLists();
 
    return u;
}
 
void QRhiResourceUpdateBatchPrivate::free()
{
    Q_ASSERT(poolIndex >= 0 && rhi->resUpdPool[poolIndex] == q);
 
    activeBufferOpCount = 0;
    activeTextureOpCount = 0;
 
    const quint64 mask = 1ULL << quint64(poolIndex);
    rhi->resUpdPoolMap &= ~mask;
    poolIndex = -1;
 
    // textureOps is cleared, to not keep the potentially large image pixel
    // data alive, but it is expected that the container keeps the list alloc
    // at least. Only trimOpList() goes for the more aggressive route with squeeze.
    textureOps.clear();
 
    // bufferOps is not touched, to allow reusing allocations (incl. in the
    // elements' QRhiBufferData) as much as possible when this batch is used
    // again in the future, which is important for performance, in particular
    // with Qt Quick.
}
 
void QRhiResourceUpdateBatchPrivate::merge(QRhiResourceUpdateBatchPrivate *other)
{
    int combinedSize = activeBufferOpCount + other->activeBufferOpCount;
    if (bufferOps.size() < combinedSize)
        bufferOps.resize(combinedSize);
    for (int i = activeBufferOpCount; i < combinedSize; ++i)
        bufferOps[i] = std::move(other->bufferOps[i - activeBufferOpCount]);
    activeBufferOpCount += other->activeBufferOpCount;
 
    combinedSize = activeTextureOpCount + other->activeTextureOpCount;
    if (textureOps.size() < combinedSize)
        textureOps.resize(combinedSize);
    for (int i = activeTextureOpCount; i < combinedSize; ++i)
        textureOps[i] = std::move(other->textureOps[i - activeTextureOpCount]);
    activeTextureOpCount += other->activeTextureOpCount;
}
 
bool QRhiResourceUpdateBatchPrivate::hasOptimalCapacity() const
{
    return activeBufferOpCount < BUFFER_OPS_STATIC_ALLOC - 16
            && activeTextureOpCount < TEXTURE_OPS_STATIC_ALLOC - 16;
}
 
void QRhiResourceUpdateBatchPrivate::trimOpLists()
{
    // Unlike free(), this is expected to aggressively deallocate all memory
    // used by both the buffer and texture operation lists. (i.e. using
    // squeeze() to only keep the stack prealloc of the QVLAs)
    //
    // This (e.g. just the destruction of bufferOps elements) may have a
    // non-negligible performance impact e.g. with Qt Quick with scenes where
    // there are lots of buffer operations per frame.
 
    activeBufferOpCount = 0;
    bufferOps.clear();
    bufferOps.squeeze();
 
    activeTextureOpCount = 0;
    textureOps.clear();
    textureOps.squeeze();
}
 
void QRhiCommandBuffer::resourceUpdate(QRhiResourceUpdateBatch *resourceUpdates)
{
    if (resourceUpdates)
        m_rhi->resourceUpdate(this, resourceUpdates);
}
 
void QRhiCommandBuffer::beginPass(QRhiRenderTarget *rt,
                                  const QColor &colorClearValue,
                                  const QRhiDepthStencilClearValue &depthStencilClearValue,
                                  QRhiResourceUpdateBatch *resourceUpdates,
                                  BeginPassFlags flags)
{
    m_rhi->beginPass(this, rt, colorClearValue, depthStencilClearValue, resourceUpdates, flags);
}
 
void QRhiCommandBuffer::endPass(QRhiResourceUpdateBatch *resourceUpdates)
{
    m_rhi->endPass(this, resourceUpdates);
}
 
void QRhiCommandBuffer::setGraphicsPipeline(QRhiGraphicsPipeline *ps)
{
    Q_ASSERT(ps != nullptr);
    m_rhi->setGraphicsPipeline(this, ps);
}
 
void QRhiCommandBuffer::setShaderResources(QRhiShaderResourceBindings *srb,
                                           int dynamicOffsetCount,
                                           const DynamicOffset *dynamicOffsets)
{
    m_rhi->setShaderResources(this, srb, dynamicOffsetCount, dynamicOffsets);
}
 
void QRhiCommandBuffer::setVertexInput(int startBinding, int bindingCount, const VertexInput *bindings,
                                       QRhiBuffer *indexBuf, quint32 indexOffset,
                                       IndexFormat indexFormat)
{
    m_rhi->setVertexInput(this, startBinding, bindingCount, bindings, indexBuf, indexOffset, indexFormat);
}
 
void QRhiCommandBuffer::setViewport(const QRhiViewport &viewport)
{
    m_rhi->setViewport(this, viewport);
}
 
void QRhiCommandBuffer::setScissor(const QRhiScissor &scissor)
{
    m_rhi->setScissor(this, scissor);
}
 
void QRhiCommandBuffer::setBlendConstants(const QColor &c)
{
    m_rhi->setBlendConstants(this, c);
}
 
void QRhiCommandBuffer::setStencilRef(quint32 refValue)
{
    m_rhi->setStencilRef(this, refValue);
}
 
void QRhiCommandBuffer::draw(quint32 vertexCount,
                             quint32 instanceCount,
                             quint32 firstVertex,
                             quint32 firstInstance)
{
    m_rhi->draw(this, vertexCount, instanceCount, firstVertex, firstInstance);
}
 
void QRhiCommandBuffer::drawIndexed(quint32 indexCount,
                                    quint32 instanceCount,
                                    quint32 firstIndex,
                                    qint32 vertexOffset,
                                    quint32 firstInstance)
{
    m_rhi->drawIndexed(this, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
 
void QRhiCommandBuffer::debugMarkBegin(const QByteArray &name)
{
    m_rhi->debugMarkBegin(this, name);
}
 
void QRhiCommandBuffer::debugMarkEnd()
{
    m_rhi->debugMarkEnd(this);
}
 
void QRhiCommandBuffer::debugMarkMsg(const QByteArray &msg)
{
    m_rhi->debugMarkMsg(this, msg);
}
 
void QRhiCommandBuffer::beginComputePass(QRhiResourceUpdateBatch *resourceUpdates, BeginPassFlags flags)
{
    m_rhi->beginComputePass(this, resourceUpdates, flags);
}
 
void QRhiCommandBuffer::endComputePass(QRhiResourceUpdateBatch *resourceUpdates)
{
    m_rhi->endComputePass(this, resourceUpdates);
}
 
void QRhiCommandBuffer::setComputePipeline(QRhiComputePipeline *ps)
{
    m_rhi->setComputePipeline(this, ps);
}
 
void QRhiCommandBuffer::dispatch(int x, int y, int z)
{
    m_rhi->dispatch(this, x, y, z);
}
 
const QRhiNativeHandles *QRhiCommandBuffer::nativeHandles()
{
    return m_rhi->nativeHandles(this);
}
 
void QRhiCommandBuffer::beginExternal()
{
    m_rhi->beginExternal(this);
}
 
void QRhiCommandBuffer::endExternal()
{
    m_rhi->endExternal(this);
}
 
double QRhiCommandBuffer::lastCompletedGpuTime()
{
    return m_rhi->lastCompletedGpuTime(this);
}
 
int QRhi::ubufAligned(int v) const
{
    const int byteAlign = ubufAlignment();
    return (v + byteAlign - 1) & ~(byteAlign - 1);
}
 
int QRhi::mipLevelsForSize(const QSize &size)
{
    return qFloor(std::log2(qMax(size.width(), size.height()))) + 1;
}
 
QSize QRhi::sizeForMipLevel(int mipLevel, const QSize &baseLevelSize)
{
    const int w = qMax(1, baseLevelSize.width() >> mipLevel);
    const int h = qMax(1, baseLevelSize.height() >> mipLevel);
    return QSize(w, h);
}
 
bool QRhi::isYUpInFramebuffer() const
{
    return d->isYUpInFramebuffer();
}
 
bool QRhi::isYUpInNDC() const
{
    return d->isYUpInNDC();
}
 
bool QRhi::isClipDepthZeroToOne() const
{
    return d->isClipDepthZeroToOne();
}
 
QMatrix4x4 QRhi::clipSpaceCorrMatrix() const
{
    return d->clipSpaceCorrMatrix();
}
 
bool QRhi::isTextureFormatSupported(QRhiTexture::Format format, QRhiTexture::Flags flags) const
{
    return d->isTextureFormatSupported(format, flags);
}
 
bool QRhi::isFeatureSupported(QRhi::Feature feature) const
{
    return d->isFeatureSupported(feature);
}
 
int QRhi::resourceLimit(ResourceLimit limit) const
{
    return d->resourceLimit(limit);
}
 
const QRhiNativeHandles *QRhi::nativeHandles()
{
    return d->nativeHandles();
}
 
bool QRhi::makeThreadLocalNativeContextCurrent()
{
    return d->makeThreadLocalNativeContextCurrent();
}
 
void QRhi::releaseCachedResources()
{
    d->releaseCachedResources();
 
    for (QRhiResourceUpdateBatch *u : d->resUpdPool) {
        if (u->d->poolIndex < 0)
            u->d->trimOpLists();
    }
}
 
bool QRhi::isDeviceLost() const
{
    return d->isDeviceLost();
}
 
QByteArray QRhi::pipelineCacheData()
{
    return d->pipelineCacheData();
}
 
void QRhi::setPipelineCacheData(const QByteArray &data)
{
    d->setPipelineCacheData(data);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QRhiStats &info)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QRhiStats("
                  << "totalPipelineCreationTime=" << info.totalPipelineCreationTime
                  << " blockCount=" << info.blockCount
                  << " allocCount=" << info.allocCount
                  << " usedBytes=" << info.usedBytes
                  << " unusedBytes=" << info.unusedBytes
                  << " totalUsageBytes=" << info.totalUsageBytes
                  << ')';
    return dbg;
}
#endif
 
QRhiStats QRhi::statistics() const
{
    return d->statistics();
}
 
QRhiGraphicsPipeline *QRhi::newGraphicsPipeline()
{
    return d->createGraphicsPipeline();
}
 
QRhiComputePipeline *QRhi::newComputePipeline()
{
    return d->createComputePipeline();
}
 
QRhiShaderResourceBindings *QRhi::newShaderResourceBindings()
{
    return d->createShaderResourceBindings();
}
 
QRhiBuffer *QRhi::newBuffer(QRhiBuffer::Type type,
                            QRhiBuffer::UsageFlags usage,
                            quint32 size)
{
    return d->createBuffer(type, usage, size);
}
 
QRhiRenderBuffer *QRhi::newRenderBuffer(QRhiRenderBuffer::Type type,
                                        const QSize &pixelSize,
                                        int sampleCount,
                                        QRhiRenderBuffer::Flags flags,
                                        QRhiTexture::Format backingFormatHint)
{
    return d->createRenderBuffer(type, pixelSize, sampleCount, flags, backingFormatHint);
}
 
QRhiTexture *QRhi::newTexture(QRhiTexture::Format format,
                              const QSize &pixelSize,
                              int sampleCount,
                              QRhiTexture::Flags flags)
{
    if (pixelSize.height() == 0)
        flags |= QRhiTexture::OneDimensional;
 
    return d->createTexture(format, pixelSize, 1, 0, sampleCount, flags);
}
 
QRhiTexture *QRhi::newTexture(QRhiTexture::Format format,
                              int width, int height, int depth,
                              int sampleCount,
                              QRhiTexture::Flags flags)
{
    if (depth > 0)
        flags |= QRhiTexture::ThreeDimensional;
 
    if (height == 0 && depth == 0)
        flags |= QRhiTexture::OneDimensional;
 
    return d->createTexture(format, QSize(width, height), depth, 0, sampleCount, flags);
}
 
QRhiTexture *QRhi::newTextureArray(QRhiTexture::Format format,
                                   int arraySize,
                                   const QSize &pixelSize,
                                   int sampleCount,
                                   QRhiTexture::Flags flags)
{
    flags |= QRhiTexture::TextureArray;
 
    if (pixelSize.height() == 0)
        flags |= QRhiTexture::OneDimensional;
 
    return d->createTexture(format, pixelSize, 1, arraySize, sampleCount, flags);
}
 
QRhiSampler *QRhi::newSampler(QRhiSampler::Filter magFilter,
                              QRhiSampler::Filter minFilter,
                              QRhiSampler::Filter mipmapMode,
                              QRhiSampler::AddressMode addressU,
                              QRhiSampler::AddressMode addressV,
                              QRhiSampler::AddressMode addressW)
{
    return d->createSampler(magFilter, minFilter, mipmapMode, addressU, addressV, addressW);
}
 
QRhiTextureRenderTarget *QRhi::newTextureRenderTarget(const QRhiTextureRenderTargetDescription &desc,
                                                      QRhiTextureRenderTarget::Flags flags)
{
    return d->createTextureRenderTarget(desc, flags);
}
 
QRhiSwapChain *QRhi::newSwapChain()
{
    return d->createSwapChain();
}
 
QRhi::FrameOpResult QRhi::beginFrame(QRhiSwapChain *swapChain, BeginFrameFlags flags)
{
    if (d->inFrame)
        qWarning("Attempted to call beginFrame() within a still active frame; ignored");
 
    QRhi::FrameOpResult r = !d->inFrame ? d->beginFrame(swapChain, flags) : FrameOpSuccess;
    if (r == FrameOpSuccess)
        d->inFrame = true;
 
    return r;
}
 
QRhi::FrameOpResult QRhi::endFrame(QRhiSwapChain *swapChain, EndFrameFlags flags)
{
    if (!d->inFrame)
        qWarning("Attempted to call endFrame() without an active frame; ignored");
 
    QRhi::FrameOpResult r = d->inFrame ? d->endFrame(swapChain, flags) : FrameOpSuccess;
    d->inFrame = false;
    // deleteLater is a high level QRhi concept the backends know
    // nothing about - handle it here.
    qDeleteAll(d->pendingDeleteResources);
    d->pendingDeleteResources.clear();
 
    return r;
}
 
bool QRhi::isRecordingFrame() const
{
    return d->inFrame;
}
 
int QRhi::currentFrameSlot() const
{
    return d->currentFrameSlot;
}
 
QRhi::FrameOpResult QRhi::beginOffscreenFrame(QRhiCommandBuffer **cb, BeginFrameFlags flags)
{
    if (d->inFrame)
        qWarning("Attempted to call beginOffscreenFrame() within a still active frame; ignored");
 
    QRhi::FrameOpResult r = !d->inFrame ? d->beginOffscreenFrame(cb, flags) : FrameOpSuccess;
    if (r == FrameOpSuccess)
        d->inFrame = true;
 
    return r;
}
 
QRhi::FrameOpResult QRhi::endOffscreenFrame(EndFrameFlags flags)
{
    if (!d->inFrame)
        qWarning("Attempted to call endOffscreenFrame() without an active frame; ignored");
 
    QRhi::FrameOpResult r = d->inFrame ? d->endOffscreenFrame(flags) : FrameOpSuccess;
    d->inFrame = false;
    qDeleteAll(d->pendingDeleteResources);
    d->pendingDeleteResources.clear();
 
    return r;
}
 
QRhi::FrameOpResult QRhi::finish()
{
    return d->finish();
}
 
QList<int> QRhi::supportedSampleCounts() const
{
    return d->supportedSampleCounts();
}
 
int QRhi::ubufAlignment() const
{
    return d->ubufAlignment();
}
 
Q_CONSTINIT static QBasicAtomicInteger<QRhiGlobalObjectIdGenerator::Type> counter = Q_BASIC_ATOMIC_INITIALIZER(0);
 
QRhiGlobalObjectIdGenerator::Type QRhiGlobalObjectIdGenerator::newId()
{
    return counter.fetchAndAddRelaxed(1) + 1;
}
 
bool QRhiPassResourceTracker::isEmpty() const
{
    return m_buffers.isEmpty() && m_textures.isEmpty();
}
 
void QRhiPassResourceTracker::reset()
{
    m_buffers.clear();
    m_textures.clear();
}
 
static inline QRhiPassResourceTracker::BufferStage earlierStage(QRhiPassResourceTracker::BufferStage a,
                                                                QRhiPassResourceTracker::BufferStage b)
{
    return QRhiPassResourceTracker::BufferStage(qMin(int(a), int(b)));
}
 
void QRhiPassResourceTracker::registerBuffer(QRhiBuffer *buf, int slot, BufferAccess *access, BufferStage *stage,
                                             const UsageState &state)
{
    auto it = m_buffers.find(buf);
    if (it != m_buffers.end()) {
        if (it->access != *access) {
            const QByteArray name = buf->name();
            qWarning("Buffer %p (%s) used with different accesses within the same pass, this is not allowed.",
                     buf, name.constData());
            return;
        }
        if (it->stage != *stage) {
            it->stage = earlierStage(it->stage, *stage);
            *stage = it->stage;
        }
        return;
    }
 
    Buffer b;
    b.slot = slot;
    b.access = *access;
    b.stage = *stage;
    b.stateAtPassBegin = state; // first use -> initial state
    m_buffers.insert(buf, b);
}
 
static inline QRhiPassResourceTracker::TextureStage earlierStage(QRhiPassResourceTracker::TextureStage a,
                                                                 QRhiPassResourceTracker::TextureStage b)
{
    return QRhiPassResourceTracker::TextureStage(qMin(int(a), int(b)));
}
 
static inline bool isImageLoadStore(QRhiPassResourceTracker::TextureAccess access)
{
    return access == QRhiPassResourceTracker::TexStorageLoad
            || access == QRhiPassResourceTracker::TexStorageStore
            || access == QRhiPassResourceTracker::TexStorageLoadStore;
}
 
void QRhiPassResourceTracker::registerTexture(QRhiTexture *tex, TextureAccess *access, TextureStage *stage,
                                              const UsageState &state)
{
    auto it = m_textures.find(tex);
    if (it != m_textures.end()) {
        if (it->access != *access) {
            // Different subresources of a texture may be used for both load
            // and store in the same pass. (think reading from one mip level
            // and writing to another one in a compute shader) This we can
            // handle by treating the entire resource as read-write.
            if (isImageLoadStore(it->access) && isImageLoadStore(*access)) {
                it->access = QRhiPassResourceTracker::TexStorageLoadStore;
                *access = it->access;
            } else {
                const QByteArray name = tex->name();
                qWarning("Texture %p (%s) used with different accesses within the same pass, this is not allowed.",
                         tex, name.constData());
            }
        }
        if (it->stage != *stage) {
            it->stage = earlierStage(it->stage, *stage);
            *stage = it->stage;
        }
        return;
    }
 
    Texture t;
    t.access = *access;
    t.stage = *stage;
    t.stateAtPassBegin = state; // first use -> initial state
    m_textures.insert(tex, t);
}
 
QRhiPassResourceTracker::BufferStage QRhiPassResourceTracker::toPassTrackerBufferStage(QRhiShaderResourceBinding::StageFlags stages)
{
    // pick the earlier stage (as this is going to be dstAccessMask)
    if (stages.testFlag(QRhiShaderResourceBinding::VertexStage))
        return QRhiPassResourceTracker::BufVertexStage;
    if (stages.testFlag(QRhiShaderResourceBinding::TessellationControlStage))
        return QRhiPassResourceTracker::BufTCStage;
    if (stages.testFlag(QRhiShaderResourceBinding::TessellationEvaluationStage))
        return QRhiPassResourceTracker::BufTEStage;
    if (stages.testFlag(QRhiShaderResourceBinding::FragmentStage))
        return QRhiPassResourceTracker::BufFragmentStage;
    if (stages.testFlag(QRhiShaderResourceBinding::ComputeStage))
        return QRhiPassResourceTracker::BufComputeStage;
    if (stages.testFlag(QRhiShaderResourceBinding::GeometryStage))
        return QRhiPassResourceTracker::BufGeometryStage;
 
    Q_UNREACHABLE_RETURN(QRhiPassResourceTracker::BufVertexStage);
}
 
QRhiPassResourceTracker::TextureStage QRhiPassResourceTracker::toPassTrackerTextureStage(QRhiShaderResourceBinding::StageFlags stages)
{
    // pick the earlier stage (as this is going to be dstAccessMask)
    if (stages.testFlag(QRhiShaderResourceBinding::VertexStage))
        return QRhiPassResourceTracker::TexVertexStage;
    if (stages.testFlag(QRhiShaderResourceBinding::TessellationControlStage))
        return QRhiPassResourceTracker::TexTCStage;
    if (stages.testFlag(QRhiShaderResourceBinding::TessellationEvaluationStage))
        return QRhiPassResourceTracker::TexTEStage;
    if (stages.testFlag(QRhiShaderResourceBinding::FragmentStage))
        return QRhiPassResourceTracker::TexFragmentStage;
    if (stages.testFlag(QRhiShaderResourceBinding::ComputeStage))
        return QRhiPassResourceTracker::TexComputeStage;
    if (stages.testFlag(QRhiShaderResourceBinding::GeometryStage))
        return QRhiPassResourceTracker::TexGeometryStage;
 
    Q_UNREACHABLE_RETURN(QRhiPassResourceTracker::TexVertexStage);
}
 
QT_END_NAMESPACE