qssgrenderskymaterialmanager.cpp

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

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

// Qt-Security score:significant reason:default

#include <QtQuick3DRuntimeRender/private/qssgrenderskymaterialmanager_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrenderskymaterial_p.h>

#include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>

#include <QtQuick3DUtils/private/qssgassert_p.h>

#include "qssgrendercontextcore.h"

#include "qssgrendershadercache_p.h"

#include "qssgrhicontext_p.h"

#include <QtCore/qmath.h>

#include <cmath>

using namespace Qt::StringLiterals;

QT_BEGIN_NAMESPACE

namespace {

static constexpr QRhiTexture::Format cTextureFormat = QRhiTexture::RGBA16F;

static int nearestPowerOfTwo(int v)

    if (v <= 1)

        return 1;

    int upper = qNextPowerOfTwo(v);

    int lower = upper >> 1;

    return (v - lower < upper - v) ? lower : upper;

static QVarLengthArray<QMatrix4x4, 6> skyIblEnvironmentMapViews(QRhi *rhi)

    auto lookAt = [](const QVector3D &eye, const QVector3D &center, const QVector3D &up) {

        QMatrix4x4 viewMatrix;

        viewMatrix.lookAt(eye, center, up);

        return viewMatrix;

};

    QVarLengthArray<QMatrix4x4, 6> views;

    views.append(lookAt(QVector3D(0.0f, 0.0f, 0.0f), QVector3D(1.0, 0.0, 0.0), QVector3D(0.0f, -1.0f, 0.0f)));

    views.append(lookAt(QVector3D(0.0f, 0.0f, 0.0f), QVector3D(-1.0, 0.0, 0.0), QVector3D(0.0f, -1.0f, 0.0f)));

    if (rhi->isYUpInFramebuffer()) {

        views.append(lookAt(QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0, 1.0, 0.0), QVector3D(0.0f, 0.0f, 1.0f)));

        views.append(lookAt(QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0, -1.0, 0.0), QVector3D(0.0f, 0.0f, -1.0f)));

    } else {

        views.append(lookAt(QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0, -1.0, 0.0), QVector3D(0.0f, 0.0f, -1.0f)));

        views.append(lookAt(QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0, 1.0, 0.0), QVector3D(0.0f, 0.0f, 1.0f)));

    views.append(lookAt(QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0, 0.0, 1.0), QVector3D(0.0f, -1.0f, 0.0f)));

    views.append(lookAt(QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0, 0.0, -1.0), QVector3D(0.0f, -1.0f, 0.0f)));

    return views;

// Creates 6 face render targets for a texture, always at mip level 0.

// preserveColorContents controls whether the render target loads existing

// content before drawing (additive accumulation) or clears it (first slice).

// Using level=0 unconditionally is intentional: on Android GLES some drivers

// silently ignore the level parameter to glFramebufferTextureLayer for level>0,

// so the accumulator is allocated as separate per-mip non-mipmapped textures

// and each is always attached at level 0.

