qssgrhicustommaterialsystem.cpp

// Copyright (C) 2008-2012 NVIDIA Corporation.

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

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

// Qt-Security score:significant reason:default

#include "qssgrhicustommaterialsystem_p.h"

#include <QtQuick3DUtils/private/qssgutils_p.h>

#include "qssgrendercontextcore.h"

#include <QtQuick3DRuntimeRender/private/qssgrenderbuffermanager_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrendermesh_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrendercamera_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrenderlight_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrenderlayer_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrenderableimage_p.h>

#include <QtQuick3DRuntimeRender/private/qssgvertexpipelineimpl_p.h>

#include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrendermodel_p.h>

#include <QtQuick3DRuntimeRender/private/qssgruntimerenderlogging_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrhiparticles_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrenderhelpers_p.h>

#include <qtquick3d_tracepoints_p.h>

#include <QtCore/qbitarray.h>

QT_BEGIN_NAMESPACE

Q_TRACE_POINT(qtquick3d, QSSG_generateShader_entry)

Q_TRACE_POINT(qtquick3d, QSSG_generateShader_exit)

QSSGCustomMaterialSystem::QSSGCustomMaterialSystem() = default;

QSSGCustomMaterialSystem::~QSSGCustomMaterialSystem()

bool QSSGCustomMaterialSystem::prepareForRender(const QSSGRenderModel &,

                                          const QSSGRenderSubset &,

                                          QSSGRenderCustomMaterial &inMaterial)

    return inMaterial.isDirty();

void QSSGCustomMaterialSystem::setRenderContextInterface(QSSGRenderContextInterface *inContext)

    context = inContext;

void QSSGCustomMaterialSystem::releaseCachedResources()

    shaderMap.clear();

