qssgrhicontext_p.h

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

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

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

++

++

++ #ifndef QSSGRHICONTEXT_P_H

++ #define QSSGRHICONTEXT_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 <QtGui/rhi/qrhi.h>

++

++ #include <QtQuick3DRuntimeRender/qtquick3druntimerenderexports.h>

++ #include <QtQuick3DUtils/private/qssgrenderbasetypes_p.h>

++ #include <QtQuick3DUtils/private/qssgutils_p.h>

++ #include <ssg/qssgrhicontext.h>

++

++ QT_BEGIN_NAMESPACE

++

++ struct QSSGRenderLayer;

++ struct QSSGRenderSkyMaterial;

++ struct QSSGRenderInstanceTable;

++ struct QSSGRenderModel;

++ struct QSSGRenderMesh;

++ class QSSGRenderGraphObject;

++ class QSSGBufferManager;

++ class QSSGUserRenderPassManager;

++

++ struct QSSGRhiInputAssemblerStatePrivate

++ {

++     using InputAssemblerState = QSSGRhiGraphicsPipelineState::InputAssemblerState;

++     static const InputAssemblerState &get(const QSSGRhiGraphicsPipelineState &ps) { return ps.ia; }

++     static InputAssemblerState &get(QSSGRhiGraphicsPipelineState &ps) { return ps.ia; }

++ };

++

++ using QSSGRhiInputAssemblerState = QSSGRhiInputAssemblerStatePrivate::InputAssemblerState;

++

++ struct QSSGRhiGraphicsPipelineStatePrivate

++ {

++     static void setShaderPipeline(QSSGRhiGraphicsPipelineState &ps, const QSSGRhiShaderPipeline *pipeline)

++     {

++         ps.shaderPipeline = pipeline;

++     }

++

++     static constexpr const QSSGRhiShaderPipeline *getShaderPipeline(const QSSGRhiGraphicsPipelineState &ps)

++     {

++         return ps.shaderPipeline;

++     }

++ };

++

++ namespace QSSGRhiHelpers

++ {

++

++ inline QRhiSampler::Filter toRhi(QSSGRenderTextureFilterOp op)

++ {

++     switch (op) {

++     case QSSGRenderTextureFilterOp::Nearest:

++         return QRhiSampler::Nearest;

++     case QSSGRenderTextureFilterOp::Linear:

++         return QRhiSampler::Linear;

++     case QSSGRenderTextureFilterOp::None:

++         return QRhiSampler::Linear;

++     }

++

++     Q_UNREACHABLE_RETURN(QRhiSampler::Linear);

++ }

++

++ inline QRhiSampler::AddressMode toRhi(QSSGRenderTextureCoordOp tiling)

++ {

++     switch (tiling) {

++     case QSSGRenderTextureCoordOp::Repeat:

++         return QRhiSampler::Repeat;

++     case QSSGRenderTextureCoordOp::MirroredRepeat:

++         return QRhiSampler::Mirror;

++     case QSSGRenderTextureCoordOp::ClampToEdge:

++         return QRhiSampler::ClampToEdge;

++     case QSSGRenderTextureCoordOp::Unknown:

++         return QRhiSampler::ClampToEdge;

++     }

++

++     Q_UNREACHABLE_RETURN(QRhiSampler::ClampToEdge);

++ }

++

++ inline QRhiGraphicsPipeline::CullMode toCullMode(QSSGCullFaceMode cullFaceMode)

++ {

++     switch (cullFaceMode) {

++     case QSSGCullFaceMode::Back:

++         return QRhiGraphicsPipeline::Back;

++     case QSSGCullFaceMode::Front:

++         return QRhiGraphicsPipeline::Front;

++     case QSSGCullFaceMode::Disabled:

++         return QRhiGraphicsPipeline::None;

++     case QSSGCullFaceMode::FrontAndBack:

++         qWarning("FrontAndBack cull mode not supported");

++         return QRhiGraphicsPipeline::None;

++     case QSSGCullFaceMode::Unknown:

++         return QRhiGraphicsPipeline::None;

++     }

++

++     Q_UNREACHABLE_RETURN(QRhiGraphicsPipeline::None);

++ }

++

++ QRhiVertexInputAttribute::Format toVertexInputFormat(QSSGRenderComponentType compType, quint32 numComps);

++ QRhiGraphicsPipeline::Topology toTopology(QSSGRenderDrawMode drawMode);

++ // Fills out inputLayout.attributes[].location based on

++ // inputLayoutInputNames and the provided shader reflection info.

++ void bakeVertexInputLocations(QSSGRhiInputAssemblerState *ia, const QSSGRhiShaderPipeline &shaders, int instanceBufferBinding = 0);

++

++ } // namespace QSSGRhiHelpers

++

++ inline bool operator==(const QSSGRhiGraphicsPipelineState &a, const QSSGRhiGraphicsPipelineState &b) Q_DECL_NOTHROW

++ {

++     const auto &ia_a = QSSGRhiInputAssemblerStatePrivate::get(a);

++     const auto &ia_b = QSSGRhiInputAssemblerStatePrivate::get(b);

++     const auto compareTargetBlend = [](const std::array<QRhiGraphicsPipeline::TargetBlend, 8> &a,

++                                        const std::array<QRhiGraphicsPipeline::TargetBlend, 8> &b,

++                                        const int count) -> bool {

++         for (int i = 0; i < count; i++) {

++             if (a[i].colorWrite != b[i].colorWrite

++                 || a[i].srcColor != b[i].srcColor

++                 || a[i].dstColor != b[i].dstColor

++                 || a[i].opColor != b[i].opColor

++                 || a[i].srcAlpha != b[i].srcAlpha

++                 || a[i].dstAlpha != b[i].dstAlpha

++                 || a[i].opAlpha != b[i].opAlpha) {

++                 return false;

++             }

++         }

++         return true;

++     };

++     // The viewport and scissor rects are intentionally not compared: they are

++     // dynamic state, never baked into a QRhiGraphicsPipeline, and comparing

++     // them made the pipeline cache key size-dependent, growing the cache with

++     // a new set of pipelines for every window size!

++     return QSSGRhiGraphicsPipelineStatePrivate::getShaderPipeline(a) == QSSGRhiGraphicsPipelineStatePrivate::getShaderPipeline(b)

++             && a.samples == b.samples

++             && a.flags == b.flags

++             && a.stencilRef == b.stencilRef

++             && (std::memcmp(&a.stencilOpFrontState, &b.stencilOpFrontState, sizeof(QRhiGraphicsPipeline::StencilOpState)) == 0)

++             && a.stencilWriteMask == b.stencilWriteMask

++             && a.depthFunc == b.depthFunc

++             && a.cullMode == b.cullMode

++             && a.depthBias == b.depthBias

++             && a.slopeScaledDepthBias == b.slopeScaledDepthBias

++             && ia_a.topology == ia_b.topology

++             && ia_a.inputLayout == ia_b.inputLayout

++             && a.colorAttachmentCount == b.colorAttachmentCount

++             && compareTargetBlend(a.targetBlend, b.targetBlend, a.colorAttachmentCount)

++             && a.lineWidth == b.lineWidth

++             && a.polygonMode == b.polygonMode

++             && a.viewCount == b.viewCount;

++ }