static bool skyIblCreateFaceTargets(QRhi *rhi,

                                    QRhiTexture *texture,

                                    const QByteArray &namePrefix,

                                    QSSGSkyIblFaceTargets *outTargets,

                                    bool preserveColorContents = false)

    Q_ASSERT(outTargets);

    const QRhiTextureRenderTarget::Flags rtFlags = preserveColorContents

            ? QRhiTextureRenderTarget::Flags(QRhiTextureRenderTarget::PreserveColorContents)

            : QRhiTextureRenderTarget::Flags();

    for (const auto face : QSSGRenderTextureCubeFaces) {

        QRhiColorAttachment att(texture);

        att.setLayer(quint8(face));

        // No setLevel() call — always attaches at mip level 0. Each per-mip

        // accumulator texture has only one mip level, so this is correct.

        QRhiTextureRenderTargetDescription rtDesc;

        rtDesc.setColorAttachments({ att });

        auto renderTarget = rhi->newTextureRenderTarget(rtDesc, rtFlags);

        renderTarget->setName(namePrefix + "/"_ba + QSSGBaseTypeHelpers::displayName(face));

        renderTarget->setDescription(rtDesc);

        if (!outTargets->renderPassDesc)

            outTargets->renderPassDesc = renderTarget->newCompatibleRenderPassDescriptor();

        renderTarget->setRenderPassDescriptor(outTargets->renderPassDesc);

        if (!renderTarget->create()) {

            qWarning("Failed to build sky IBL env map render target");

            return false;

        outTargets->renderTargets << renderTarget;

    return true;

static bool skyIblCreatePrefilterTargets(QRhi *rhi,

                                         QRhiTexture *texture,

                                         const QSize &environmentMapSize,

                                         const QByteArray &namePrefix,

                                         QSSGSkyIblPrefilterTargets *outTargets,

                                         bool preserveColorContents = false)

    Q_ASSERT(outTargets);

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

    outTargets->mipmapCount = hasMips ? qMin(rhi->mipLevelsForSize(environmentMapSize), 6) : 1;

    outTargets->mipLevelSizes.resize(outTargets->mipmapCount);

    outTargets->mipRenderTargetsMap.resize(outTargets->mipmapCount);

    const QRhiTextureRenderTarget::Flags rtFlags = preserveColorContents

            ? QRhiTextureRenderTarget::Flags(QRhiTextureRenderTarget::PreserveColorContents)

            : QRhiTextureRenderTarget::Flags();

    auto cleanup = [outTargets](QRhiTextureRenderTarget *failed, const QSSGSkyIblCubeFaceRenderTargets &partial) {

        delete failed;

        for (auto *rt : partial)

            delete rt;

        for (const QSSGSkyIblCubeFaceRenderTargets &rts : std::as_const(outTargets->mipRenderTargetsMap)) {

            for (auto *rt : rts)

                delete rt;

        delete outTargets->renderPassDesc;

        outTargets->renderPassDesc = nullptr;

        outTargets->mipRenderTargetsMap.clear();

        outTargets->mipLevelSizes.clear();

        outTargets->mipmapCount = 0;

};

    for (int mipLevel = 0; mipLevel < outTargets->mipmapCount; ++mipLevel) {

        QSSGSkyIblCubeFaceRenderTargets renderTargets;

        for (const auto face : QSSGRenderTextureCubeFaces) {

            QRhiColorAttachment att(texture);

            att.setLayer(quint8(face));

            att.setLevel(mipLevel);

            QRhiTextureRenderTargetDescription rtDesc;

            rtDesc.setColorAttachments({ att });

            auto renderTarget = rhi->newTextureRenderTarget(rtDesc, rtFlags);

            renderTarget->setName(namePrefix + QByteArrayLiteral("/m") + QByteArray::number(mipLevel)

                                  + QByteArrayLiteral("/") + QSSGBaseTypeHelpers::displayName(face));

            renderTarget->setDescription(rtDesc);

            if (!outTargets->renderPassDesc)

                outTargets->renderPassDesc = renderTarget->newCompatibleRenderPassDescriptor();

            renderTarget->setRenderPassDescriptor(outTargets->renderPassDesc);

            if (!renderTarget->create()) {

                qWarning("Failed to build sky IBL prefilter env map render target");

                cleanup(renderTarget, renderTargets);

                return false;

            renderTargets << renderTarget;

        const QSize levelSize(environmentMapSize.width() * std::pow(0.5, mipLevel),

                              environmentMapSize.height() * std::pow(0.5, mipLevel));

        outTargets->mipLevelSizes[mipLevel] = levelSize;

        outTargets->mipRenderTargetsMap[mipLevel] = renderTargets;

    return true;

static void skyIblInitializeUnrenderedMips(QRhi *rhi,

                                           QRhiCommandBuffer *cb,

                                           QSSGRhiContext *context,

                                           QRhiTexture *texture,

                                           int firstMip,

                                           int mipCountExclusive,

                                           const QByteArray &debugObjectName)

    if (firstMip >= mipCountExclusive)

        return;

    QRhiRenderPassDescriptor *rpDesc = nullptr;

    for (int mipLevel = firstMip; mipLevel < mipCountExclusive; ++mipLevel) {

        for (const auto face : QSSGRenderTextureCubeFaces) {

            QRhiColorAttachment att(texture);

            att.setLayer(quint8(face));

            att.setLevel(mipLevel);

            QRhiTextureRenderTargetDescription rtDesc;

            rtDesc.setColorAttachments({ att });

            auto *rt = rhi->newTextureRenderTarget(rtDesc);

            rt->setName(debugObjectName + "/init/m"_ba + QByteArray::number(mipLevel) + "/"_ba

                        + QSSGBaseTypeHelpers::displayName(face));

            rt->setDescription(rtDesc);

            if (!rpDesc)

                rpDesc = rt->newCompatibleRenderPassDescriptor();

            rt->setRenderPassDescriptor(rpDesc);

            if (!rt->create()) {

                qWarning("Failed to create sky IBL init render target");

                delete rt;

                continue;

            rt->deleteLater();

            cb->beginPass(rt, QColor(0, 0, 0, 1), { 1.0f, 0 }, nullptr, context->commonPassFlags());

            cb->endPass();

    if (rpDesc)

        rpDesc->deleteLater();

static const float skyIblCubeVerts[] = {

    -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f,  -1.0f, 1.0f,  1.0f,  -1.0f, 1.0f,  1.0f,

    -1.0f, 1.0f,  -1.0f, -1.0f, -1.0f, -1.0f,

    -1.0f, -1.0f, -1.0f, 1.0f,  1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,

    -1.0f, 1.0f,  -1.0f, 1.0f,  1.0f,  -1.0f,

    -1.0f, -1.0f, -1.0f, 1.0f,  -1.0f, -1.0f, 1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, -1.0f,

    1.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, 1.0f,

    -1.0f, 1.0f,  -1.0f, -1.0f, 1.0f,  1.0f,  1.0f,  1.0f,  1.0f,  -1.0f, 1.0f,  -1.0f,

    1.0f,  1.0f,  1.0f,  1.0f,  1.0f,  -1.0f,

    1.0f,  1.0f,  -1.0f, 1.0f,  1.0f,  1.0f,  1.0f,  -1.0f, 1.0f,  1.0f,  -1.0f, 1.0f,

    1.0f,  -1.0f, -1.0f, 1.0f,  1.0f,  -1.0f,

    -1.0f, 1.0f,  1.0f,  -1.0f, -1.0f, 1.0f,  1.0f,  1.0f,  1.0f,  -1.0f, -1.0f, 1.0f,

    1.0f,  -1.0f, 1.0f,  1.0f,  1.0f,  1.0f,

    0.0f,  1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f,  0.0f,  1.0f,

    1.0f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  0.0f,

    1.0f,  0.0f,  1.0f,  1.0f,  0.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,

    1.0f,  0.0f,  0.0f,  0.0f,  0.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,

    1.0f,  0.0f,  0.0f,  0.0f,  0.0f,  1.0f,  0.0f,  1.0f,  1.0f,  1.0f,  1.0f,  0.0f,

    0.0f,  0.0f,  0.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,  1.0f,  0.0f,

};

static bool ensureDynamicUBuf(QRhi *rhi, QRhiBuffer *&dst, int size, const char *errorMessage)

    if (dst)

        return true;

    dst = rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, size);

    if (!dst->create()) {

        qWarning("%s", errorMessage);

        delete dst;

        dst = nullptr;

        return false;

    return true;

static bool ensureSrb(QRhi *rhi, QRhiShaderResourceBindings *&dst, std::initializer_list<QRhiShaderResourceBinding> bindings, const char *errorMessage)

    if (dst)

        return true;

    dst = rhi->newShaderResourceBindings();

    dst->setBindings(bindings);

    if (!dst->create()) {

        qWarning("%s", errorMessage);

        delete dst;

        dst = nullptr;

        return false;

    return true;

struct PrefilterPipelineConfig

    QSSGRhiShaderPipeline *shader = nullptr;

    QRhiShaderResourceBindings *srb = nullptr;

    QRhiRenderPassDescriptor *rpd = nullptr;

    bool additiveBlend = false;

};

static QRhiGraphicsPipeline *createPrefilterPipeline(QRhi *rhi,

                                                     const QRhiVertexInputLayout &inputLayout,

                                                     const PrefilterPipelineConfig &cfg,

                                                     const char *errorMessage)

    auto *pipeline = rhi->newGraphicsPipeline();

    pipeline->setCullMode(QRhiGraphicsPipeline::Front);

    pipeline->setFrontFace(QRhiGraphicsPipeline::CCW);

    pipeline->setDepthOp(QRhiGraphicsPipeline::LessOrEqual);

    pipeline->setShaderStages({ *cfg.shader->vertexStage(), *cfg.shader->fragmentStage() });

    pipeline->setVertexInputLayout(inputLayout);

    pipeline->setShaderResourceBindings(cfg.srb);

    pipeline->setRenderPassDescriptor(cfg.rpd);

    pipeline->setFlags(QRhiGraphicsPipeline::UsesScissor);

    if (cfg.additiveBlend) {

        QRhiGraphicsPipeline::TargetBlend addBlend;

        addBlend.enable = true;

        addBlend.srcColor = QRhiGraphicsPipeline::One;

        addBlend.dstColor = QRhiGraphicsPipeline::One;

        addBlend.opColor = QRhiGraphicsPipeline::Add;

        addBlend.srcAlpha = QRhiGraphicsPipeline::One;

        addBlend.dstAlpha = QRhiGraphicsPipeline::One;

        addBlend.opAlpha = QRhiGraphicsPipeline::Add;

        pipeline->setTargetBlends({ addBlend });

    if (!pipeline->create()) {

        qWarning("%s", errorMessage);

        delete pipeline;

        return nullptr;

    return pipeline;

static void drawCubeFace(QRhiCommandBuffer *cb,

                         QSSGRhiContext *ctx,

                         QRhiTextureRenderTarget *rt,

                         QSize viewport,

                         QRhiGraphicsPipeline *pipeline,

                         QRhiShaderResourceBindings *srb,

                         const QRhiCommandBuffer::VertexInput &vbufBinding,

                         const QVector<QPair<int, quint32>> &dynamicOffsets,

                         const QByteArray &profilerLabel,

                         const QByteArray &passDebugLabel,

                         const QColor &clearColor = QColor(0, 0, 0, 1))

    cb->beginPass(rt, clearColor, { 1.0f, 0 }, nullptr, ctx->commonPassFlags());

    QSSGRHICTX_STAT(ctx, beginRenderPass(rt));

    Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

    cb->setViewport(QRhiViewport(0, 0, viewport.width(), viewport.height()));

    cb->setScissor(QRhiScissor(0, 0, viewport.width(), viewport.height()));

    cb->setGraphicsPipeline(pipeline);

    cb->setShaderResources(srb, dynamicOffsets.size(), dynamicOffsets.constData());

    cb->setVertexInput(0, 1, &vbufBinding);

    Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall);

    cb->draw(36);

    QSSGRHICTX_STAT(ctx, draw(36, 1));

    Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderCall, 36llu | (1llu << 32), profilerLabel);

    cb->endPass();

    QSSGRHICTX_STAT(ctx, endRenderPass());

    Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, passDebugLabel);

} // namespace

// Per-frame derived state passed between phase methods

struct QSSGRenderSkyMaterialManager::FrameState

    // computeFrameState

    QSize environmentMapSize;

    int totalSamples = 0;

    bool enableIBL = false;

    bool needCreateEnv = false;

    bool inProgressTimeSlice = false;

    bool envContentDirty = false;

    bool deferEnvRefresh = false;

    bool needRenderEnv = false;

    // ensureTextures

    bool prefilteredJustCreated = false;

    int prefilterTotalMipCount = 0;

    int prefilterSpecularMipCount = 0;

    int prefilterRoughnessDenom = 1;

    float resolution = 0.0f;

    // deriveCycleState

    bool multiFrame = false;

    bool prefilterIsConverged = false;

    bool runPrefilterSlice = false;

    int perFrameBudget = 0;

    int sliceSamplesThisFrame = 0;

    int sliceSampleStart = 0;

    int sliceSampleEnd = 0;

    bool sliceCompletesCycle = false;

    bool writePrefilteredCubeThisFrame = false;

    bool runIrradiancePass = false;

    bool haveConvergedResultEntering = false;

    bool isFirstSlice = false;

    // ensureSharedResources

    QRhiVertexInputLayout inputLayout;

    QMatrix4x4 mvp;

    QVarLengthArray<QMatrix4x4, 6> views;

    int ubufElementSize = 0;

    QRhiCommandBuffer::VertexInput vbufBinding { nullptr, 0 };

};

QSSGRenderSkyMaterialManager::QSSGRenderSkyMaterialManager(const QSSGRenderContextInterface &inContext)

    : m_context(inContext)

QSSGRenderSkyMaterialManager::~QSSGRenderSkyMaterialManager()

    releaseCachedResources();

void QSSGRenderSkyMaterialManager::clearPrefilterCache()

    auto releasePrefilterTargets = [](QSSGSkyIblPrefilterTargets &t) {

        for (const QSSGSkyIblCubeFaceRenderTargets &renderTargets : std::as_const(t.mipRenderTargetsMap)) {

            for (QRhiTextureRenderTarget *renderTarget : renderTargets)

                delete renderTarget;

        delete t.renderPassDesc;

        t.renderPassDesc = nullptr;

        t.mipRenderTargetsMap.clear();

        t.mipLevelSizes.clear();

        t.mipmapCount = 0;

};

    auto releaseFaceTargets = [](QSSGSkyIblFaceTargets &t) {

        for (QRhiTextureRenderTarget *rt : t.renderTargets)

            delete rt;

        delete t.renderPassDesc;

        t.renderPassDesc = nullptr;

        t.renderTargets.clear();

};

    auto safeDelete = [](auto *&res) {

        delete res;

        res = nullptr;

};

    safeDelete(m_cache.vertexBuffer);

    safeDelete(m_cache.uBuf);

    safeDelete(m_cache.uBufSlice);

    safeDelete(m_cache.uBufNormalize);

    safeDelete(m_cache.uBufIrradiance);

    releaseFaceTargets(m_cache.envFaceTargets);

    releasePrefilterTargets(m_cache.prefilterTargets);

    // Release per-mip accumulator face targets (preserve and clear variants)

    for (QSSGSkyIblFaceTargets &t : m_cache.accumPreserveFaceTargets)

        releaseFaceTargets(t);

    m_cache.accumPreserveFaceTargets.clear();

    for (QSSGSkyIblFaceTargets &t : m_cache.accumClearFaceTargets)

        releaseFaceTargets(t);

    m_cache.accumClearFaceTargets.clear();

    // Release per-mip normalize SRBs

    for (QRhiShaderResourceBindings *srb : std::as_const(m_cache.normalizeSrbs))

        delete srb;

    m_cache.normalizeSrbs.clear();

    safeDelete(m_cache.sliceSrb);

    safeDelete(m_cache.irradianceSrb);

    safeDelete(m_cache.envMapPipeline);

    safeDelete(m_cache.slicePipeline);

    safeDelete(m_cache.normalizeCubePipeline);

    safeDelete(m_cache.irradiancePipeline);

    m_cache.environmentMapSize = { };

    m_cache.enableIBL = false;

    m_cache.prefilterTotalMipCount = 0;

    m_cache.envCubeMap = nullptr;

    m_cache.prefilteredCubeMap = nullptr;

    m_cache.prefilterAccumulators.clear();

    m_cache.envShaderPipeline = nullptr;

void QSSGRenderSkyMaterialManager::releaseCachedResources()

    clearPrefilterCache();

    if (auto rhiCtx = m_context.rhiContext().get(); QSSG_GUARD(rhiCtx && rhiCtx->isValid())) {

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

        if (m_envCubeMap)

            rhiCtxD->releaseTexture(m_envCubeMap);

        if (m_prefilteredCubeMap)

            rhiCtxD->releaseTexture(m_prefilteredCubeMap);

        for (QRhiTexture *t : std::as_const(m_prefilterAccumulators))

            rhiCtxD->releaseTexture(t);

    m_envCubeMap = nullptr;

    m_prefilteredCubeMap = nullptr;

    m_prefilterAccumulators.clear();

    m_skyIblTexture = { };

    m_cubeMapSize = { };

    m_prefilteredMipCount = 0;

    m_accumulatedSamples = 0;

    m_accumIblSampleCount = 0;

    m_haveConvergedResult = false;

    m_envTailMipsInitialized = false;

    m_prefilteredTailMipsInitialized = false;

    m_finalizeIblPending = false;

QSSGRenderImageTexture QSSGRenderSkyMaterialManager::resolve(QSSGRenderSkyMaterial *settings, QSSGPassKey passKey)

    const auto &rhiCtx = m_context.rhiContext();

    if (!QSSG_GUARD(rhiCtx && rhiCtx->isValid() && rhiCtx->rhi()->isRecordingFrame()))

        return { };

    if (!ensureEnvironmentMap(settings, passKey)) {

        return { };

    const bool pendingAccumulation = settings->enableIBL && m_accumulatedSamples < settings->iblSampleCount;

    settings->wantsMoreFrames = pendingAccumulation || settings->isDirty || m_finalizeIblPending;

    return m_skyIblTexture;

bool QSSGRenderSkyMaterialManager::ensureEnvironmentMap(QSSGRenderSkyMaterial *inSky, QSSGPassKey passKey)

    const auto &context = m_context.rhiContext();

    if (!context->rhi()->isTextureFormatSupported(cTextureFormat)) {

        static bool warningPrinted = false;

        if (Q_UNLIKELY(!warningPrinted)) {

            qWarning() << "SkyMaterial not supported due to missing RGBA16F texture format support.";

            warningPrinted = true;

        return false;

    auto *cb = context->commandBuffer();

    FrameState fs;

    if (!computeFrameState(inSky, fs))

        return false;

    if (!ensureTextures(fs))

        return false;

    deriveCycleState(inSky, fs);

    QSSGRhiShaderPipelinePtr shaderPipeline;

    if (fs.needRenderEnv) {

        shaderPipeline = inSky->ensurePipeline(m_context);

        if (!shaderPipeline) {

            return false;

    QSSGRhiShaderPipeline *envShaderPipelineKey = fs.needRenderEnv ? shaderPipeline.get() : m_cache.envShaderPipeline;

    validateAndUpdateCacheKey(fs, envShaderPipelineKey);

    if (!ensureSharedResources(fs, cb))

        return false;

    auto *rub = context->rhi()->nextResourceUpdateBatch();

    for (const auto face : QSSGRenderTextureCubeFaces) {

        rub->updateDynamicBuffer(m_cache.uBuf, quint8(face) * fs.ubufElementSize, 64, fs.mvp.constData());

        rub->updateDynamicBuffer(m_cache.uBuf, quint8(face) * fs.ubufElementSize + 64, 64, fs.views[quint8(face)].constData());

    if (fs.runIrradiancePass) {

        struct IrradianceData

            float roughness;

            float resolution;

            float lodBias;

            int sampleCount;

            int distribution;

        } irradianceData;

        irradianceData.roughness = 0.0f;

        irradianceData.resolution = fs.resolution;

        irradianceData.lodBias = 0.0f;

        irradianceData.distribution = 0;

        irradianceData.sampleCount = qMax(int(fs.resolution / 4.0f), 1);

        rub->updateDynamicBuffer(m_cache.uBufIrradiance, 0, sizeof(IrradianceData), &irradianceData);

    if (fs.needRenderEnv) {

        if (!renderEnvironmentCube(inSky, passKey, fs, shaderPipeline, cb, rub))

            return false;

        rub = nullptr;

    if (fs.enableIBL && fs.needRenderEnv)

        runEnvironmentMipChain(fs, cb);

    if (!rub)

        rub = context->rhi()->nextResourceUpdateBatch();

    cb->debugMarkBegin("Sky IBL Pre-filtered Environment Cubemap Generation");

    if (!runPrefilterCycle(inSky, fs, cb, rub))

        return false;

    if (rub) {

        cb->resourceUpdate(rub);

        rub = nullptr;

    cb->debugMarkEnd();

    m_prefilteredMipCount = m_cache.prefilterTargets.mipmapCount;

    initializeTailMips(fs, cb);

    m_skyIblTexture.m_texture = m_prefilteredCubeMap;

    m_skyIblTexture.m_mipmapCount = m_prefilteredMipCount;

    m_skyIblTexture.m_flags.setLinear(true);

    m_skyIblTexture.m_flags.setRgbe8(false);

    return true;

bool QSSGRenderSkyMaterialManager::computeFrameState(QSSGRenderSkyMaterial *inSky, FrameState &fs)

    fs.enableIBL = inSky->enableIBL;

    fs.totalSamples = qBound(1, inSky->iblSampleCount, 1024);

    const int radianceMapSize = qBound(8, nearestPowerOfTwo(inSky->radianceMapSize), 2048);

    fs.environmentMapSize = QSize(radianceMapSize, radianceMapSize);

    const bool envWantsMips = fs.enableIBL;

    const bool envHasMips = m_envCubeMap && m_envCubeMap->flags().testFlag(QRhiTexture::MipMapped);

    fs.needCreateEnv = !m_envCubeMap || m_cubeMapSize != fs.environmentMapSize || envHasMips != envWantsMips;

    fs.inProgressTimeSlice = fs.enableIBL && m_accumulatedSamples > 0 && m_accumulatedSamples < m_accumIblSampleCount;

    fs.envContentDirty = inSky->isDirty && !fs.needCreateEnv;

    fs.deferEnvRefresh = fs.envContentDirty && (fs.inProgressTimeSlice || m_finalizeIblPending);

    fs.needRenderEnv = fs.needCreateEnv || (fs.envContentDirty && !fs.deferEnvRefresh);

    return true;

bool QSSGRenderSkyMaterialManager::ensureTextures(FrameState &fs)

    const auto &context = m_context.rhiContext();

    auto *rhi = context->rhi();

    QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(context.get());

    // --- Environment cube ---

    if (fs.needCreateEnv) {

        if (m_envCubeMap) {

            rhiCtxD->releaseTexture(m_envCubeMap);

            m_envCubeMap = nullptr;

        // The prefiltered cube derives from m_envCubeMap and must be invalidated alongside.

        if (m_prefilteredCubeMap) {

            rhiCtxD->releaseTexture(m_prefilteredCubeMap);

            m_prefilteredCubeMap = nullptr;

            m_prefilteredMipCount = 0;

        m_envTailMipsInitialized = false;

        m_prefilteredTailMipsInitialized = false;

        QRhiTexture::Flags envFlags = QRhiTexture::RenderTarget | QRhiTexture::CubeMap;

        if (fs.enableIBL)

            envFlags |= QRhiTexture::MipMapped | QRhiTexture::UsedWithGenerateMips;

        m_envCubeMap = rhi->newTexture(cTextureFormat, fs.environmentMapSize, 1, envFlags);

        if (!m_envCubeMap->create()) {

            qWarning("Failed to create Sky IBL environment cube map");

            delete m_envCubeMap;

            m_envCubeMap = nullptr;

            return false;

        m_envCubeMap->setName("SkyMaterialLightProbe procEnvCube"_ba);

        rhiCtxD->registerTexture(m_envCubeMap);

        m_cubeMapSize = fs.environmentMapSize;

    if (!m_prefilteredCubeMap) {

        const QRhiTexture::Flags pfFlags = QRhiTexture::RenderTarget | QRhiTexture::CubeMap | QRhiTexture::MipMapped;

        m_prefilteredCubeMap = rhi->newTexture(cTextureFormat, fs.environmentMapSize, 1, pfFlags);

        if (!m_prefilteredCubeMap->create()) {

            qWarning("Failed to create Sky IBL pre-filtered environment cube map");

            delete m_prefilteredCubeMap;

            m_prefilteredCubeMap = nullptr;

            return false;

        m_prefilteredCubeMap->setName("SkyMaterialLightProbe"_ba);

        rhiCtxD->registerTexture(m_prefilteredCubeMap);

        fs.prefilteredJustCreated = true;

        m_haveConvergedResult = false;

        m_prefilteredTailMipsInitialized = false;

    fs.prefilterTotalMipCount = m_prefilteredCubeMap->flags().testFlag(QRhiTexture::MipMapped)

            ? qMin(rhi->mipLevelsForSize(fs.environmentMapSize), 6)

            : 1;

    fs.prefilterSpecularMipCount = fs.enableIBL ? fs.prefilterTotalMipCount - 1 : 1;

    fs.prefilterRoughnessDenom = qMax(fs.prefilterSpecularMipCount - 1, 1);

    fs.resolution = float(fs.environmentMapSize.width());

    // Determine whether the existing per-mip accumulator set is still valid.

    // We need one texture per specular mip level, each sized for that mip.

    const bool needCreateAccum = m_prefilterAccumulators.isEmpty() || m_prefilterAccumulators.size() != fs.prefilterSpecularMipCount

            || (!m_prefilterAccumulators.isEmpty() && m_prefilterAccumulators[0]->pixelSize() != fs.environmentMapSize);

    if (needCreateAccum) {

        for (QRhiTexture *t : std::as_const(m_prefilterAccumulators))

            rhiCtxD->releaseTexture(t);

        m_prefilterAccumulators.clear();

        m_accumulatedSamples = 0;

        // Allocate one non-mipmapped 2D array texture per specular mip level.

        // Each texture is sized for its mip level and only has mip 0.

//

        // Rationale: on Android GLES (Adreno, Mali) glFramebufferTextureLayer

        // with level > 0 is sometimes silently broken. The driver accepts the

        // FBO as complete but writes to the wrong location or ignores the level

        // entirely. By giving each mip level its own texture and always attaching

        // at level 0, we avoid the broken code path entirely.

        bool ok = true;

        for (int mip = 0; mip < fs.prefilterSpecularMipCount; ++mip) {

            const QSize mipSize(qMax(1, fs.environmentMapSize.width() >> mip), qMax(1, fs.environmentMapSize.height() >> mip));

            // No MipMapped flag — single level only, always attached at level 0.

            auto *t = rhi->newTextureArray(cTextureFormat, 6, mipSize, 1, QRhiTexture::RenderTarget);

            if (!t->create()) {

                qWarning("Failed to create Sky IBL prefilter accumulator mip %d", mip);

                delete t;

                ok = false;

                break;

            t->setName("SkyMaterialLightProbe procEnvPfAccum m"_ba + QByteArray::number(mip));

            rhiCtxD->registerTexture(t);

            m_prefilterAccumulators.append(t);

        if (!ok) {

            for (QRhiTexture *t : std::as_const(m_prefilterAccumulators))

                rhiCtxD->releaseTexture(t);

            m_prefilterAccumulators.clear();

            // Accumulator unavailable — fall back to single-frame prefilter.

        } else {

            // No tail-mip initialization needed: each texture has exactly one

            // mip level (level 0), so there are no unwritten tail mips.

    return true;

void QSSGRenderSkyMaterialManager::deriveCycleState(QSSGRenderSkyMaterial *inSky, FrameState &fs)

    // Finalize frame: all slicing is complete, run normalize + irradiance now.

    if (m_finalizeIblPending && !fs.needRenderEnv && !fs.prefilteredJustCreated && m_accumIblSampleCount == fs.totalSamples) {

        m_finalizeIblPending = false;

        m_haveConvergedResult = true;

        fs.runPrefilterSlice = false;

        fs.writePrefilteredCubeThisFrame = true;

        fs.runIrradiancePass = fs.enableIBL;

        fs.sliceSamplesThisFrame = 0;

        fs.sliceSampleStart = m_accumulatedSamples;

        fs.sliceSampleEnd = m_accumulatedSamples;

        fs.isFirstSlice = false;

        fs.sliceCompletesCycle = false;

        fs.haveConvergedResultEntering = false; // was not converged before this frame

        fs.multiFrame = false;

        return;

    fs.multiFrame = fs.enableIBL && inSky->iblSamplesPerFrame > 0 && inSky->iblSamplesPerFrame < fs.totalSamples;

    // Restart the accumulator if anything stale: env content changed, prefiltered cube was

    // re-created, or the sample-count target changed.

    if (!m_prefilterAccumulators.isEmpty()) {

        const bool resetAccumulation = fs.needRenderEnv || fs.prefilteredJustCreated || m_accumIblSampleCount != fs.totalSamples;

        if (resetAccumulation) {

            m_accumulatedSamples = 0;

            // Any finalize pending from the previous cycle is now stale — the accumulators

            // have been reset so running normalize would write garbage to the prefiltered cube.

            m_finalizeIblPending = false;

        m_accumIblSampleCount = fs.totalSamples;

    fs.prefilterIsConverged = !m_prefilterAccumulators.isEmpty() && m_accumulatedSamples >= fs.totalSamples;

    fs.runPrefilterSlice = !m_prefilterAccumulators.isEmpty() && !fs.prefilterIsConverged;

    // perFrameBudget = samples to integrate this frame.

    //   Single-frame (iblSamplesPerFrame <= 0) or !enableIBL: all remaining samples.

    //   Multi-frame:                                          the requested budget.

    fs.perFrameBudget = (inSky->iblSamplesPerFrame > 0 && fs.enableIBL) ? inSky->iblSamplesPerFrame

                                                                        : (fs.totalSamples - m_accumulatedSamples);

    fs.sliceSamplesThisFrame = fs.runPrefilterSlice ? qMin(fs.perFrameBudget, fs.totalSamples - m_accumulatedSamples) : 0;

    fs.sliceCompletesCycle = fs.runPrefilterSlice && (m_accumulatedSamples + fs.sliceSamplesThisFrame >= fs.totalSamples);

    fs.sliceSampleStart = m_accumulatedSamples;

    fs.sliceSampleEnd = fs.runPrefilterSlice ? qMin(m_accumulatedSamples + fs.perFrameBudget, fs.totalSamples) : 0;

    fs.isFirstSlice = m_accumulatedSamples == 0;

    fs.haveConvergedResultEntering = m_haveConvergedResult;

    if (inSky->iblRenderFrames >= 1) {

        // iblRenderFrames >= 1: normalize and irradiance are deferred to a dedicated frame

        // after all slicing completes, so the last slice frame never pays both costs.

        // m_finalizeIblPending is set in runPrefilterCycle (not here) so it only fires

        // once the accumulators actually contain data. Setting it here would trigger a

        // spurious finalize when the prefilter was blocked by canPrefilter==false (e.g.

        // skyRenderFrames >= 1 on the env-render frame), normalising empty accumulators.

        fs.writePrefilteredCubeThisFrame = false;

        fs.runIrradiancePass = false;

    } else {

        // iblRenderFrames == 0: normalize runs every frame so the user sees progressive

        // convergence while slicing, then fully on the cycle-completion frame.

        fs.writePrefilteredCubeThisFrame = fs.runPrefilterSlice && (fs.sliceCompletesCycle || !m_haveConvergedResult);

        fs.runIrradiancePass = fs.enableIBL && fs.writePrefilteredCubeThisFrame;

void QSSGRenderSkyMaterialManager::validateAndUpdateCacheKey(const FrameState &fs, QSSGRhiShaderPipeline *envShaderPipelineKey)

    const bool cacheValid = m_cache.environmentMapSize == fs.environmentMapSize && m_cache.enableIBL == fs.enableIBL

            && m_cache.prefilterTotalMipCount == fs.prefilterTotalMipCount && m_cache.envCubeMap == m_envCubeMap

            && m_cache.prefilteredCubeMap == m_prefilteredCubeMap && m_cache.prefilterAccumulators == m_prefilterAccumulators

            && m_cache.envShaderPipeline == envShaderPipelineKey;

    if (cacheValid)

        return;

    clearPrefilterCache();

    m_cache.environmentMapSize = fs.environmentMapSize;

    m_cache.enableIBL = fs.enableIBL;

    m_cache.prefilterTotalMipCount = fs.prefilterTotalMipCount;

    m_cache.envCubeMap = m_envCubeMap;

    m_cache.prefilteredCubeMap = m_prefilteredCubeMap;

    m_cache.prefilterAccumulators = m_prefilterAccumulators;

    m_cache.envShaderPipeline = envShaderPipelineKey;

bool QSSGRenderSkyMaterialManager::ensureSharedResources(FrameState &fs, QRhiCommandBuffer *cb)

    const auto &context = m_context.rhiContext();

    auto *rhi = context->rhi();

    fs.inputLayout.setBindings({ { 3 * sizeof(float) } });

    fs.inputLayout.setAttributes({ { 0, 0, QRhiVertexInputAttribute::Float3, 0 } });

    fs.mvp = rhi->clipSpaceCorrMatrix();

    fs.mvp.perspective(90.0f, 1.0f, 0.1f, 10.0f);

    fs.views = skyIblEnvironmentMapViews(rhi);

    fs.ubufElementSize = rhi->ubufAligned(128);

    if (!m_cache.vertexBuffer) {

        m_cache.vertexBuffer = rhi->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, sizeof(skyIblCubeVerts));

        if (!m_cache.vertexBuffer->create()) {

            qWarning("Failed to create sky IBL vertex buffer");

            delete m_cache.vertexBuffer;

            m_cache.vertexBuffer = nullptr;

            return false;

        auto *initRub = rhi->nextResourceUpdateBatch();

        initRub->uploadStaticBuffer(m_cache.vertexBuffer, skyIblCubeVerts);

        cb->resourceUpdate(initRub);

    if (!ensureDynamicUBuf(rhi, m_cache.uBuf, fs.ubufElementSize * 6, "Failed to create sky IBL view uniform buffer"))

        return false;

    fs.vbufBinding = QRhiCommandBuffer::VertexInput(m_cache.vertexBuffer, 0);

    if (!m_cache.prefilterTargets.renderPassDesc) {

        if (!skyIblCreatePrefilterTargets(rhi, m_prefilteredCubeMap, fs.environmentMapSize, "SkyMaterialLightProbe procEnvPf"_ba, &m_cache.prefilterTargets)) {

            return false;

    if (!ensureDynamicUBuf(rhi, m_cache.uBufIrradiance, rhi->ubufAligned(20), "Failed to create sky IBL irradiance uniform buffer"))

        return false;

    const QSSGRhiSamplerDescription samplerNoMipDesc { QRhiSampler::Linear,      QRhiSampler::Linear,

                                                       QRhiSampler::None,        QRhiSampler::ClampToEdge,

                                                       QRhiSampler::ClampToEdge, QRhiSampler::Repeat };

    QRhiSampler *envMapCubeNoMipSampler = context->sampler(samplerNoMipDesc);

    if (!ensureSrb(rhi,

                   m_cache.irradianceSrb,

                   { QRhiShaderResourceBinding::uniformBufferWithDynamicOffset(0, QRhiShaderResourceBinding::VertexStage, m_cache.uBuf, 128),

                     QRhiShaderResourceBinding::uniformBufferWithDynamicOffset(2, QRhiShaderResourceBinding::FragmentStage, m_cache.uBufIrradiance, 20),

                     QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, m_envCubeMap, envMapCubeNoMipSampler) },

                   "Failed to create sky IBL irradiance SRB"))

        return false;

    if (!m_cache.irradiancePipeline) {

        const auto &shader = m_context.shaderCache()->getBuiltInRhiShaders().getRhienvironmentmapPreFilterShader(false);

        m_cache.irradiancePipeline = createPrefilterPipeline(rhi,

                                                             fs.inputLayout,

                                                             { shader.get(),

                                                               m_cache.irradianceSrb,

                                                               m_cache.prefilterTargets.renderPassDesc,

                                                               false },

                                                             "Failed to create sky IBL realtime irradiance pipeline "

                                                             "state");

        if (!m_cache.irradiancePipeline)

            return false;

    return true;

bool QSSGRenderSkyMaterialManager::renderEnvironmentCube(QSSGRenderSkyMaterial *inSky,

                                                         QSSGPassKey passKey,

                                                         const FrameState &fs,

                                                         const QSSGRhiShaderPipelinePtr &shaderPipeline,

                                                         QRhiCommandBuffer *cb,

                                                         QRhiResourceUpdateBatch *rub)

    const auto &context = m_context.rhiContext();

    auto *rhi = context->rhi();

    QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(context.get());

    const quint32 skyElementSize = inSky->updateUniforms(m_context, passKey, fs.mvp, fs.views);

    if (!m_cache.envFaceTargets.renderPassDesc) {

        if (!skyIblCreateFaceTargets(rhi, m_envCubeMap, "SkyMaterialLightProbe procEnvCube"_ba, &m_cache.envFaceTargets))

            return false;

    QRhiShaderResourceBindings *envSrb = rhiCtxD->srb(inSky->bindings);

    Q_ASSERT(envSrb);

    if (!m_cache.envMapPipeline) {

        m_cache.envMapPipeline = createPrefilterPipeline(rhi,

                                                         fs.inputLayout,

                                                         { shaderPipeline.get(), envSrb, m_cache.envFaceTargets.renderPassDesc, false },

                                                         "Failed to create sky IBL env map pipeline state");

        if (!m_cache.envMapPipeline)

            return false;

    cb->resourceUpdate(rub);

    cb->debugMarkBegin("Sky IBL Procedural Environment Cubemap Generation");

    for (const auto face : QSSGRenderTextureCubeFaces) {

        const QVector<QPair<int, quint32>> offsets = { { 0, quint32(skyElementSize * quint8(face)) } };

        drawCubeFace(cb,

                     context.get(),

                     m_cache.envFaceTargets.renderTargets[quint8(face)],

                     fs.environmentMapSize,

                     m_cache.envMapPipeline,

                     envSrb,

                     fs.vbufBinding,

                     offsets,

                     QByteArrayLiteral("sky_ibl_procedural_environment_map"),

                     QSSG_RENDERPASS_NAME("sky_ibl_procedural_environment_map", 0, face));

    cb->debugMarkEnd();

    inSky->isDirty = false;

    return true;

void QSSGRenderSkyMaterialManager::runEnvironmentMipChain(const FrameState &fs, QRhiCommandBuffer *cb)

    const auto &context = m_context.rhiContext();

    auto *rhi = context->rhi();

    if (!m_envTailMipsInitialized) {

        const int envFullMipCount = rhi->mipLevelsForSize(fs.environmentMapSize);

        skyIblInitializeUnrenderedMips(rhi, cb, context.get(), m_envCubeMap, 1, envFullMipCount, "SkyMaterialLightProbe procEnvCube"_ba);

        m_envTailMipsInitialized = true;

    auto *rubMip = rhi->nextResourceUpdateBatch();

    rubMip->generateMips(m_envCubeMap);

    cb->resourceUpdate(rubMip);

bool QSSGRenderSkyMaterialManager::runPrefilterCycle(QSSGRenderSkyMaterial *inSky,

                                                     const FrameState &fs,

                                                     QRhiCommandBuffer *cb,

                                                     QRhiResourceUpdateBatch *&rub)

    Q_UNUSED(inSky);

    if (!fs.runPrefilterSlice && !fs.writePrefilteredCubeThisFrame) {

        cb->resourceUpdate(rub);

        rub = nullptr;

        return true;

    const auto &context = m_context.rhiContext();

    auto *rhi = context->rhi();

    // Ensure per-mip face targets for the accumulator.

//

    // Each specular mip level has its own non-mipmapped 2D array texture

    // (m_prefilterAccumulators[mip]), and we need two sets of face render

    // targets for it: one that preserves existing content (for slices 2..N,

    // additive blend) and one that clears (for the first slice).

//

    // We always attach at level 0 because each accumulator texture has only

    // one mip level. This sidesteps the Android GLES driver bug where

    // glFramebufferTextureLayer ignores level > 0.

    if (m_cache.accumPreserveFaceTargets.size() != fs.prefilterSpecularMipCount) {

        // Release any stale targets (size mismatch after cache invalidation)

        for (QSSGSkyIblFaceTargets &t : m_cache.accumPreserveFaceTargets) {

            for (QRhiTextureRenderTarget *rt : t.renderTargets)

                delete rt;

            delete t.renderPassDesc;

        m_cache.accumPreserveFaceTargets.clear();

        m_cache.accumPreserveFaceTargets.resize(fs.prefilterSpecularMipCount);

        for (int mip = 0; mip < fs.prefilterSpecularMipCount; ++mip) {

            if (!skyIblCreateFaceTargets(rhi,

                                         m_prefilterAccumulators[mip],

                                         "SkyMaterialLightProbe procEnvPfAccum/m"_ba + QByteArray::number(mip),

                                         &m_cache.accumPreserveFaceTargets[mip],

                                         true)) {

                return false;

    if (m_cache.accumClearFaceTargets.size() != fs.prefilterSpecularMipCount) {

        for (QSSGSkyIblFaceTargets &t : m_cache.accumClearFaceTargets) {

            for (QRhiTextureRenderTarget *rt : t.renderTargets)

                delete rt;

            delete t.renderPassDesc;

        m_cache.accumClearFaceTargets.clear();

        m_cache.accumClearFaceTargets.resize(fs.prefilterSpecularMipCount);

        for (int mip = 0; mip < fs.prefilterSpecularMipCount; ++mip) {

            if (!skyIblCreateFaceTargets(rhi,

                                         m_prefilterAccumulators[mip],

                                         "SkyMaterialLightProbe procEnvPfAccumClear/m"_ba + QByteArray::number(mip),

                                         &m_cache.accumClearFaceTargets[mip],

                                         false)) {

                return false;

    QSSGSkyIblPrefilterTargets &prefilterTargets = m_cache.prefilterTargets;

    constexpr int uBufSliceSize = 32;

    constexpr int uBufNormalizeSize = 16;

    const int uBufSliceElementSize = rhi->ubufAligned(uBufSliceSize);

    const int uBufNormalizeElementSize = rhi->ubufAligned(uBufNormalizeSize);

    const int uBufNormalizeEntryCount = qMax(fs.prefilterSpecularMipCount, 1) * 6;

    if (!ensureDynamicUBuf(rhi, m_cache.uBufSlice, uBufSliceElementSize * qMax(fs.prefilterSpecularMipCount, 1), "Failed to create sky IBL slice uniform buffer"))

        return false;

    if (!ensureDynamicUBuf(rhi, m_cache.uBufNormalize, uBufNormalizeElementSize * uBufNormalizeEntryCount, "Failed to create sky IBL normalize uniform buffer"))

        return false;

    const QSSGRhiSamplerDescription mipSamplerDesc { QRhiSampler::Linear,      QRhiSampler::Linear,

                                                     QRhiSampler::Linear,      QRhiSampler::ClampToEdge,

                                                     QRhiSampler::ClampToEdge, QRhiSampler::Repeat };

    const QSSGRhiSamplerDescription noMipLinearSamplerDesc { QRhiSampler::Linear,      QRhiSampler::Linear,

                                                             QRhiSampler::None,        QRhiSampler::ClampToEdge,

                                                             QRhiSampler::ClampToEdge, QRhiSampler::Repeat };

    const QSSGRhiSamplerDescription nearestSamplerDesc { QRhiSampler::Nearest,     QRhiSampler::Nearest,

                                                         QRhiSampler::None,        QRhiSampler::ClampToEdge,

                                                         QRhiSampler::ClampToEdge, QRhiSampler::Repeat };

    QRhiSampler *envMapCubeSampler = context->sampler(fs.enableIBL ? mipSamplerDesc : noMipLinearSamplerDesc);

    QRhiSampler *accumReadSampler = context->sampler(nearestSamplerDesc);

    if (!ensureSrb(rhi,

                   m_cache.sliceSrb,

                   { QRhiShaderResourceBinding::uniformBufferWithDynamicOffset(0, QRhiShaderResourceBinding::VertexStage, m_cache.uBuf, 128),

                     QRhiShaderResourceBinding::uniformBufferWithDynamicOffset(2, QRhiShaderResourceBinding::FragmentStage, m_cache.uBufSlice, uBufSliceSize),

                     QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, m_envCubeMap, envMapCubeSampler) },

                   "Failed to create sky IBL slice SRB"))

        return false;

    // Create one normalize SRB per specular mip level, each binding the

    // corresponding per-mip accumulator texture. Since the accumulator textures

    // are separate non-mipmapped arrays (one per mip), we always read from

    // level 0 of whichever texture is bound — the normalize shader passes 0

    // as the texelFetch lod (mipLevel in the UBO is set to 0 for all entries).

    if (m_cache.normalizeSrbs.size() != fs.prefilterSpecularMipCount) {

        for (QRhiShaderResourceBindings *srb : std::as_const(m_cache.normalizeSrbs))

            delete srb;

        m_cache.normalizeSrbs.clear();

        m_cache.normalizeSrbs.resize(fs.prefilterSpecularMipCount, nullptr);

    for (int mip = 0; mip < fs.prefilterSpecularMipCount; ++mip) {

        if (!ensureSrb(rhi,

                       m_cache.normalizeSrbs[mip],

                       { QRhiShaderResourceBinding::uniformBufferWithDynamicOffset(0, QRhiShaderResourceBinding::VertexStage, m_cache.uBuf, 128),

                         QRhiShaderResourceBinding::uniformBufferWithDynamicOffset(2, QRhiShaderResourceBinding::FragmentStage, m_cache.uBufNormalize, uBufNormalizeSize),

                         QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, m_prefilterAccumulators[mip], accumReadSampler) },

                       "Failed to create sky IBL normalize SRB"))

            return false;

    if (!m_cache.slicePipeline) {

        const auto &shader = m_context.shaderCache()->getBuiltInRhiShaders().getRhiSkyIblPreFilterShader();

        m_cache.slicePipeline = createPrefilterPipeline(rhi,

                                                        fs.inputLayout,

                                                        { shader.get(),

                                                          m_cache.sliceSrb,

                                                          m_cache.accumPreserveFaceTargets[0].renderPassDesc,

                                                          true },

                                                        "Failed to create sky IBL slice pipeline state");

        if (!m_cache.slicePipeline)

            return false;

    if (!m_cache.normalizeCubePipeline) {

        // All normalize SRBs share the same layout; create the pipeline from SRB 0.

        const auto &shader = m_context.shaderCache()->getBuiltInRhiShaders().getRhiSkyIblPreFilterNormalizeShader();

        m_cache.normalizeCubePipeline = createPrefilterPipeline(rhi,

                                                                fs.inputLayout,

                                                                { shader.get(),

                                                                  m_cache.normalizeSrbs[0],

                                                                  prefilterTargets.renderPassDesc,

                                                                  false },

                                                                "Failed to create sky IBL normalize-to-cube pipeline "

                                                                "state");

        if (!m_cache.normalizeCubePipeline)

            return false;

    for (int mipLevel = 0; mipLevel < fs.prefilterSpecularMipCount; ++mipLevel) {

        struct SliceData

            float roughness;

            float resolution;

            quint32 sampleStart;

            quint32 sampleEnd;

            quint32 totalSampleCount;

            quint32 _pad0;

            quint32 _pad1;

            quint32 _pad2;

        } sliceData;

        sliceData.roughness = float(mipLevel) / float(fs.prefilterRoughnessDenom);

        sliceData.resolution = fs.resolution;

        sliceData.sampleStart = quint32(fs.sliceSampleStart);

        sliceData.sampleEnd = quint32(fs.sliceSampleEnd);

        sliceData.totalSampleCount = quint32(fs.totalSamples);

        sliceData._pad0 = sliceData._pad1 = sliceData._pad2 = 0;

        rub->updateDynamicBuffer(m_cache.uBufSlice, mipLevel * uBufSliceElementSize, sizeof(SliceData), &sliceData);

        for (const auto face : QSSGRenderTextureCubeFaces) {

            struct NormalizeData

                qint32 faceIndex;

                qint32 _pad0 = 0;

                qint32 _pad1 = 0;

                qint32 _pad2 = 0;

            } normalizeData;

            normalizeData.faceIndex = quint8(face);

            const int entryIndex = mipLevel * 6 + quint8(face);

            rub->updateDynamicBuffer(m_cache.uBufNormalize, entryIndex * uBufNormalizeElementSize, sizeof(NormalizeData), &normalizeData);

    cb->resourceUpdate(rub);

    rub = nullptr;

    // Slice accumulation pass.

//

    // On the first slice we use the clear-variant face targets (no PreserveColorContents)

    // so the render pass clears the accumulator before the additive draw. This replaces

    // the old pattern of a separate empty clear pass followed by a preserve pass, which

    // was fragile on tile-based GPUs (the load in the preserve pass could see stale tile

    // data from a prior clear pass that stored to the same surface).

//

    // On subsequent slices we use the preserve-variant targets so the additive blend

    // accumulates on top of the existing content.

    if (fs.runPrefilterSlice) {

        for (int mipLevel = 0; mipLevel < fs.prefilterSpecularMipCount; ++mipLevel) {

            QSSGSkyIblFaceTargets &sliceTargets = fs.isFirstSlice ? m_cache.accumClearFaceTargets[mipLevel]

                                                                  : m_cache.accumPreserveFaceTargets[mipLevel];

            const QSize mipSize(qMax(1, fs.environmentMapSize.width() >> mipLevel),

                                qMax(1, fs.environmentMapSize.height() >> mipLevel));

            for (const auto face : QSSGRenderTextureCubeFaces) {

                const QVector<QPair<int, quint32>> offsets = { { 0, quint32(fs.ubufElementSize * quint8(face)) },

                                                               { 2, quint32(uBufSliceElementSize * mipLevel) } };

                drawCubeFace(cb,

                             context.get(),

                             sliceTargets.renderTargets[quint8(face)],

                             mipSize,

                             m_cache.slicePipeline,

                             m_cache.sliceSrb,

                             fs.vbufBinding,

                             offsets,

                             QByteArrayLiteral("sky_ibl_prefilter_slice"),

                             QSSG_RENDERPASS_NAME("sky_ibl_prefilter_slice", mipLevel, face),

                             QColor(0, 0, 0, 0));

        m_accumulatedSamples = fs.sliceSampleEnd;

        if (fs.sliceCompletesCycle) {

            if (inSky->iblRenderFrames >= 1) {

                // Defer normalize+irradiance to a dedicated finalize frame.

                // Set the flag here (after the slice actually ran) so the accumulators

                // are guaranteed to contain data when the finalize fires.

                m_finalizeIblPending = true;

            } else {

                // iblRenderFrames==0: normalize runs inline, mark converged now.

                m_haveConvergedResult = true;

    // Normalize accumulated samples into the prefiltered cube.

    // For iblRenderFrames==0: runs every frame until convergence (progressive).

    // For iblRenderFrames>=1: only runs in the dedicated finalize frame.

    if (fs.writePrefilteredCubeThisFrame) {

        for (int mipLevel = 0; mipLevel < fs.prefilterSpecularMipCount; ++mipLevel) {

            for (const auto face : QSSGRenderTextureCubeFaces) {

                const int normalizeEntryIndex = mipLevel * 6 + quint8(face);

                const QVector<QPair<int, quint32>> offsets = { { 0, quint32(fs.ubufElementSize * quint8(face)) },

                                                               { 2, quint32(uBufNormalizeElementSize * normalizeEntryIndex) } };

                drawCubeFace(cb,

                             context.get(),

                             prefilterTargets.mipRenderTargetsMap[mipLevel][quint8(face)],

                             prefilterTargets.mipLevelSizes[mipLevel],

                             m_cache.normalizeCubePipeline,

                             m_cache.normalizeSrbs[mipLevel],

                             fs.vbufBinding,

                             offsets,

                             QByteArrayLiteral("sky_ibl_prefilter_normalize"),

                             QSSG_RENDERPASS_NAME("sky_ibl_prefilter_normalize", mipLevel, face));

    if (fs.runIrradiancePass) {

        const int irradianceMip = prefilterTargets.mipmapCount - 1;

        for (const auto face : QSSGRenderTextureCubeFaces) {

            const QVector<QPair<int, quint32>> offsets = { { 0, quint32(fs.ubufElementSize * quint8(face)) }, { 2, 0u } };

            drawCubeFace(cb,

                         context.get(),

                         prefilterTargets.mipRenderTargetsMap[irradianceMip][quint8(face)],

                         prefilterTargets.mipLevelSizes[irradianceMip],

                         m_cache.irradiancePipeline,

                         m_cache.irradianceSrb,

                         fs.vbufBinding,

                         offsets,

                         QByteArrayLiteral("sky_ibl_irradiance"),

                         QSSG_RENDERPASS_NAME("sky_ibl_irradiance", irradianceMip, face));

    return true;

void QSSGRenderSkyMaterialManager::initializeTailMips(const FrameState &fs, QRhiCommandBuffer *cb)

    if (!m_prefilteredCubeMap->flags().testFlag(QRhiTexture::MipMapped) || m_prefilteredTailMipsInitialized)

        return;

    const auto &context = m_context.rhiContext();

    auto *rhi = context->rhi();

    const int prefilteredFullMipCount = rhi->mipLevelsForSize(fs.environmentMapSize);

    // Mips actually written this lifetime depend on enableIBL:

    //   * enableIBL=true:  prefilter loop writes mips [0, prefilterMipCount), irradiance writes

    //                      the last (prefilterTargets.mipmapCount-1). So mips [0, prefilterTargets.mipmapCount)

    //                      are covered → init starts at prefilterTargets.mipmapCount.

    //   * enableIBL=false: prefilter loop writes only mip 0, irradiance is skipped → init starts at 1.

    // The prefiltered cube is allocated mip-mapped in both modes for downstream sampler

    // completeness; we just need to clear the tail.

    const int firstUnwrittenMip = fs.enableIBL ? m_cache.prefilterTargets.mipmapCount : 1;

    skyIblInitializeUnrenderedMips(rhi, cb, context.get(), m_prefilteredCubeMap, firstUnwrittenMip, prefilteredFullMipCount, "SkyMaterialLightProbe"_ba);

    m_prefilteredTailMipsInitialized = true;

QT_END_NAMESPACE

Revision control

Copy as Markdown