QSSGRhiShaderPipelinePtr QSSGCustomMaterialSystem::shadersForCustomMaterial(QSSGRhiGraphicsPipelineState *ps,

                                                                            const QSSGRenderCustomMaterial &material,

                                                                            QSSGSubsetRenderable &renderable,

                                                                            const QSSGShaderDefaultMaterialKeyProperties &defaultMaterialShaderKeyProperties,

                                                                            const QSSGShaderFeatures &featureSet,

                                                                            const QSSGUserShaderAugmentation &shaderAugmentation)

    QElapsedTimer timer;

    timer.start();

    QSSGRhiShaderPipelinePtr shaderPipeline;

    const bool multiView = featureSet.isSet(QSSGShaderFeatures::Feature::DisableMultiView)

        ? false

        : defaultMaterialShaderKeyProperties.m_viewCount.getValue(renderable.shaderDescription) >= 2;

    const QByteArray &baseShaderPathKey = material.m_shaderPathKey[multiView ? QSSGRenderCustomMaterial::MultiViewShaderPathKeyIndex

                                                                             : QSSGRenderCustomMaterial::RegularShaderPathKeyIndex];

    const QByteArray shaderPathKey = shaderAugmentation.hasUserAugmentation()

            ? baseShaderPathKey + ':' + shaderAugmentation.hash

            : baseShaderPathKey;

    // This just references inFeatureSet and inRenderable.shaderDescription -

    // cheap to construct and is good enough for the find(). This is the first

    // level, fast lookup. (equivalent to what

    // QSSGRenderer::getShaderPipelineForDefaultMaterial does for the

    // default/principled material)

    QSSGShaderMapKey skey = QSSGShaderMapKey(shaderPathKey,

                                             featureSet,

                                             renderable.shaderDescription);

    auto it = shaderMap.find(skey);

    if (it == shaderMap.end()) {

        // This is also passed to generateMaterialRhiShader() so that newly

        // generated shaders get stored in the caches under the same key.

        QByteArray shaderString = shaderPathKey;

        QSSGShaderDefaultMaterialKey matKey(renderable.shaderDescription);

        matKey.toString(shaderString, defaultMaterialShaderKeyProperties);

        for (const auto &def : shaderAugmentation.defines)

            shaderString.append(def.name).append(';').append(def.value).append(';');

        // Try the persistent (disk-based) cache.

        const QByteArray qsbcKey = QQsbCollection::EntryDesc::generateSha(shaderString, QQsbCollection::toFeatureSet(featureSet));

        shaderPipeline = context->shaderCache()->tryNewPipelineFromPersistentCache(qsbcKey, shaderString, featureSet);

        if (!shaderPipeline) {

            // Have to generate the shaders and send it all through the shader conditioning pipeline.

            Q_TRACE_SCOPE(QSSG_generateShader);

            Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DGenerateShader);

            QSSGMaterialVertexPipeline vertexPipeline(*context->shaderProgramGenerator(),

                                                      defaultMaterialShaderKeyProperties,

                                                      material.adapter);

            shaderPipeline = QSSGMaterialShaderGenerator::generateMaterialRhiShader(shaderPathKey,

                                                                                    shaderString,

                                                                                    vertexPipeline,

                                                                                    renderable.shaderDescription,

                                                                                    defaultMaterialShaderKeyProperties,

                                                                                    featureSet,

                                                                                    material,

                                                                                    *context->shaderLibraryManager(),

                                                                                    *context->shaderCache(),

                                                                                    shaderAugmentation);

            Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DGenerateShader, 0, material.profilingId);

        // make skey useable as a key for the QHash (makes a copy of the materialKey, instead of just referencing)

        skey.detach();

        // insert it no matter what, no point in trying over and over again

        shaderMap.insert(skey, shaderPipeline);

    } else {

        shaderPipeline = it.value();

    if (shaderPipeline) {

        QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(*ps, shaderPipeline.get());

        shaderPipeline->resetExtraTextures();

    QSSGRhiContextStats::get(*context->rhiContext()).registerMaterialShaderGenerationTime(timer.elapsed());

    return shaderPipeline;

void QSSGCustomMaterialSystem::updateUniformsForCustomMaterial(QSSGRhiShaderPipeline &shaderPipeline,

                                                               QSSGRhiContext *rhiCtx,

                                                               const QSSGLayerRenderData &inData,

                                                               char *ubufData,

                                                               QSSGRhiGraphicsPipelineState *ps,

                                                               const QSSGRenderCustomMaterial &material,

                                                               QSSGSubsetRenderable &renderable,

                                                               const QSSGRenderCameraList &cameras,

                                                               const QVector2D *depthAdjust,

                                                               const QMatrix4x4 *alteredModelViewProjection)

    QSSGRenderMvpArray alteredMvpList;

    if (alteredModelViewProjection)

        alteredMvpList[0] = *alteredModelViewProjection;

    const QMatrix4x4 clipSpaceCorrMatrix = rhiCtx->rhi()->clipSpaceCorrMatrix();

    QRhiTexture *lightmapTexture = inData.getLightmapTexture(renderable.modelContext);

    const auto &modelNode = renderable.modelContext.model;

    const auto &[localInstanceTransform, globalInstanceTransform] = inData.getInstanceTransforms(modelNode);

    const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable();

    const QMatrix4x4 &modelMatrix(modelNode.usesBoneTexture() ? QMatrix4x4() : renderable.modelContext.globalTransform);

    QSSGMaterialShaderGenerator::setRhiMaterialProperties(*context,

                                                          shaderPipeline,

                                                          ubufData,

ps,

                                                          material,

                                                          renderable.shaderDescription,

                                                          defaultMaterialShaderKeyProperties,

                                                          cameras,

                                                          alteredModelViewProjection ? alteredMvpList : renderable.modelContext.modelViewProjections,

                                                          renderable.modelContext.normalMatrix,

                                                          modelMatrix,

                                                          clipSpaceCorrMatrix,

                                                          localInstanceTransform,

                                                          globalInstanceTransform,

                                                          toDataView(modelNode.morphWeights),

                                                          renderable.firstImage,

                                                          renderable.opacity,

                                                          inData,

                                                          renderable.lights,

                                                          renderable.reflectionProbe,

                                                          true,

                                                          renderable.renderableFlags.receivesReflections(),

                                                          depthAdjust,

                                                          lightmapTexture);

static const QRhiShaderResourceBinding::StageFlags CUSTOM_MATERIAL_VISIBILITY_ALL =

        QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage;

void QSSGCustomMaterialSystem::rhiPrepareRenderable(QSSGRhiGraphicsPipelineState *ps,

                                                    QSSGPassKey passKey,

                                                    QSSGSubsetRenderable &renderable,

                                                    const QSSGShaderFeatures &featureSet,

                                                    const QSSGRenderCustomMaterial &material,

                                                    const QSSGLayerRenderData &layerData,

                                                    QRhiRenderPassDescriptor *renderPassDescriptor,

                                                    int samples,

                                                    int viewCount,

                                                    bool screenMapPass,

                                                    QSSGRenderCamera *alteredCamera,

                                                    QSSGRenderTextureCubeFace cubeFace,

                                                    QMatrix4x4 *alteredModelViewProjection,

                                                    QSSGReflectionMapEntry *entry,

                                                    bool oit)

    QSSGRhiContext *rhiCtx = context->rhiContext().get();

    QRhiGraphicsPipeline::TargetBlend blend; // no blending by default

    if (material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Blending)) {

        blend.enable = true;

        blend.srcColor = material.m_srcBlend;

        blend.srcAlpha = material.m_srcAlphaBlend;

        blend.dstColor = material.m_dstBlend;

        blend.dstAlpha = material.m_dstAlphaBlend;

    const QSSGCullFaceMode cullMode = material.m_cullMode;

    const auto &defaultMaterialShaderKeyProperties = layerData.getDefaultMaterialPropertyTable();

    const bool blendParticles = defaultMaterialShaderKeyProperties.m_blendParticles.getValue(renderable.shaderDescription);

    const auto &shaderPipeline = shadersForCustomMaterial(ps, material, renderable, defaultMaterialShaderKeyProperties, featureSet);

    if (shaderPipeline) {

        QSSGRhiShaderResourceBindingList bindings;

        const auto &modelNode = renderable.modelContext.model;

        // NOTE:

        // - entryIdx should 0 for QSSGRenderTextureCubeFaceNone (and a null entry).

        // In all other cases the entryIdx is a combination of the cubeface idx and the subset

        // offset, where the lower bits are the cubeface idx. The per-probe reflection map

        // entry, if any, goes in the key's mapEntry slot. The key's resource must be the

        // material itself, and nothing but the material, since

        // cleanupDrawCallDataForResource() releases the entries for a to-be-destroyed

        // material by matching on the resource.

        const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);

        const quintptr entryIdx = quintptr(cubeFace != QSSGRenderTextureCubeFaceNone)

                * (cubeFaceIdx + (quintptr(renderable.subset.offset) << 3));

        // cleanupDrawCallDataForResource() is handed a QSSGRenderGraphObject pointer, so

        // that is the identity the key has to carry.

        const auto *materialResource = static_cast<const QSSGRenderGraphObject *>(&material);

        QSSGRhiDrawCallData &dcd = QSSGRhiContextPrivate::get(rhiCtx)->drawCallData({ passKey, &modelNode,

                                                                                      materialResource, entry,

                                                                                      entryIdx });

        shaderPipeline->ensureCombinedUniformBuffer(&dcd.ubuf);

        char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();

        if (!alteredCamera) {

            updateUniformsForCustomMaterial(*shaderPipeline, rhiCtx, layerData, ubufData, ps, material, renderable, layerData.renderedCameras, nullptr, nullptr);

        } else {

            QSSGRenderCameraList cameras({ alteredCamera });

            updateUniformsForCustomMaterial(*shaderPipeline, rhiCtx, layerData, ubufData, ps, material, renderable, cameras, nullptr, alteredModelViewProjection);

        if (blendParticles)

            QSSGParticleRenderer::updateUniformsForParticleModel(*shaderPipeline, ubufData, &renderable.modelContext.model, renderable.subset.offset);

        dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();

        if (blendParticles)

            QSSGParticleRenderer::prepareParticlesForModel(*shaderPipeline, rhiCtx, bindings, &renderable.modelContext.model);

        bool instancing = false;

        if (!alteredCamera) {

            const QSSGRenderCameraDataList &cameraDatas(*layerData.renderedCameraData);

            instancing = QSSGLayerRenderData::prepareInstancing(rhiCtx, &renderable, cameraDatas[0].direction, cameraDatas[0].position, renderable.instancingLodMin, renderable.instancingLodMax);

        } else {

            const auto &altCamTransform = layerData.getGlobalTransform(*alteredCamera);

            instancing = QSSGLayerRenderData::prepareInstancing(rhiCtx, &renderable, QSSGRenderNode::getScalingCorrectDirection(altCamTransform), QSSGRenderNode::getGlobalPos(altCamTransform), renderable.instancingLodMin, renderable.instancingLodMax);

        ps->samples = samples;

        ps->viewCount = viewCount;

        ps->cullMode = QSSGRhiHelpers::toCullMode(cullMode);

        if (!oit)

            ps->targetBlend[0] = blend;

        auto &ia = QSSGRhiInputAssemblerStatePrivate::get(*ps);

        ia = renderable.subset.rhi.ia;

        //### Copied code from default materials

        int instanceBufferBinding = 0;

        if (instancing) {

            // Need to setup new bindings for instanced buffers

            const quint32 stride = renderable.modelContext.model.instanceTable->stride();

            QVarLengthArray<QRhiVertexInputBinding, 8> bindings;

            std::copy(ia.inputLayout.cbeginBindings(),

                      ia.inputLayout.cendBindings(),

                      std::back_inserter(bindings));

            bindings.append({ stride, QRhiVertexInputBinding::PerInstance });

            instanceBufferBinding = bindings.size() - 1;

            ia.inputLayout.setBindings(bindings.cbegin(), bindings.cend());

        QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);

        QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();

        QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);

        QRhiTexture *dummyTextureArray = rhiCtx->dummyTexture({}, resourceUpdates, QSize(64, 64), Qt::black, qMax(2, viewCount));

        QRhiTexture *dummyTexture3D = rhiCtx->dummyTexture(QRhiTexture::ThreeDimensional, resourceUpdates);

        QRhiTexture *dummyCubeTexture = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates);

        QRhiTexture *dummyCubeTextureArray = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates, QSize(64, 64), Qt::black, qMax(2, viewCount));

        rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);

        bindings.addUniformBuffer(0, CUSTOM_MATERIAL_VISIBILITY_ALL, dcd.ubuf, 0, shaderPipeline->ub0Size());

        bindings.addUniformBuffer(1, CUSTOM_MATERIAL_VISIBILITY_ALL, dcd.ubuf, shaderPipeline->ub0LightDataOffset(), sizeof(QSSGShaderLightsUniformData));

        bindings.addUniformBuffer(2, CUSTOM_MATERIAL_VISIBILITY_ALL, dcd.ubuf, shaderPipeline->ub0DirectionalLightDataOffset(), sizeof(QSSGShaderDirectionalLightsUniformData));

        QVector<QShaderDescription::InOutVariable> samplerVars =

                shaderPipeline->fragmentStage()->shader().description().combinedImageSamplers();

        const auto combinedSamplers = shaderPipeline->vertexStage()->shader().description().combinedImageSamplers();

        for (const QShaderDescription::InOutVariable &var : combinedSamplers) {

            auto it = std::find_if(samplerVars.cbegin(), samplerVars.cend(),

                                   [&var](const QShaderDescription::InOutVariable &v) { return var.binding == v.binding; });

            if (it == samplerVars.cend())

                samplerVars.append(var);

        int maxSamplerBinding = -1;

        for (const QShaderDescription::InOutVariable &var : std::as_const(samplerVars))

            maxSamplerBinding = qMax(maxSamplerBinding, var.binding);

        // Will need to set unused image-samplers to something dummy

        // because the shader code contains all custom property textures,

        // and not providing a binding for all of them is invalid with some

        // graphics APIs (and will need a real texture because setting a

        // null handle or similar is not permitted with some of them so the

        // srb does not accept null QRhiTextures either; but first let's

        // figure out what bindings are unused in this frame)

        QBitArray samplerBindingsSpecified(maxSamplerBinding + 1);

        if (blendParticles)

            samplerBindingsSpecified.setBit(shaderPipeline->bindingForTexture("qt_particleTexture"));

        // Skinning

        if (QRhiTexture *boneTexture = layerData.getBonemapTexture(renderable.modelContext)) {

            int binding = shaderPipeline->bindingForTexture("qt_boneTexture");

            if (binding >= 0) {

                QRhiSampler *boneSampler = rhiCtx->sampler({ QRhiSampler::Nearest,

                                                             QRhiSampler::Nearest,

                                                             QRhiSampler::None,

                                                             QRhiSampler::ClampToEdge,

                                                             QRhiSampler::ClampToEdge,

                                                             QRhiSampler::Repeat

});

                bindings.addTexture(binding,

                                    QRhiShaderResourceBinding::VertexStage,

                                    boneTexture,

                                    boneSampler);

                samplerBindingsSpecified.setBit(binding);

        // Morphing

        auto *targetsTexture = renderable.subset.rhi.targetsTexture;

        if (targetsTexture) {

            int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");

            if (binding >= 0) {

                QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,

                                                                QRhiSampler::Nearest,

                                                                QRhiSampler::None,

                                                                QRhiSampler::ClampToEdge,

                                                                QRhiSampler::ClampToEdge,

                                                                QRhiSampler::ClampToEdge

});

                bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, renderable.subset.rhi.targetsTexture, targetsSampler);

                samplerBindingsSpecified.setBit(binding);

        // Prioritize reflection texture over Light Probe texture because

        // reflection texture also contains the irradiance and pre filtered

        // values for the light probe.

        if (featureSet.isSet(QSSGShaderFeatures::Feature::ReflectionProbe)) {

            int reflectionSampler = shaderPipeline->bindingForTexture("qt_reflectionMap");

            QRhiTexture* reflectionTexture = layerData.getReflectionMapManager()->reflectionMapEntry(renderable.reflectionProbeIndex)->m_rhiPrefilteredCube;

            const auto mipMapFilter = reflectionTexture && reflectionTexture->flags().testFlag(QRhiTexture::Flag::MipMapped)

                    ? QRhiSampler::Linear

                    : QRhiSampler::None;

            QRhiSampler *sampler = rhiCtx->sampler(

                    { QRhiSampler::Linear, QRhiSampler::Linear, mipMapFilter, QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

            if (reflectionSampler >= 0 && reflectionTexture) {

                bindings.addTexture(reflectionSampler, QRhiShaderResourceBinding::FragmentStage, reflectionTexture, sampler);

                samplerBindingsSpecified.setBit(reflectionSampler);

        if (int binding = shaderPipeline->bindingForTexture("qt_lightProbe", int(QSSGRhiSamplerBindingHints::LightProbe));

            binding >= 0) {

            auto texture = shaderPipeline->lightProbeTexture();

            if (!texture)

                texture = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates);

            Q_ASSERT(texture);

            samplerBindingsSpecified.setBit(binding);

            QPair<QSSGRenderTextureCoordOp, QSSGRenderTextureCoordOp> tiling = shaderPipeline->lightProbeTiling();

            QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,

                                                     QRhiSampler::Linear,

                                                     QRhiSampler::Linear, // enables mipmapping

                                                     QSSGRhiHelpers::toRhi(tiling.first),

                                                     QSSGRhiHelpers::toRhi(tiling.second),

                                                     QRhiSampler::Repeat });

            bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);

        if (shaderPipeline->screenTexture()) {

            const int screenTextureBinding = shaderPipeline->bindingForTexture("qt_screenTexture", int(QSSGRhiSamplerBindingHints::ScreenTexture));

            const int screenTextureArrayBinding = shaderPipeline->bindingForTexture("qt_screenTextureArray", int(QSSGRhiSamplerBindingHints::ScreenTextureArray));

            if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) {

                QRhiTexture *screenTexture = shaderPipeline->screenTexture();

                // If we're called as part of the screen map pass there's obviously no screen texture available, but the shader may still expect it, so bind a dummy texture.

                if (screenMapPass) {

                    QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();

                    // Just mirror what is set up by the ScreenMap pass.

                    const QRhiTexture::Flags flags = screenTexture->flags();

                    // and set the dummy texture so there's something for the shader to sample.

                    screenTexture = rhiCtx->dummyTexture(flags, resourceUpdates);

                    rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);

                // linear min/mag, mipmap filtering depends on the

                // texture, with SCREEN_TEXTURE there are no mipmaps, but

                // once SCREEN_MIP_TEXTURE is seen the texture (the same

                // one) has mipmaps generated.

                QRhiSampler::Filter mipFilter = shaderPipeline->screenTexture()->flags().testFlag(QRhiTexture::MipMapped)

                        ? QRhiSampler::Linear : QRhiSampler::None;

                QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, mipFilter,

                                                         QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });

                if (screenTextureBinding >= 0) {

                    samplerBindingsSpecified.setBit(screenTextureBinding);

                    bindings.addTexture(screenTextureBinding,

                                        QRhiShaderResourceBinding::FragmentStage,

                                        screenTexture, sampler);

                if (screenTextureArrayBinding >= 0) {

                    samplerBindingsSpecified.setBit(screenTextureArrayBinding);

                    bindings.addTexture(screenTextureArrayBinding,

                                        QRhiShaderResourceBinding::FragmentStage,

                                        screenTexture, sampler);

            } // else ignore, not an error

        if (shaderPipeline->depthTexture()) {

            const int depthTextureBinding = shaderPipeline->bindingForTexture("qt_depthTexture", int(QSSGRhiSamplerBindingHints::DepthTexture));

            const int depthTextureArrayBinding = shaderPipeline->bindingForTexture("qt_depthTextureArray", int(QSSGRhiSamplerBindingHints::DepthTextureArray));

            if (depthTextureBinding >= 0 || depthTextureArrayBinding >= 0) {

                // nearest min/mag, no mipmap

                QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,

                                                         QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

                if (depthTextureBinding >= 0) {

                    samplerBindingsSpecified.setBit(depthTextureBinding);

                    bindings.addTexture(depthTextureBinding,

                                        CUSTOM_MATERIAL_VISIBILITY_ALL,

                                        shaderPipeline->depthTexture(), sampler);

                if (depthTextureArrayBinding >= 0) {

                    samplerBindingsSpecified.setBit(depthTextureArrayBinding);

                    bindings.addTexture(depthTextureArrayBinding,

                                        CUSTOM_MATERIAL_VISIBILITY_ALL,

                                        shaderPipeline->depthTexture(), sampler);

            } // else ignore, not an error

        if (shaderPipeline->normalTexture()) {

            const int normalTextureBinding = shaderPipeline->bindingForTexture("qt_normalTexture", int(QSSGRhiSamplerBindingHints::NormalTexture));

            if (normalTextureBinding >= 0) {

                // nearest min/mag, no mipmap

                QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,

                                                         QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

                samplerBindingsSpecified.setBit(normalTextureBinding);

                bindings.addTexture(normalTextureBinding, CUSTOM_MATERIAL_VISIBILITY_ALL, shaderPipeline->normalTexture(), sampler);

            } // else ignore, not an error

        if (shaderPipeline->ssaoTexture()) {

            const int ssaoTextureBinding = shaderPipeline->bindingForTexture("qt_aoTexture", int(QSSGRhiSamplerBindingHints::AoTexture));

            const int ssaoTextureArrayBinding = shaderPipeline->bindingForTexture("qt_aoTextureArray", int(QSSGRhiSamplerBindingHints::AoTextureArray));

            if (ssaoTextureBinding >= 0 || ssaoTextureArrayBinding >= 0) {

                // linear min/mag, no mipmap

                QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,

                                                         QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

                if (ssaoTextureBinding >= 0) {

                    samplerBindingsSpecified.setBit(ssaoTextureBinding);

                    bindings.addTexture(ssaoTextureBinding,

                                        QRhiShaderResourceBinding::FragmentStage,

                                        shaderPipeline->ssaoTexture(), sampler);

                if (ssaoTextureArrayBinding >= 0) {

                    samplerBindingsSpecified.setBit(ssaoTextureArrayBinding);

                    bindings.addTexture(ssaoTextureArrayBinding,

                                        QRhiShaderResourceBinding::FragmentStage,

                                        shaderPipeline->ssaoTexture(), sampler);

            } // else ignore, not an error

        if (shaderPipeline->lightmapTexture()) {

            int binding = shaderPipeline->bindingForTexture("qt_lightmap", int(QSSGRhiSamplerBindingHints::LightmapTexture));

            if (binding >= 0) {

                samplerBindingsSpecified.setBit(binding);

                QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,

                                                         QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

                bindings.addTexture(binding,

                                    QRhiShaderResourceBinding::FragmentStage,

                                    shaderPipeline->lightmapTexture(), sampler);

            } // else ignore, not an error

        if (shaderPipeline->MotionVectorTexture()) {

            int binding = shaderPipeline->bindingForTexture("qt_motionVectorTexture", int(QSSGRhiSamplerBindingHints::MotionVectorTexture));

            if (binding >= 0) {

                samplerBindingsSpecified.setBit(binding);

                QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,

                                                         QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

                bindings.addTexture(binding,

                                    QRhiShaderResourceBinding::FragmentStage,

                                    shaderPipeline->MotionVectorTexture(), sampler);

        // Shadow map atlas

        auto shadowMapAtlas = shaderPipeline->shadowMapAtlasTexture();

        if (shadowMapAtlas) {

            int binding = shaderPipeline->bindingForTexture("qt_shadowmap_texture");

            if (binding >= 0) {

                samplerBindingsSpecified.setBit(binding);

                QRhiTexture *texture = shadowMapAtlas;

                QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,

                                                         QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

                Q_ASSERT(texture && sampler);

                bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);

        // Shadow map blue noise

        if (auto shadowMapBlueNoise = shaderPipeline->shadowMapBlueNoiseTexture()) {

            int binding = shaderPipeline->bindingForTexture("qt_shadowmap_blue_noise_texture");

            if (binding >= 0) {

                samplerBindingsSpecified.setBit(binding);

                QRhiTexture *texture = shadowMapBlueNoise;

                QRhiSampler *sampler = rhiCtx->sampler(

                        { QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None, QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });

                Q_ASSERT(texture && sampler);

                bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);

        QSSGRenderableImage *renderableImage = renderable.firstImage;

        while (renderableImage) {

            const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(renderableImage->m_mapType);

            const int samplerHint = int(renderableImage->m_mapType);

            int samplerBinding = shaderPipeline->bindingForTexture(samplerName, samplerHint);

            if (samplerBinding >= 0) {

                QRhiTexture *texture = renderableImage->m_texture.m_texture;

                if (samplerBinding >= 0 && texture) {

                    const bool mipmapped = texture->flags().testFlag(QRhiTexture::MipMapped);

                    QSSGRhiSamplerDescription samplerDesc = {

                        QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_minFilterType),

                        QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_magFilterType),

                        mipmapped ? QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None,

                        QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_horizontalTilingMode),

                        QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_verticalTilingMode),

                        QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_depthTilingMode)

};

                    rhiCtx->checkAndAdjustForNPoT(texture, &samplerDesc);

                    QRhiSampler *sampler = rhiCtx->sampler(samplerDesc);

                    samplerBindingsSpecified.setBit(samplerBinding);

                    bindings.addTexture(samplerBinding,

                                        CUSTOM_MATERIAL_VISIBILITY_ALL,

                                        texture, sampler);

            } // else this is not necessarily an error, e.g. having metalness/roughness maps with metalness disabled

            renderableImage = renderableImage->m_nextImage;

        if (maxSamplerBinding >= 0) {

            // custom property textures

            int customTexCount = shaderPipeline->extraTextureCount();

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

                QSSGRhiTexture &t(shaderPipeline->extraTextureAt(i));

                const int samplerBinding = shaderPipeline->bindingForTexture(t.name);

                if (samplerBinding >= 0) {

                    samplerBindingsSpecified.setBit(samplerBinding);

                    rhiCtx->checkAndAdjustForNPoT(t.texture, &t.samplerDesc);

                    QRhiSampler *sampler = rhiCtx->sampler(t.samplerDesc);

                    bindings.addTexture(samplerBinding,

                                        CUSTOM_MATERIAL_VISIBILITY_ALL,

                                        t.texture,

                                        sampler);

            // use a dummy texture for the unused samplers in the shader

            QRhiSampler *dummySampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,

                                                          QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

            for (const QShaderDescription::InOutVariable &var : std::as_const(samplerVars)) {

                if (!samplerBindingsSpecified.testBit(var.binding)) {

                    QRhiTexture *t = nullptr;

                    if (var.type == QShaderDescription::SamplerCube)

                        t = dummyCubeTexture;

                    else if (var.type == QShaderDescription::Sampler3D)

                        t = dummyTexture3D;

                    else if (var.type == QShaderDescription::Sampler2DArray)

                        t = dummyTextureArray;

                    else if (var.type == QShaderDescription::SamplerCubeArray)

                        t = dummyCubeTextureArray;

                    else

                        t = dummyTexture;

                    bindings.addTexture(var.binding, CUSTOM_MATERIAL_VISIBILITY_ALL, t, dummySampler);

        QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);

        if (oit && layerData.layer.oitMethod == QSSGRenderLayer::OITMethod::LinkedList)

            RenderHelpers::addAccumulatorImageBindings(shaderPipeline.get(), bindings);

        // do the same srb lookup acceleration as default materials

        QRhiShaderResourceBindings *&srb = dcd.srb;

        bool srbChanged = false;

        if (!srb || bindings != dcd.bindings) {

            srb = rhiCtxD->srb(bindings);

            rhiCtxD->releaseCachedSrb(dcd.bindings);

            dcd.bindings = bindings;

            srbChanged = true;

        if (cubeFace == QSSGRenderTextureCubeFaceNone)

            renderable.rhiRenderData.mainPass.srb = srb;

        else

            renderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx] = srb;

        const auto pipelineKey = QSSGGraphicsPipelineStateKey::create(*ps, renderPassDescriptor, srb);

        if (dcd.pipeline

                && !srbChanged

                && dcd.renderTargetDescriptionHash == pipelineKey.extra.renderTargetDescriptionHash

                && dcd.renderTargetDescription == pipelineKey.renderTargetDescription

                && dcd.ps == *ps)

            if (cubeFace == QSSGRenderTextureCubeFaceNone)

                renderable.rhiRenderData.mainPass.pipeline = dcd.pipeline;

            else

                renderable.rhiRenderData.reflectionPass.pipeline = dcd.pipeline;

        } else {

            if (cubeFace == QSSGRenderTextureCubeFaceNone) {

                renderable.rhiRenderData.mainPass.pipeline = rhiCtxD->pipeline(pipelineKey,

                                                                               renderPassDescriptor,

                                                                               srb);

                dcd.pipeline = renderable.rhiRenderData.mainPass.pipeline;

            } else {

                renderable.rhiRenderData.reflectionPass.pipeline = rhiCtxD->pipeline(pipelineKey,

                                                                                     renderPassDescriptor,

                                                                                     srb);

                dcd.pipeline = renderable.rhiRenderData.reflectionPass.pipeline;

            dcd.renderTargetDescriptionHash = pipelineKey.extra.renderTargetDescriptionHash;

            dcd.renderTargetDescription = pipelineKey.renderTargetDescription;

            dcd.ps = *ps;

void QSSGCustomMaterialSystem::setShaderResources(char *ubufData,

                                                  const QSSGRenderCustomMaterial &inMaterial,

                                                  const QByteArray &inPropertyName,

                                                  const QVariant &propertyValue,

                                                  QSSGRenderShaderValue::Type inPropertyType,

                                                  QSSGRhiShaderPipeline &shaderPipeline)

    Q_UNUSED(inMaterial);

    if (inPropertyType == QSSGRenderShaderValue::Texture) {

        QSSGRenderCustomMaterial::TextureProperty *textureProperty =

                reinterpret_cast<QSSGRenderCustomMaterial::TextureProperty *>(propertyValue.value<void *>());

        QSSGRenderImage *image = textureProperty->texImage;

        if (image) {

            const auto &theBufferManager(context->bufferManager());

            const QSSGRenderImageTexture texture = theBufferManager->loadRenderImage(image);

            if (texture.m_texture) {

                const QSSGRhiTexture t = {

                    inPropertyName,

                    texture.m_texture,

                    { QSSGRhiHelpers::toRhi(textureProperty->minFilterType),

                      QSSGRhiHelpers::toRhi(textureProperty->magFilterType),

                      textureProperty->mipFilterType != QSSGRenderTextureFilterOp::None ? QSSGRhiHelpers::toRhi(textureProperty->mipFilterType) : QRhiSampler::None,

                      QSSGRhiHelpers::toRhi(textureProperty->horizontalClampType),

                      QSSGRhiHelpers::toRhi(textureProperty->verticalClampType),

                      QSSGRhiHelpers::toRhi(textureProperty->zClampType)

};

                shaderPipeline.addExtraTexture(t);

    } else {

        shaderPipeline.setUniformValue(ubufData, inPropertyName, propertyValue, inPropertyType);

void QSSGCustomMaterialSystem::applyRhiShaderPropertyValues(char *ubufData,

                                                            const QSSGRenderCustomMaterial &material,

                                                            QSSGRhiShaderPipeline &shaderPipeline)

    const auto &properties = material.m_properties;

    for (const auto &prop : properties)

        setShaderResources(ubufData, material, prop.name, prop.value, prop.shaderDataType, shaderPipeline);

    const auto textProps = material.m_textureProperties;

    for (const auto &prop : textProps)

        setShaderResources(ubufData, material, prop.name, QVariant::fromValue((void *)&prop), prop.shaderDataType, shaderPipeline);

void QSSGCustomMaterialSystem::rhiRenderRenderable(QSSGRhiContext *rhiCtx,

                                                   QSSGSubsetRenderable &renderable,

                                                   bool *needsSetViewport,

                                                   QSSGRenderTextureCubeFace cubeFace,

                                                   const QSSGRhiGraphicsPipelineState &state,

                                                   qsizetype userPassIndex)

    QRhiGraphicsPipeline *ps = (userPassIndex >= 0) ? renderable.rhiRenderData.userPassData[userPassIndex].pipeline : renderable.rhiRenderData.mainPass.pipeline;

    QRhiShaderResourceBindings *srb = (userPassIndex >= 0) ? renderable.rhiRenderData.userPassData[userPassIndex].srb : renderable.rhiRenderData.mainPass.srb;

    if (cubeFace != QSSGRenderTextureCubeFaceNone) {

        const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);

        ps = renderable.rhiRenderData.reflectionPass.pipeline;

        srb = renderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx];

    if (!ps || !srb)

        return;

    Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall);

    QRhiBuffer *vertexBuffer = renderable.subset.rhi.vertexBuffer->buffer();

    QRhiBuffer *indexBuffer = renderable.subset.rhi.indexBuffer ? renderable.subset.rhi.indexBuffer->buffer() : nullptr;

    QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

    cb->setGraphicsPipeline(ps);

    cb->setShaderResources(srb);

    if (*needsSetViewport) {

        cb->setViewport(state.viewport);

        *needsSetViewport = false;

    QRhiCommandBuffer::VertexInput vertexBuffers[2];

    int vertexBufferCount = 1;

    vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0);

    quint32 instances = 1;

    if (renderable.modelContext.model.instancing()) {

        instances = renderable.modelContext.model.instanceCount();

        vertexBuffers[1] = QRhiCommandBuffer::VertexInput(renderable.instanceBuffer, 0);

        vertexBufferCount = 2;

    if (indexBuffer) {

        cb->setVertexInput(0, vertexBufferCount, vertexBuffers, indexBuffer, 0, renderable.subset.rhi.indexBuffer->indexFormat());

        cb->drawIndexed(renderable.subset.lodCount(renderable.subsetLevelOfDetail), instances, renderable.subset.lodOffset(renderable.subsetLevelOfDetail));

        QSSGRHICTX_STAT(rhiCtx, drawIndexed(renderable.subset.lodCount(renderable.subsetLevelOfDetail), instances));

    } else {

        cb->setVertexInput(0, vertexBufferCount, vertexBuffers);

        cb->draw(renderable.subset.count, instances, renderable.subset.offset);

        QSSGRHICTX_STAT(rhiCtx, draw(renderable.subset.count, instances));

    Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (renderable.subset.count | quint64(instances) << 32),

                                     QVector<int>({renderable.modelContext.model.profilingId,

                                      renderable.material.profilingId}));

QT_END_NAMESPACE

Revision control

Copy as Markdown