++

++ inline bool operator!=(const QSSGRhiGraphicsPipelineState &a, const QSSGRhiGraphicsPipelineState &b) Q_DECL_NOTHROW

++ {

++     return !(a == b);

++ }

++

++ inline size_t qHash(const QSSGRhiGraphicsPipelineState &s, size_t seed) Q_DECL_NOTHROW

++ {

++     // do not bother with all fields

++     return qHash(QSSGRhiGraphicsPipelineStatePrivate::getShaderPipeline(s), seed)

++             ^ qHash(s.samples)

++             ^ qHash(s.viewCount)

++             ^ qHash(s.targetBlend[0].dstColor)

++             ^ qHash(s.depthFunc)

++             ^ qHash(s.cullMode)

++             ^ qHash(s.colorAttachmentCount)

++             ^ qHash(s.lineWidth)

++             ^ qHash(s.polygonMode)

++             ^ qHashBits(&s.stencilOpFrontState, sizeof(QRhiGraphicsPipeline::StencilOpState))

++             ^ (s.flags)

++             ^ (s.stencilRef << 6)

++             ^ (s.stencilWriteMask << 7);

++ }

++

++ // The lookup keys can be somewhat complicated due to having to handle cases

++ // like "render a model in a shared scene between multiple View3Ds" (here both

++ // the View3D ('layer/cid') and the model ('model') act as the lookup key since

++ // while the model is the same, we still want different uniform buffers per

++ // View3D). 'resource' is the resource the model is drawn with, typically a

++ // material; many resources can map to one model. When 'resource' refers to a

++ // material it must be the material pointer and nothing else, since

++ // cleanupDrawCallDataForResource() finds the entries to release for a

++ // to-be-destroyed material by matching on 'resource'. 'mapEntry' is the

++ // per-light shadow map entry or per-probe reflection map entry being rendered

++ // into, when the draw is part of a shadow or reflection pass, otherwise null.

++ // 'resourceIdx' disambiguates multiple entries for the same resource and map

++ // entry, e.g. the cube map face and the subset offset.

++ //

++ struct QSSGRhiDrawCallDataKey

++ {

++     const void *cid = nullptr; // Usually the sub-pass (see usage of QSSGPassKey)

++     const void *model = nullptr;

++     const void *resource = nullptr;

++     const void *mapEntry = nullptr;

++     quintptr resourceIdx = 0;

++ };

++

++ class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRhiBuffer

++ {

++     Q_DISABLE_COPY(QSSGRhiBuffer)

++ public:

++     QSSGRhiBuffer(QSSGRhiContext &context,

++                   QRhiBuffer::Type type,

++                   QRhiBuffer::UsageFlags usageMask,

++                   quint32 stride,

++                   qsizetype size,

++                   QRhiCommandBuffer::IndexFormat indexFormat = QRhiCommandBuffer::IndexUInt16);

++

++     virtual ~QSSGRhiBuffer();

++

++     QRhiBuffer *buffer() const { return m_buffer; }

++     quint32 stride() const { return m_stride; }

++     quint32 numVertices() const {

++         const quint32 sz = quint32(m_buffer->size());

++         Q_ASSERT((sz % m_stride) == 0);

++         return sz / m_stride;

++     }

++     QRhiCommandBuffer::IndexFormat indexFormat() const { return m_indexFormat; }

++

++ private:

++     QSSGRhiContext &m_context;

++     QRhiBuffer *m_buffer = nullptr;

++     quint32 m_stride;

++     QRhiCommandBuffer::IndexFormat m_indexFormat;

++ };

++

++ struct QSSGRhiShaderUniform

++ {

++     char name[64];

++     size_t size = 0;

++

++ private:

++     size_t offset = SIZE_MAX;

++     bool maybeExists = true;

++     friend class QSSGRhiShaderPipeline;

++ };

++

++ struct QSSGRhiShaderUniformArray

++ {

++     char name[64];

++     size_t typeSize = 0;

++     size_t itemCount = 0;

++

++ private:

++     size_t offset = SIZE_MAX;

++     size_t size = 0;

++     bool maybeExists = true;

++     friend class QSSGRhiShaderPipeline;

++ };

++

++ using QSSGRhiBufferPtr = std::shared_ptr<QSSGRhiBuffer>;

++

++ inline bool operator==(const QSSGRhiSamplerDescription &a, const QSSGRhiSamplerDescription &b) Q_DECL_NOTHROW

++ {

++    return a.hTiling == b.hTiling && a.vTiling == b.vTiling && a.zTiling == b.zTiling

++            && a.minFilter == b.minFilter && a.magFilter == b.magFilter

++            && a.mipmap == b.mipmap;

++ }

++

++ inline bool operator!=(const QSSGRhiSamplerDescription &a, const QSSGRhiSamplerDescription &b) Q_DECL_NOTHROW

++ {

++     return !(a == b);

++ }

++

++ struct QSSGRhiTexture

++ {

++     QByteArray name;

++     QRhiTexture *texture = nullptr;

++     QSSGRhiSamplerDescription samplerDesc;

++ };

++

++ enum class QSSGRhiSamplerBindingHints

++ {

++     LightProbe = 64, // must be larger than the largest value in SSGRenderableImage::Type

++     ScreenTexture,

++     DepthTexture,

++     AoTexture,

++     LightmapTexture,

++     DepthTextureArray,

++     ScreenTextureArray,

++     AoTextureArray,

++     NormalTexture,

++     MotionVectorTexture,

++

++     BindingMapSize

++ };

++

++ // these are our current shader limits

++ #define QSSG_MAX_NUM_LIGHTS 16

++ #define QSSG_MAX_NUM_DIRECTIONAL_LIGHTS 4

++ #define QSSG_REDUCED_MAX_NUM_LIGHTS 4

++ #define QSSG_REDUCED_MAX_NUM_DIRECTIONAL_LIGHTS 1

++

++ struct QSSGShaderLightData {

++     float position[3];

++     float coneAngle;

++

++     float direction[3];

++     float innerConeAngle;

++

++     float diffuseColor[3];

++     float constantAttenuation;

++

++     float specularColor[3];

++     float linearAttenuation;

++

++     quint32 lightmapState;

++     quint32 shadowPcfSamples;

++     float quadraticAttenuation;

++     float shadowTextureSize;

++

++     float shadowAtlasUV0[2];

++     float shadowAtlasUV1[2];

++

++     float shadowAtlasLayer0;

++     float shadowAtlasLayer1;

++     float shadowPcfFactor;

++     float enableShadows;

++

++     float shadowBias;

++     float shadowFactor;

++     float shadowClipNear;

++     float shadowMapFar;

++

++     float shadowMatrix[16];

++ };

++

++ struct QSSGShaderDirectionalLightData {

++     float direction[3];

++     float shadowBias;

++

++     float diffuseColor[3];

++     float shadowFactor;

++

++     float specularColor[3];

++     float enableShadows;

++

++     float matrices[4][16];

++     float dimensionsInverted[4][4];

++     float csmSplits[4];

++     float csmActive[4];

++     float atlasLocations[4][4]; // (u, v, size, layer)

++

++     quint32 lightmapState;

++     quint32 shadowPcfSamples;

++     quint32 csmNumSplits;

++     float shadowPcfFactor;

++

++     float shadowMapFar;

++     float csmBlendRatio;

++     float padding[2];

++ };

++

++ struct QSSGShaderLightsUniformData {

++     QSSGShaderLightData lightData[QSSG_MAX_NUM_LIGHTS];

++ };

++

++ struct QSSGShaderDirectionalLightsUniformData {

++     QSSGShaderDirectionalLightData directionalLightData[QSSG_MAX_NUM_DIRECTIONAL_LIGHTS];

++ };

++

++ class QSSGRhiShaderResourceBindingList;

++ class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRhiShaderPipeline

++ {

++     Q_DISABLE_COPY(QSSGRhiShaderPipeline)

++ public:

++     explicit QSSGRhiShaderPipeline(QSSGRhiContext &context) : m_context(context) { }

++

++     QSSGRhiContext &context() const { return m_context; }

++     bool isNull() const { return m_stages.isEmpty(); }

++

++     enum StageFlag {

++         // Indicates that this shaderpipeline object is not going to be used with

++         // a QSSGRhiInputAssemblerState, i.e. bakeVertexInputLocations() will

++         // not be called.

++         UsedWithoutIa = 0x01

++     };

++     Q_DECLARE_FLAGS(StageFlags, StageFlag)

++

++     void addStage(const QRhiShaderStage &stage, StageFlags flags = {});

++     const QRhiShaderStage *cbeginStages() const { return m_stages.cbegin(); }

++     const QRhiShaderStage *cendStages() const { return m_stages.cend(); }

++

++     const QRhiShaderStage *vertexStage() const {

++         for (const QRhiShaderStage &s : m_stages) {

++             if (s.type() == QRhiShaderStage::Vertex)

++                 return &s;

++         }

++         return nullptr;

++     }

++     const QRhiShaderStage *fragmentStage() const {

++         for (const QRhiShaderStage &s : m_stages) {

++             if (s.type() == QRhiShaderStage::Fragment)

++                 return &s;

++         }

++         return nullptr;

++     }

++

++     int ub0Size() const { return m_ub0Size; }

++     int ub0LightDataOffset() const { return m_ub0NextUBufOffset; }

++     int ub0DirectionalLightDataOffset() const;

++

++     const QHash<QSSGRhiInputAssemblerState::InputSemantic, QShaderDescription::InOutVariable> &vertexInputs() const { return m_vertexInputs; }

++

++     // This struct is used purely for performance. It is used to quickly store

++     // and index common uniform names using the storeIndex argument in the

++     // setUniform method.

++     struct CommonUniformIndices

++     {

++         int cameraPositionIdx = -1;

++         int cameraDirectionIdx = -1;

++         int viewProjectionMatrixIdx = -1;

++         int projectionMatrixIdx = -1;

++         int inverseProjectionMatrixIdx = -1;

++         int viewMatrixIdx = -1;

++         int modelViewProjectionIdx = -1;

++         int normalMatrixIdx = -1;

++         int modelMatrixIdx = -1;

++         int lightProbeOrientationIdx = -1;

++         int lightProbePropertiesIdx = -1;

++         int material_emissiveColorIdx = -1;

++         int material_baseColorIdx = -1;

++         int material_specularIdx = -1;

++         int cameraPropertiesIdx = -1;

++         int light_ambient_totalIdx = -1;

++         int material_propertiesIdx = -1;

++         int material_properties2Idx = -1;

++         int material_properties3Idx = -1;

++         int material_properties4Idx = -1;

++         int material_properties5Idx = -1;

++         int material_attenuationIdx = -1;

++         int thicknessFactorIdx = -1;

++         int clearcoatNormalStrengthIdx = -1;

++         int sheenColorIdx = -1;

++         int sheenRoughnessIdx = -1;

++         int anisotropyIdx = -1;

++         int iridescenceIdx = -1;

++         int dispersionIdx = -1;

++         int clearcoatFresnelPowerIdx = -1;

++         int rhiPropertiesIdx = -1;

++         int displaceAmountIdx = -1;

++         int boneTransformsIdx = -1;

++         int boneNormalTransformsIdx = -1;

++         int shadowDepthAdjustIdx = -1;

++         int pointSizeIdx = -1;

++         int morphWeightsIdx = -1;

++         int reflectionProbeCubeMapCenter = -1;

++         int reflectionProbeBoxMax = -1;

++         int reflectionProbeBoxMin = -1;

++         int reflectionProbeCorrection = -1;

++         int specularAAIdx = -1;

++         int fogColorIdx = -1;

++         int fogSunColorIdx = -1;

++         int fogDepthPropertiesIdx = -1;

++         int fogHeightPropertiesIdx = -1;

++         int fogTransmitPropertiesIdx = -1;

++         int lightAndShadowCountsIdx = -1;

++         int abufImageWidth = -1;

++         int listNodeCount = -1;

++         int viewSize = -1;

++         int samples = -1;

++

++         struct ImageIndices

++         {

++             int imageRotationsUniformIndex = -1;

++             int imageOffsetsUniformIndex = -1;

++         };

++         QVarLengthArray<ImageIndices, 16> imageIndices;

++     } commonUniformIndices;

++

++     struct InstanceLocations {

++         int transform0 = -1;

++         int transform1 = -1;

++         int transform2 = -1;

++         int color = -1;

++         int data = -1;

++     } instanceLocations;

++

++     enum class UniformFlag {

++         Mat3 = 0x01

++     };

++     Q_DECLARE_FLAGS(UniformFlags, UniformFlag)

++

++     void setUniformValue(char *ubufData, const char *name, const QVariant &value, QSSGRenderShaderValue::Type type);

++     void setUniform(char *ubufData, const char *name, const void *data, size_t size, int *storeIndex = nullptr, UniformFlags flags = {});

++     void setUniformArray(char *ubufData, const char *name, const void *data, size_t itemCount, QSSGRenderShaderValue::Type type, int *storeIndex = nullptr);

++     int bindingForTexture(const char *name, int hint = -1);

++     int bindingForStorageImage(QByteArrayView name);

++     int bindingForStorageBuffer(QByteArrayView name);

++

++     void setShaderResources(char *ubufData,

++                             QSSGBufferManager &theBufferManager,

++                             const QByteArray &inPropertyName,

++                             const QVariant &propertyValue,

++                             QSSGRenderShaderValue::Type inPropertyType);

++

++     void setLightsEnabled(bool enable) { m_lightsEnabled = enable; }

++     bool isLightingEnabled() const { return m_lightsEnabled; }

++

++     void ensureCombinedUniformBuffer(QRhiBuffer **ubuf);

++     void ensureUniformBuffer(QRhiBuffer **ubuf);

++

++     void setLightProbeTexture(QRhiTexture *texture,

++                               QSSGRenderTextureCoordOp hTile = QSSGRenderTextureCoordOp::ClampToEdge,

++                               QSSGRenderTextureCoordOp vTile = QSSGRenderTextureCoordOp::ClampToEdge)

++     {

++         m_lightProbeTexture = texture; m_lightProbeHorzTile = hTile; m_lightProbeVertTile = vTile;

++     }

++     QRhiTexture *lightProbeTexture() const { return m_lightProbeTexture; }

++     QPair<QSSGRenderTextureCoordOp, QSSGRenderTextureCoordOp> lightProbeTiling() const

++     {

++         return {m_lightProbeHorzTile, m_lightProbeVertTile};

++     }

++

++     void setScreenTexture(QRhiTexture *texture) { m_screenTexture = texture; }

++     QRhiTexture *screenTexture() const { return m_screenTexture; }

++

++     void setDepthTexture(QRhiTexture *texture) { m_depthTexture = texture; }

++     QRhiTexture *depthTexture() const { return m_depthTexture; }

++

++     void setNormalTexture(QRhiTexture *texture) { m_normalTexture = texture; }

++     QRhiTexture *normalTexture() const { return m_normalTexture; }

++

++     void setSsaoTexture(QRhiTexture *texture) { m_ssaoTexture = texture; }

++     QRhiTexture *ssaoTexture() const { return m_ssaoTexture; }

++

++     void setLightmapTexture(QRhiTexture *texture) { m_lightmapTexture = texture; }

++     QRhiTexture *lightmapTexture() const { return m_lightmapTexture; }

++

++     void setMotionVectorTexture(QRhiTexture *texture) { m_motionVectorTexture = texture; }

++     QRhiTexture *MotionVectorTexture() const { return m_motionVectorTexture; }

++     void setShadowMapAtlasTexture(QRhiTexture *texture) { m_shadowMapAtlasTexture = texture; }

++     QRhiTexture *shadowMapAtlasTexture() const { return m_shadowMapAtlasTexture; }

++

++     void setShadowMapBlueNoiseTexture(QRhiTexture *texture) { m_shadowMapBlueNoiseTexture = texture; }

++     QRhiTexture *shadowMapBlueNoiseTexture() const { return m_shadowMapBlueNoiseTexture; }

++

++     void setOITImages(QRhiTexture *accumulator, QRhiTexture *auxiliary, QRhiTexture *counter)

++     {

++         m_oitImages[0] = accumulator;

++         m_oitImages[1] = auxiliary;

++         m_oitImages[2] = counter;

++     }

++     QRhiTexture **oitImages() { return m_oitImages; }

++

++     void resetExtraTextures() { m_extraTextures.clear(); }

++     void addExtraTexture(const QSSGRhiTexture &t) { m_extraTextures.append(t); }

++     int extraTextureCount() const { return m_extraTextures.size(); }

++     const QSSGRhiTexture &extraTextureAt(int index) const { return m_extraTextures[index]; }

++     QSSGRhiTexture &extraTextureAt(int index) { return m_extraTextures[index]; }

++

++     struct StorageResourceBinding

++     {

++         int binding = 0;

++         QByteArray name;

++         QRhiShaderResourceBinding::Type type = QRhiShaderResourceBinding::BufferLoadStore;

++         QRhiBuffer *buffer = nullptr;

++         QRhiTexture *texture = nullptr;

++         StorageResourceBinding() = default;

++         StorageResourceBinding(int binding, const QByteArray &name, QRhiShaderResourceBinding::Type type, QRhiBuffer *buffer)

++             : binding(binding), name(name), type(type), buffer(buffer), texture(nullptr) {}

++         StorageResourceBinding(int binding, const QByteArray &name, QRhiShaderResourceBinding::Type type, QRhiTexture *texture)

++             : binding(binding), name(name), type(type), buffer(nullptr), texture(texture) {}

++     };

++     using StorageBindingMap = QMap<int, StorageResourceBinding>;

++

++     void addStorageBufferBinding(const QByteArray &name, QRhiShaderResourceBinding::Type type, QRhiBuffer *buffer, int binding);

++     void addStorageImageBinding(const QByteArray &name, QRhiShaderResourceBinding::Type type, QRhiTexture *texture, int binding);

++     void applyAndClearStorageBindings(QRhiShaderResourceBinding::StageFlags stage, QSSGRhiShaderResourceBindingList &bindings);

++     const StorageBindingMap &storageBufferBindings() const { return m_storageBufferBindings; }

++     const StorageBindingMap &storageImageBindings() const { return m_storageImageBindings; }

++

++     QSSGShaderLightsUniformData &lightsUniformData() { return m_lightsUniformData; }

++     QSSGShaderDirectionalLightsUniformData &directionalLightsUniformData() { return m_directionalLightsUniformData; }

++     InstanceLocations instanceBufferLocations() const { return instanceLocations; }

++

++     int offsetOfUniform(const QByteArray &name);

++

++ private:

++     QSSGRhiContext &m_context;

++     QVarLengthArray<QRhiShaderStage, 2> m_stages;

++     int m_ub0Size = 0;

++     int m_ub0NextUBufOffset = 0;

++     QHash<QByteArray, QShaderDescription::BlockVariable> m_ub0;

++     QHash<QSSGRhiInputAssemblerState::InputSemantic, QShaderDescription::InOutVariable> m_vertexInputs;

++     QHash<QByteArray, QShaderDescription::InOutVariable> m_combinedImageSamplers;

++     QHash<QByteArray, QShaderDescription::InOutVariable> m_storageImages;

++     QHash<QByteArray, QShaderDescription::StorageBlock> m_storageBuffers;

++     int m_materialImageSamplerBindings[size_t(QSSGRhiSamplerBindingHints::BindingMapSize)];

++

++     QVarLengthArray<QSSGRhiShaderUniform, 32> m_uniforms; // members of the main (binding 0) uniform buffer

++     QVarLengthArray<QSSGRhiShaderUniformArray, 8> m_uniformArrays;

++     QHash<QByteArray, size_t> m_uniformIndex; // Maps uniform name to index in m_uniforms and m_uniformArrays

++

++     // transient (per-object) data; pointers are all non-owning

++     bool m_lightsEnabled = false;

++     QSSGShaderLightsUniformData m_lightsUniformData;

++     QSSGShaderDirectionalLightsUniformData m_directionalLightsUniformData;

++     QRhiTexture *m_shadowMapAtlasTexture = nullptr;

++     QRhiTexture *m_shadowMapBlueNoiseTexture = nullptr;

++     QRhiTexture *m_lightProbeTexture = nullptr;

++     QSSGRenderTextureCoordOp m_lightProbeHorzTile = QSSGRenderTextureCoordOp::ClampToEdge;

++     QSSGRenderTextureCoordOp m_lightProbeVertTile = QSSGRenderTextureCoordOp::ClampToEdge;

++     QRhiTexture *m_screenTexture = nullptr;

++     QRhiTexture *m_depthTexture = nullptr;

++     QRhiTexture *m_normalTexture = nullptr;

++     QRhiTexture *m_ssaoTexture = nullptr;

++     QRhiTexture *m_lightmapTexture = nullptr;

++     QRhiTexture *m_oitImages[3] = {nullptr};

++     QRhiTexture *m_motionVectorTexture = nullptr;

++     QVarLengthArray<QSSGRhiTexture, 8> m_extraTextures;

++

++     QMap<int, StorageResourceBinding> m_storageImageBindings;

++     QMap<int, StorageResourceBinding> m_storageBufferBindings;

++ };

++

++ Q_DECLARE_OPERATORS_FOR_FLAGS(QSSGRhiShaderPipeline::StageFlags)

++ Q_DECLARE_OPERATORS_FOR_FLAGS(QSSGRhiShaderPipeline::UniformFlags)

++

++ using QSSGRhiShaderPipelinePtr = std::shared_ptr<QSSGRhiShaderPipeline>;

++

++ class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRhiShaderResourceBindingList

++ {

++ public:

++     static const int MAX_SIZE = 32;

++

++     int p = 0;

++     size_t h = 0;

++     QRhiShaderResourceBinding v[MAX_SIZE];

++

++     void clear() { p = 0; h = 0; }

++

++     QSSGRhiShaderResourceBindingList() { }

++

++     QSSGRhiShaderResourceBindingList(const QSSGRhiShaderResourceBindingList &other)

++         : p(other.p),

++         h(other.h)

++     {

++         for (int i = 0; i < p; ++i)

++             v[i] = other.v[i];

++     }

++

++     QSSGRhiShaderResourceBindingList &operator=(const QSSGRhiShaderResourceBindingList &other) Q_DECL_NOTHROW

++     {

++         if (this != &other) {

++             p = other.p;

++             h = other.h;

++             for (int i = 0; i < p; ++i)

++                 v[i] = other.v[i];

++         }

++         return *this;

++     }

++

++     void addUniformBuffer(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiBuffer *buf, int offset = 0 , int size = 0, bool hasDynamicOffset = false);

++     void addTexture(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiTexture *tex, QRhiSampler *sampler);

++     void addImageLoad(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiTexture *tex, int level);

++     void addImageStore(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiTexture *tex, int level);

++     void addImageLoadStore(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiTexture *tex, int level);

++     void addStorageBufferLoad(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiBuffer *buf, int offset = 0 , int size = 0);

++     void addStorageBufferStore(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiBuffer *buf, int offset = 0 , int size = 0);

++     void addStorageBufferLoadStore(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiBuffer *buf, int offset = 0 , int size = 0);

++ private:

++     void fillImage(QRhiShaderResourceBinding::Data *d, QRhiShaderResourceBinding::Type t, int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiTexture *tex, int level);

++     void fillStorageBuffer(QRhiShaderResourceBinding::Data *d, QRhiShaderResourceBinding::Type t, int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiBuffer *buf, int offset, int size);

++     QRhiShaderResourceBinding::Data *newBinding();

++ };

++

++ inline bool operator==(const QSSGRhiShaderResourceBindingList &a, const QSSGRhiShaderResourceBindingList &b) Q_DECL_NOTHROW

++ {

++     if (a.h != b.h)

++         return false;

++     if (a.p != b.p)

++         return false;

++     for (int i = 0; i < a.p; ++i) {

++         if (a.v[i] != b.v[i])

++             return false;

++     }

++     return true;

++ }

++

++ inline bool operator!=(const QSSGRhiShaderResourceBindingList &a, const QSSGRhiShaderResourceBindingList &b) Q_DECL_NOTHROW

++ {

++     return !(a == b);

++ }

++

++ inline size_t qHash(const QSSGRhiShaderResourceBindingList &bl, size_t seed) Q_DECL_NOTHROW

++ {

++     return bl.h ^ seed;

++ }

++

++ struct QSSGRhiDrawCallData

++ {

++     QRhiBuffer *ubuf = nullptr; // owned

++     QRhiShaderResourceBindings *srb = nullptr; // not owned

++     QSSGRhiShaderResourceBindingList bindings;

++     QRhiGraphicsPipeline *pipeline = nullptr; // not owned

++     size_t renderTargetDescriptionHash = 0;

++     QVector<quint32> renderTargetDescription;

++     QSSGRhiGraphicsPipelineState ps;

++

++     void reset()

++     {

++         delete ubuf;

++         ubuf = nullptr;

++         srb = nullptr;

++         pipeline = nullptr;

++     }

++ };

++

++ class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGManagedRhiTexture

++ {

++     enum class Private { Initialize };

++     Q_DISABLE_COPY(QSSGManagedRhiTexture)

++ public:

++     using Ptr = std::unique_ptr<QSSGManagedRhiTexture>;

++

++     const std::unique_ptr<QRhiTexture> &texture() const { return m_texture; }

++

++     [[nodiscard]] bool isValid() const { return m_texture != nullptr; }

++

++     QSSGManagedRhiTexture() = default;

++     QSSGManagedRhiTexture(const std::shared_ptr<QSSGUserRenderPassManager> &manager, QRhiTexture *texture, Private);

++     QSSGManagedRhiTexture(const std::shared_ptr<QSSGUserRenderPassManager> &manager, std::unique_ptr<QRhiTexture> texture);

++     ~QSSGManagedRhiTexture();

++

++     [[nodiscard]] static Ptr make_copy(const Ptr &other)

++     {

++         return std::make_unique<QSSGManagedRhiTexture>(other->m_manager, other->m_texture.get(), Private::Initialize);

++     }

++

++ private:

++     friend class QSSGRhiRenderableTextureV2;

++     friend class QSSGUserRenderPassManager;

++

++     void invalidate();

++

++     std::shared_ptr<QSSGUserRenderPassManager> m_manager;

++     std::unique_ptr<QRhiTexture> m_texture;

++ };

++

++ using QSSGManagedRhiTexturePtr = QSSGManagedRhiTexture::Ptr;

++

++ class QSSGRhiRenderableTextureV2

++ {

++     enum class Private { Initialize };

++ public:

++     QSSGRhiRenderableTextureV2(const std::shared_ptr<QSSGUserRenderPassManager> &manager, Private)

++         : m_manager(manager)

++     {

++     }

++     ~QSSGRhiRenderableTextureV2();

++

++     void setDescription(QRhi *rhi, QRhiTextureRenderTargetDescription rtDesc, QRhiTextureRenderTarget::Flags = {});

++

++     void setName(const QByteArray &name) { rtName = name; }

++     const QByteArray &getName() const { return rtName; }

++

++     const QSSGManagedRhiTexturePtr &getDepthTexture() const { return depthTexture; }

++     const std::unique_ptr<QRhiRenderBuffer> &getDepthStencil() const { return depthStencil; }

++     const std::unique_ptr<QRhiRenderPassDescriptor> &getRenderPassDescriptor() const { return rpDesc; }

++     const std::unique_ptr<QRhiTextureRenderTarget> &getRenderTarget() const { return rt; }

++

++     size_t colorAttachmentCount() const { return textures.size(); }

++     const QSSGManagedRhiTexturePtr &getColorTexture(int index) const { return textures[index]; }

++

++     bool isValid() const { return (textures.size() > 0) && rt && rpDesc; }

++

++     void finialize(QRhi *rhi);

++

++     void resetRenderTarget();

++     void reset();

++

++ private:

++     friend class QSSGUserRenderPassManager;

++

++     enum Dirty : quint32

++     {

++         ColorTextureDirty = 0x1,

++         DepthStencilDirty = 0x2,

++         DepthTextureDirty = 0x4,

++     };

++

++     void invalidate();

++

++     using DirtyT = std::underlying_type_t<Dirty>;

++

++     std::shared_ptr<QSSGUserRenderPassManager> m_manager;

++

++     QVarLengthArray<QSSGManagedRhiTexturePtr, 4> textures {};

++     std::unique_ptr<QRhiRenderBuffer> depthStencil;

++     QSSGManagedRhiTexturePtr depthTexture; // either depthStencil or depthTexture are valid, never both

++

++     std::unique_ptr<QRhiRenderPassDescriptor> rpDesc;

++     std::unique_ptr<QRhiTextureRenderTarget> rt;

++     QByteArray rtName;

++     DirtyT dirty = 0;

++ };

++

++ using QSSGRhiRenderableTextureV2Ptr = std::shared_ptr<QSSGRhiRenderableTextureV2>;

++

++ struct QSSGRhiRenderableTexture

++ {

++     QRhiTexture *texture = nullptr;

++     QRhiRenderBuffer *depthStencil = nullptr;

++     QRhiTexture *depthTexture = nullptr; // either depthStencil or depthTexture are valid, never both

++     QRhiRenderPassDescriptor *rpDesc = nullptr;

++     QRhiTextureRenderTarget *rt = nullptr;

++     bool isValid() const { return texture && rpDesc && rt; }

++     void resetRenderTarget() {

++         delete rt;

++         rt = nullptr;

++         delete rpDesc;

++         rpDesc = nullptr;

++     }

++     void reset() {

++         resetRenderTarget();

++         delete texture;

++         delete depthStencil;

++         delete depthTexture;

++         *this = QSSGRhiRenderableTexture();

++     }

++ };

++

++ struct QSSGRhiSortData

++ {

++     float d = 0.0f;

++     int indexOrOffset = -1;

++ };

++

++ struct QSSGRhiInstanceBufferData

++ {

++     QRhiBuffer *buffer = nullptr;

++     QByteArray sortedData;

++     QList<QSSGRhiSortData> sortData;

++     QVector3D sortedCameraDirection;

++     QVector3D cameraPosition;

++     QByteArray lodData;

++     int serial = -1;

++     bool owned = true;

++     bool sorting = false;

++ };

++

++ struct QSSGRhiParticleData

++ {

++     QRhiTexture *texture = nullptr;

++     QByteArray sortedData;

++     QByteArray convertData;

++     QList<QSSGRhiSortData> sortData;

++     int particleCount = 0;

++     int serial = -1;

++     bool sorting = false;

++ };

++

++ class QSSGComputePipelineStateKey

++ {

++ public:

++     QShader shader;

++     QVector<quint32> srbLayoutDescription;

++     struct {

++         size_t srbLayoutDescriptionHash;

++     } extra;

++     static QSSGComputePipelineStateKey create(const QShader &shader,

++                                               const QRhiShaderResourceBindings *srb)

++     {

++         const QVector<quint32> srbDesc = srb->serializedLayoutDescription();

++         return { shader, srbDesc, { qHash(srbDesc) } };

++     }

++ };

++

++ inline bool operator==(const QSSGComputePipelineStateKey &a, const QSSGComputePipelineStateKey &b) Q_DECL_NOTHROW

++ {

++     return a.shader == b.shader && a.srbLayoutDescription == b.srbLayoutDescription;

++ }

++

++ inline bool operator!=(const QSSGComputePipelineStateKey &a, const QSSGComputePipelineStateKey &b) Q_DECL_NOTHROW

++ {

++     return !(a == b);

++ }

++

++ inline size_t qHash(const QSSGComputePipelineStateKey &k, size_t seed = 0) Q_DECL_NOTHROW

++ {

++     return qHash(k.shader, seed) ^ k.extra.srbLayoutDescriptionHash;

++ }

++

++ struct QSSGRhiDummyTextureKey

++ {

++     QRhiTexture::Flags flags;

++     QSize size;

++     QColor color;

++     int arraySize;

++ };

++

++ inline size_t qHash(const QSSGRhiDummyTextureKey &k, size_t seed) Q_DECL_NOTHROW

++ {

++     return qHash(k.flags, seed)

++             ^ qHash(k.size.width() ^ k.size.height() ^ k.color.red() ^ k.color.green()

++                         ^ k.color.blue() ^ k.color.alpha() ^ k.arraySize);

++ }

++

++ inline bool operator==(const QSSGRhiDummyTextureKey &a, const QSSGRhiDummyTextureKey &b) Q_DECL_NOTHROW

++ {

++     return a.flags == b.flags && a.size == b.size && a.color == b.color && a.arraySize == b.arraySize;

++ }

++

++ inline bool operator!=(const QSSGRhiDummyTextureKey &a, const QSSGRhiDummyTextureKey &b) Q_DECL_NOTHROW

++ {

++     return !(a == b);

++ }

++

++ class QSSGGraphicsPipelineStateKey

++ {

++ public:

++     QSSGRhiGraphicsPipelineState state;

++     QVector<quint32> renderTargetDescription;

++     QVector<quint32> srbLayoutDescription;

++     struct {

++         size_t renderTargetDescriptionHash;

++         size_t srbLayoutDescriptionHash;

++     } extra;

++     static QSSGGraphicsPipelineStateKey create(const QSSGRhiGraphicsPipelineState &state,

++                                                const QRhiRenderPassDescriptor *rpDesc,

++                                                const QRhiShaderResourceBindings *srb)

++     {

++         const QVector<quint32> rtDesc = rpDesc->serializedFormat();

++         const QVector<quint32> srbDesc = srb->serializedLayoutDescription();

++         return { state, rtDesc, srbDesc, { qHash(rtDesc), qHash(srbDesc) } };

++     }

++ };

++

++ inline bool operator==(const QSSGGraphicsPipelineStateKey &a, const QSSGGraphicsPipelineStateKey &b) Q_DECL_NOTHROW

++ {

++     return a.state == b.state

++         && a.renderTargetDescription == b.renderTargetDescription

++         && a.srbLayoutDescription == b.srbLayoutDescription;

++ }

++

++ inline bool operator!=(const QSSGGraphicsPipelineStateKey &a, const QSSGGraphicsPipelineStateKey &b) Q_DECL_NOTHROW

++ {

++     return !(a == b);

++ }

++

++ inline size_t qHash(const QSSGGraphicsPipelineStateKey &k, size_t seed) Q_DECL_NOTHROW

++ {

++     return qHash(k.state, seed)

++         ^ k.extra.renderTargetDescriptionHash

++         ^ k.extra.srbLayoutDescriptionHash;

++ }

++

++ #define QSSGRHICTX_STAT(ctx, f) \

++     for (bool qssgrhictxlog_enabled = QSSGRhiContextStats::get(*ctx).isEnabled(); qssgrhictxlog_enabled; qssgrhictxlog_enabled = false) \

++         QSSGRhiContextStats::get(*ctx).f

++

++ class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRhiContextStats

++ {

++ public:

++     [[nodiscard]] static QSSGRhiContextStats &get(QSSGRhiContext &rhiCtx);

++     [[nodiscard]] static const QSSGRhiContextStats &get(const QSSGRhiContext &rhiCtx);

++

++     struct DrawInfo {

++         quint64 callCount = 0;

++         quint64 vertexOrIndexCount = 0;

++     };

++     struct InstancedDrawInfo {

++         quint64 callCount = 0;

++         quint64 vertexOrIndexCount = 0;

++         quint64 instanceCount = 0;

++     };

++     struct RenderPassInfo {

++         QByteArray rtName;

++         QSize pixelSize;

++         DrawInfo indexedDraws;

++         DrawInfo draws;

++         InstancedDrawInfo instancedIndexedDraws;

++         InstancedDrawInfo instancedDraws;

++     };

++     struct PerLayerInfo {

++         PerLayerInfo()

++         {

++             externalRenderPass.rtName = QByteArrayLiteral("Qt Quick");

++         }

++

++         // The main render pass if renderMode==Offscreen, plus render passes

++         // for shadow maps, postprocessing effects, etc.

++         QVector<RenderPassInfo> renderPasses;

++

++         // An Underlay/Overlay/Inline renderMode will make the View3D add stuff

++         // to a render pass managed by Qt Quick. (external == not under the

++         // control of Qt Quick 3D)

++         RenderPassInfo externalRenderPass;

++

++         int currentRenderPassIndex = -1;

++     };

++     struct GlobalInfo { // global as in per QSSGRhiContext which is per-QQuickWindow

++         quint64 meshDataSize = 0;

++         quint64 imageDataSize = 0;

++         qint64 materialGenerationTime = 0;

++         qint64 effectGenerationTime = 0;

++     };

++

++     QHash<QSSGRenderLayer *, PerLayerInfo> perLayerInfo;

++     GlobalInfo globalInfo;

++

++     QSSGRhiContextStats(QSSGRhiContext &context)

++         : rhiCtx(&context)

++     {

++     }

++

++     // The data collected have four consumers:

++     //

++     // - Printed on debug output when QSG_RENDERER_DEBUG has the relevant key.

++     //   (this way the debug output from the 2D scenegraph renderer and these 3D

++     //   statistics appear nicely intermixed)

++     // - Passed on to the QML profiler when profiling is enabled.

++     // - DebugView via QQuick3DRenderStats.

++     // - When tracing is enabled

++     //

++     // The first two are enabled globally, but DebugView needs a dynamic

++     // enable/disable since we want to collect data when a DebugView item

++     // becomes visible, but not otherwise.

++

++     static bool profilingEnabled();

++     static bool rendererDebugEnabled();

++

++     bool isEnabled() const;

++     void drawIndexed(quint32 indexCount, quint32 instanceCount);

++     void draw(quint32 vertexCount, quint32 instanceCount);

++

++     void meshDataSizeChanges(quint64 newSize) // can be called outside start-stop

++     {

++         globalInfo.meshDataSize = newSize;

++     }

++

++     void imageDataSizeChanges(quint64 newSize) // can be called outside start-stop

++     {

++         globalInfo.imageDataSize = newSize;

++     }

++

++     void registerMaterialShaderGenerationTime(qint64 ms)

++     {

++         globalInfo.materialGenerationTime += ms;

++     }

++

++     void registerEffectShaderGenerationTime(qint64 ms)

++     {

++         globalInfo.effectGenerationTime += ms;

++     }

++

++     static quint64 totalDrawCallCountForPass(const QSSGRhiContextStats::RenderPassInfo &pass)

++     {

++         return pass.draws.callCount

++                 + pass.indexedDraws.callCount

++                 + pass.instancedDraws.callCount

++                 + pass.instancedIndexedDraws.callCount;

++     }

++

++     static quint64 totalVertexCountForPass(const QSSGRhiContextStats::RenderPassInfo &pass)

++     {

++         return pass.draws.vertexOrIndexCount

++                 + pass.indexedDraws.vertexOrIndexCount

++                 + pass.instancedDraws.vertexOrIndexCount

++                 + pass.instancedIndexedDraws.vertexOrIndexCount;

++     }

++

++     void start(QSSGRenderLayer *layer);

++     void stop(QSSGRenderLayer *layer);

++     void beginRenderPass(QRhiTextureRenderTarget *rt);

++     void endRenderPass();

++     void printRenderPass(const RenderPassInfo &rp);

++     void cleanupLayerInfo(QSSGRenderLayer *layer);

++

++     QSSGRhiContext *rhiCtx;

++     QSSGRenderLayer *layerKey = nullptr;

++     QSet<QSSGRenderLayer *> dynamicDataSources;

++ };

++

++ class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRhiContextPrivate

++ {

++     Q_DECLARE_PUBLIC(QSSGRhiContext)

++

++     explicit QSSGRhiContextPrivate(QSSGRhiContext &rhiCtx, QRhi *rhi_)

++         : q_ptr(&rhiCtx)

++         , m_rhi(rhi_)

++         , m_stats(rhiCtx)

++     {}

++

++ public:

++     using Textures = QSet<QRhiTexture *>;

++     using Meshes = QSet<QSSGRenderMesh *>;

++

++     [[nodiscard]] static QSSGRhiContextPrivate *get(QSSGRhiContext *q) { return q->d_ptr.get(); }

++     [[nodiscard]] static const QSSGRhiContextPrivate *get(const QSSGRhiContext *q) { return q->d_ptr.get(); }

++

++     [[nodiscard]] static bool shaderDebuggingEnabled();

++     [[nodiscard]] static bool editorMode();

++

++     void setMainRenderPassDescriptor(QRhiRenderPassDescriptor *rpDesc);

++     void setCommandBuffer(QRhiCommandBuffer *cb);

++     void setRenderTarget(QRhiRenderTarget *rt);

++     void setMainPassSampleCount(int samples);

++     void setMainPassViewCount(int viewCount);

++

++     void releaseCachedResources();

++

++     void registerTexture(QRhiTexture *texture);

++     void releaseTexture(QRhiTexture *texture);

++

++     void registerMesh(QSSGRenderMesh *mesh);

++     void releaseMesh(QSSGRenderMesh *mesh);

++

++     QRhiShaderResourceBindings *srb(const QSSGRhiShaderResourceBindingList &bindings);

++     void releaseCachedSrb(QSSGRhiShaderResourceBindingList &bindings);

++

++     QRhiGraphicsPipeline *pipeline(const QSSGRhiGraphicsPipelineState &ps,

++                                    QRhiRenderPassDescriptor *rpDesc,

++                                    QRhiShaderResourceBindings *srb);

++

++     QRhiGraphicsPipeline *pipeline(const QSSGGraphicsPipelineStateKey &key,

++                                    QRhiRenderPassDescriptor *rpDesc,

++                                    QRhiShaderResourceBindings *srb);

++

++     QRhiComputePipeline *computePipeline(const QShader &shader,

++                                          QRhiShaderResourceBindings *srb);

++

++     QRhiComputePipeline *computePipeline(const QSSGComputePipelineStateKey &key,

++                                          QRhiShaderResourceBindings *srb);

++

++     QSSGRhiDrawCallData &drawCallData(const QSSGRhiDrawCallDataKey &key);

++     void releaseDrawCallData(QSSGRhiDrawCallData &dcd);

++     void cleanupDrawCallData(const QSSGRenderModel *model);

++     void cleanupDrawCallDataForResource(const void *resource);

++     void cleanupDrawCallDataForCid(const void *cid);

++     void cleanupDrawCallDataForSkyMaterial(QSSGRenderSkyMaterial *skyMaterial);

++

++     QSSGRhiInstanceBufferData &instanceBufferData(QSSGRenderInstanceTable *instanceTable);

++     void releaseInstanceBuffer(QSSGRenderInstanceTable *instanceTable);

++

++     QSSGRhiInstanceBufferData &instanceBufferData(const QSSGRenderModel *model);

++

++     QSSGRhiParticleData &particleData(const QSSGRenderGraphObject *particlesOrModel);

++

++     QSSGRhiContext *q_ptr = nullptr;

++     QRhi *m_rhi = nullptr;

++

++     QRhiRenderPassDescriptor *m_mainRpDesc = nullptr;

++     QRhiCommandBuffer *m_cb = nullptr;

++     QRhiRenderTarget *m_rt = nullptr;

++     Textures m_textures;

++     Meshes m_meshes;

++     int m_mainSamples = 1;

++     int m_mainViewCount = 1;

++

++     QVector<QPair<QSSGRhiSamplerDescription, QRhiSampler*>> m_samplers;

++

++     QHash<QSSGRhiDrawCallDataKey, QSSGRhiDrawCallData> m_drawCallData;

++     QHash<QSSGRhiShaderResourceBindingList, QRhiShaderResourceBindings *> m_srbCache;

++     QHash<QSSGGraphicsPipelineStateKey, QRhiGraphicsPipeline *> m_pipelines;

++     QHash<QSSGComputePipelineStateKey, QRhiComputePipeline *> m_computePipelines;

++     QHash<QSSGRhiDummyTextureKey, QRhiTexture *> m_dummyTextures;

++     QHash<QSSGRenderInstanceTable *, QSSGRhiInstanceBufferData> m_instanceBuffers;

++     QHash<const QSSGRenderModel *, QSSGRhiInstanceBufferData> m_instanceBuffersLod;

++     QHash<const QSSGRenderGraphObject *, QSSGRhiParticleData> m_particleData;

++     QSSGRhiContextStats m_stats;

++ };

++

++ inline bool operator==(const QSSGRhiDrawCallDataKey &a, const QSSGRhiDrawCallDataKey &b) noexcept

++ {

++     return a.cid == b.cid && a.model == b.model && a.resource == b.resource && a.mapEntry == b.mapEntry

++             && a.resourceIdx == b.resourceIdx;

++ }

++

++ inline bool operator!=(const QSSGRhiDrawCallDataKey &a, const QSSGRhiDrawCallDataKey &b) noexcept

++ {

++     return !(a == b);

++ }

++

++ inline size_t qHash(const QSSGRhiDrawCallDataKey &k, size_t seed = 0) noexcept

++ {

++     return qHashMulti(seed, k.cid, k.model, k.resource, k.mapEntry, k.resourceIdx);

++ }

++

++ QT_END_NAMESPACE

++

++ #endif // QSSGRHICONTEXT_P_H

Revision control