qssgrendershadowmap.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 <QtQuick3DRuntimeRender/private/qssgrenderlayer_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrendershadowmap_p.h>

#include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>

#include "qssgrendercontextcore.h"

QT_BEGIN_NAMESPACE

namespace AtlasHelpers {

struct ShelfPacker {

    struct Shelf {

        int y;

        int height;

        int curX;

};

    struct ShelfPage {

        int pageIndex;

        int width;

        int height;

        int curY;

        std::vector<Shelf> shelves;

};

    struct AtlasPlacement {

        bool success;

        int pageIndex;

        int x;

        int y;

};

    const int pageWidth;

    const int pageHeight;

    std::vector<ShelfPage> pages;

    ShelfPacker(int pageWidth, int pageHeight)

        : pageWidth(pageWidth)

        , pageHeight(pageHeight)

    AtlasPlacement addRectangle(int sizeNeeded) {

        // Try each page in turn

        for (auto &page : pages) {

            AtlasPlacement placement = placeOnPage(page, sizeNeeded);

            if (placement.success)

                return placement;

        // If we get here, we need a new page

        ShelfPage newPage;

        newPage.pageIndex = int(pages.size());

        newPage.width = pageWidth;

        newPage.height = pageHeight;

        newPage.curY = 0;

        newPage.shelves.clear();

        pages.push_back(newPage);

        // now place in the new page

        return placeOnPage(pages.back(), sizeNeeded);

    AtlasPlacement placeOnPage(ShelfPage &page, int sizeNeeded)

        AtlasPlacement result;

        result.success = false;

        // Iterate over shelves to see if we can place the rect

        for (auto &shelf : page.shelves) {

            // check if it fits horizontally

            if (shelf.curX + sizeNeeded <= page.width) {

                // also check if the shelf's height is enough

                // but here we store the shelf's "height" as the max of the rectangles' heights

                // If each rect is the same "sizeNeeded," we just need to see if there's room in page.height

                // not enough vertical space

                if (shelf.y + shelf.height >= page.height)

                    continue;

                // place here

                result.success = true;

                result.pageIndex = page.pageIndex;

                result.x = shelf.curX;

                result.y = shelf.y;

                // update shelf

                shelf.curX += sizeNeeded;

                if (sizeNeeded > shelf.height)

                    shelf.height = sizeNeeded;

                return result;

        // No existing shelf had space, so start a new shelf

        int newShelfY = 0;

        if (!page.shelves.empty()) {

            const Shelf &lastShelf = page.shelves.back();

            newShelfY = lastShelf.y + lastShelf.height;

        // check if there's enough space left in the page vertically

        if (newShelfY + sizeNeeded > page.height) {

            // no space in this page

            return result; // success = false

        // create a new shelf

        Shelf newShelf;

        newShelf.y = newShelfY;

        newShelf.height = sizeNeeded;

        newShelf.curX = 0;

        page.shelves.push_back(newShelf);

        // place rect at top-left of this shelf

        Shelf &shelfRef = page.shelves.back();

        result.success = true;

        result.pageIndex = page.pageIndex;

        result.x = shelfRef.curX;

        result.y = shelfRef.y;

        shelfRef.curX += sizeNeeded;

        return result;

    int pagesNeeded() const { return int(pages.size()); }

};

static QRhiTexture *allocateRhiShadowTexture(QRhi *rhi, QRhiTexture::Format format, const QSize &size, quint32 numLayers, QRhiTexture::Flags flags)

    auto texture = rhi->newTexture(format, size, 1, flags);

    if (flags & QRhiTexture::TextureArray)

        texture->setArraySize(numLayers);

    if (!texture->create())

        qWarning("Failed to create shadow map texture of size %dx%d", size.width(), size.height());

    return texture;

static QRhiRenderBuffer *allocateRhiShadowRenderBuffer(QRhi *rhi, QRhiRenderBuffer::Type type, const QSize &size)

    auto renderBuffer = rhi->newRenderBuffer(type, size, 1);

    if (!renderBuffer->create())

        qWarning("Failed to build depth-stencil buffer of size %dx%d", size.width(), size.height());

    return renderBuffer;

static bool checkCompatibility(QSSGShadowMapEntry *entry, const QVector<QSSGShadowMapEntry::AtlasEntry> &atlasEntries) {

    if (!entry)

        return false;

    for (int i = 0; i < atlasEntries.size(); ++i) {

        const auto &atlasEntry = atlasEntries.at(i);

        if (!(entry->m_atlasInfo[i].layerIndex == atlasEntry.layerIndex &&

              qFuzzyCompare(entry->m_atlasInfo[i].uOffset, atlasEntry.uOffset) &&

              qFuzzyCompare(entry->m_atlasInfo[i].vOffset, atlasEntry.vOffset) &&

              qFuzzyCompare(entry->m_atlasInfo[i].uvScale, atlasEntry.uvScale)))

            return false;

    return true;

static QVector<QSSGShadowMapEntry::AtlasEntry> createAtlasEntries(const QVarLengthArray<AtlasHelpers::ShelfPacker::AtlasPlacement, 4> &atlasPlacements, int entrySize, int atlasPageSize) {

    QVector<QSSGShadowMapEntry::AtlasEntry> atlasEntries;

    atlasEntries.reserve(atlasPlacements.size());

    for (int i = 0; i < atlasPlacements.size(); ++i) {

        const auto &placement = atlasPlacements.at(i);

        const float x = float(placement.x) / float(atlasPageSize);

        const float y = float(placement.y) / float(atlasPageSize);

        const float uvScale = float(entrySize) / float(atlasPageSize);

        atlasEntries.append({placement.pageIndex, x, y, uvScale});

    return atlasEntries;

QSSGRenderShadowMap::QSSGRenderShadowMap(const QSSGRenderContextInterface &inContext)

    : m_context(inContext)

QSSGRenderShadowMap::~QSSGRenderShadowMap()

    releaseCachedResources();

void QSSGRenderShadowMap::releaseCachedResources()

    for (QSSGShadowMapEntry &entry : m_shadowMapList)

        entry.destroyRhiResources();

    if (m_shadowMapAtlasTexture)

        m_shadowMapAtlasTexture.reset();

    if (m_shadowMapBlueNoiseTexture)

        m_shadowMapBlueNoiseTexture.reset();

    qDeleteAll(m_layerDepthStencilBuffers);

    m_layerDepthStencilBuffers.clear();

    qDeleteAll(m_layerRenderTargets);

    m_layerRenderTargets.clear();

    qDeleteAll(m_layerRenderPassDescriptors);

    m_layerRenderPassDescriptors.clear();

    m_shadowMapList.clear();

void QSSGRenderShadowMap::addShadowMaps(const QSSGShaderLightList &renderableLights)

    QRhi *rhi = m_context.rhiContext()->rhi();

    // Bail out if there is no QRhi, since we can't add entries without it

    if (!rhi)

        return;

    // Handle blue noise texture

    if (!m_shadowMapBlueNoiseTexture) {

        // The blue noise image is based on two random blue noise images with values v0 and v1.

        // Then the cos and sin of these are stored to avoid trigonmoetric functions

        // in the shadow mapping shader.

        // R = cos(v0)

        // G = sin(v0)

        // B = cos(v1)

        // A = sin(v1)

        QImage blueNoiseImage(QStringLiteral(":/res/textures/blue_noise.png"));

        if (blueNoiseImage.isNull()) {

            qWarning("Failed to load blue noise texture!");

        } else {

            Q_ASSERT(blueNoiseImage.size() == QSize(64, 64));

            Q_ASSERT(blueNoiseImage.format() == QImage::Format_ARGB32);

            blueNoiseImage = blueNoiseImage.convertToFormat(QImage::Format_RGBA8888);

            m_shadowMapBlueNoiseTexture.reset(allocateRhiShadowTexture(rhi, QRhiTexture::RGBA8, QSize(64, 64), 0, {}));

            if (!m_shadowMapBlueNoiseTexture->create()) {

                qWarning("Failed to create blue noise texture");

            } else {

                QRhiResourceUpdateBatch *rub = rhi->nextResourceUpdateBatch();

                QRhiTextureSubresourceUploadDescription subresDesc(blueNoiseImage);

                rub->uploadTexture(m_shadowMapBlueNoiseTexture.get(),

                                   QRhiTextureUploadDescription({ QRhiTextureUploadEntry(0, 0, subresDesc) }));

                QRhiCommandBuffer *cb = m_context.rhiContext()->commandBuffer();

                cb->resourceUpdate(rub);

    const quint32 numLights = renderableLights.size();

    qsizetype numShadows = 0;

    const bool supports32BitTextures = rhi->isTextureFormatSupported(QRhiTexture::R32F);

    QRhiTexture::Format format = QRhiTexture::R16F;

    quint32 mapSize = 0;

    QHash<quint32, QVector<QSSGShadowMapEntry::AtlasEntry>> lightIndexToAtlasEntries;

    // Get format and maximum texture size needed

    for (quint32 lightIndex = 0; lightIndex < numLights; ++lightIndex) {

        const QSSGShaderLight &shaderLight = renderableLights.at(lightIndex);

        if (!shaderLight.shadows)

            continue;

        // Force R32F format if any light requests it

        if (shaderLight.light->m_use32BitShadowmap && supports32BitTextures)

            format = QRhiTexture::R32F;

        // Find the largest shadow map size needed

        if (mapSize < shaderLight.light->m_shadowMapRes)

            mapSize = shaderLight.light->m_shadowMapRes;

        numShadows += 1;

    auto atlasPacker = AtlasHelpers::ShelfPacker(mapSize, mapSize);

    // Figure out the number of layers needed for the atlas

    // including where everthing will go in the atlas

    for (quint32 lightIndex = 0; lightIndex < numLights; ++lightIndex) {

        const QSSGShaderLight &shaderLight = renderableLights.at(lightIndex);

        if (!shaderLight.shadows)

            continue;

        quint8 mapsNeeded = 0;

        if (shaderLight.light->type == QSSGRenderLight::Type::DirectionalLight)

            mapsNeeded = shaderLight.light->m_csmNumSplits + 1;

        else if (shaderLight.light->type == QSSGRenderLight::Type::SpotLight)

            mapsNeeded = 1;

        else if (shaderLight.light->type == QSSGRenderLight::Type::PointLight)

            mapsNeeded = 2;

        QVarLengthArray<AtlasHelpers::ShelfPacker::AtlasPlacement, 4> atlasPlacements;

        for (quint8 i = 0; i < mapsNeeded; ++i) {

            const int size = shaderLight.light->m_shadowMapRes;

            auto result = atlasPacker.addRectangle(size);

            if (result.success)

                atlasPlacements.push_back(result);

        lightIndexToAtlasEntries.insert(lightIndex, createAtlasEntries(atlasPlacements, shaderLight.light->m_shadowMapRes, mapSize));

    const QSize texSize = QSize(mapSize, mapSize);

    const quint32 layersNeeded = atlasPacker.pagesNeeded();

    // Check if we need a rebuild

    bool needsRebuild = numShadows != shadowMapEntryCount();

    if (!m_shadowMapAtlasTexture ||

        m_shadowMapAtlasTexture->pixelSize() != texSize ||

        m_shadowMapAtlasTexture->arraySize() != int(layersNeeded) ||

        m_shadowMapAtlasTexture->format() != format) {

        // If we need a new texture as well

        if (m_shadowMapAtlasTexture) {

            m_shadowMapAtlasTexture.reset();

        m_shadowMapAtlasTexture.reset(allocateRhiShadowTexture(rhi, format, texSize, layersNeeded, QRhiTexture::RenderTarget | QRhiTexture::TextureArray));

        qDeleteAll(m_layerDepthStencilBuffers);

        m_layerDepthStencilBuffers.clear();

        qDeleteAll(m_layerRenderTargets);

        m_layerRenderTargets.clear();

        qDeleteAll(m_layerRenderPassDescriptors);

        m_layerRenderPassDescriptors.clear();

        for (quint32 i = 0; i < layersNeeded; ++i) {

            // Recreate per layer RenderBuffers, TextureRenderTarget, and RenderPassDescriptors

            QRhiRenderBuffer *depthStencilBuffer = allocateRhiShadowRenderBuffer(rhi, QRhiRenderBuffer::DepthStencil, texSize);

            QRhiTextureRenderTargetDescription rtDesc;

            QRhiColorAttachment attachment(m_shadowMapAtlasTexture.get());

            attachment.setLayer(i);

            rtDesc.setColorAttachments({ attachment });

            rtDesc.setDepthStencilBuffer(depthStencilBuffer);

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

            rt->setDescription(rtDesc);

            rt->setFlags(QRhiTextureRenderTarget::PreserveColorContents); // Don't clear between passes since this is an atlas

            QRhiRenderPassDescriptor *rpDesc = rt->newCompatibleRenderPassDescriptor();

            rt->setRenderPassDescriptor(rpDesc);

            if (!rt->create())

                qWarning("Failed to build shadow map render target");

            rt->setName(QByteArrayLiteral("shadow map atlas layer") + QByteArray::number(i));

            m_layerDepthStencilBuffers.append(depthStencilBuffer);

            m_layerRenderTargets.append(rt);

            m_layerRenderPassDescriptors.append(rpDesc);

        needsRebuild = true;

    // If we need to allocate the RHI resources

    if (!m_sharedFrontCubeToAtlasUniformBuffer || !m_sharedBackCubeToAtlasUniformBuffer) {

        const quint32 uniformValueFront = 0;

        const quint32 uniformValueBack = 1;

        QRhiResourceUpdateBatch *rub = rhi->nextResourceUpdateBatch();

        if (!m_sharedFrontCubeToAtlasUniformBuffer) {

            m_sharedFrontCubeToAtlasUniformBuffer.reset(rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, sizeof(uint32_t)));

            m_sharedFrontCubeToAtlasUniformBuffer->create();

            rub->updateDynamicBuffer(m_sharedFrontCubeToAtlasUniformBuffer.get(), 0, sizeof(quint32), &uniformValueFront);

        if (!m_sharedBackCubeToAtlasUniformBuffer) {

            m_sharedBackCubeToAtlasUniformBuffer.reset(rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, sizeof(uint32_t)));

            m_sharedBackCubeToAtlasUniformBuffer->create();

            rub->updateDynamicBuffer(m_sharedBackCubeToAtlasUniformBuffer.get(), 0, sizeof(quint32), &uniformValueBack);

        QRhiCommandBuffer *cb = m_context.rhiContext()->commandBuffer();

        cb->resourceUpdate(rub);

    if (!m_sharedCubeToAtlasSampler) {

        m_sharedCubeToAtlasSampler.reset(rhi->newSampler(QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None, QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge));

        m_sharedCubeToAtlasSampler->create();

    if (!m_shadowClearSrb) {

        m_shadowClearSrb.reset(rhi->newShaderResourceBindings());

        m_shadowClearSrb->create();

    if (!needsRebuild) {

        // Check if relevant shadow properties has changed

        for (quint32 lightIndex = 0; lightIndex < numLights; ++lightIndex) {

            const QSSGShaderLight &shaderLight = renderableLights.at(lightIndex);

            if (!shaderLight.shadows)

                continue;

            QSSGShadowMapEntry *pEntry = shadowMapEntry(lightIndex);

            if (!pEntry) {

                needsRebuild = true;

                break;

            const auto &atlasEntires = lightIndexToAtlasEntries.value(lightIndex);

            if (!checkCompatibility(pEntry, atlasEntires)) {

                needsRebuild = true;

                break;

    if (!needsRebuild)

        return;

    // Rebuild then

    for (QSSGShadowMapEntry &entry : m_shadowMapList)

        entry.destroyRhiResources();

    m_shadowMapList.clear();

    for (quint32 lightIndex = 0; lightIndex < numLights; ++lightIndex) {

        const QSSGShaderLight &shaderLight = renderableLights.at(lightIndex);

        if (!shaderLight.shadows)

            continue;

        addShadowMap(lightIndex,

                     texSize,

                     lightIndexToAtlasEntries.value(lightIndex),

                     shaderLight.light->m_csmNumSplits,

                     format,

                     shaderLight.light->type == QSSGRenderLight::Type::PointLight,

                     shaderLight.light->debugObjectName);

QSSGShadowMapEntry *QSSGRenderShadowMap::addShadowMap(quint32 lightIdx,

                                                      QSize size,

                                                      QVector<QSSGShadowMapEntry::AtlasEntry> atlasEntries,

                                                      quint32 csmNumSplits,

                                                      QRhiTexture::Format rhiFormat,

                                                      bool isPointLight,

                                                      const QString &renderNodeObjName)

    QRhi *rhi = m_context.rhiContext()->rhi();

    QSSGShadowMapEntry *pEntry = shadowMapEntry(lightIdx);

    Q_ASSERT(rhi);

    Q_ASSERT(!pEntry);

    Q_ASSERT(!atlasEntries.isEmpty());

    m_shadowMapList.push_back(QSSGShadowMapEntry::withAtlas(lightIdx));

    pEntry = &m_shadowMapList.back();

    pEntry->m_csmNumSplits = csmNumSplits;

    if (isPointLight) {

        const QSize localSize = size * atlasEntries.first().uvScale;

        // First pass renders to depth cube map

        const QByteArray rtName = renderNodeObjName.toLatin1();

        pEntry->m_rhiDepthCube = allocateRhiShadowTexture(rhi, rhiFormat, localSize, 0, QRhiTexture::RenderTarget | QRhiTexture::CubeMap);

        pEntry->m_rhiDepthStencilCube = allocateRhiShadowRenderBuffer(rhi, QRhiRenderBuffer::DepthStencil, localSize);

        for (const auto face : QSSGRenderTextureCubeFaces) {

            QRhiTextureRenderTarget *&rt(pEntry->m_rhiRenderTargetCube[quint8(face)]);

            Q_ASSERT(!rt);

            QRhiColorAttachment att(pEntry->m_rhiDepthCube);

            att.setLayer(quint8(face)); // 6 render targets, each referencing one face of the cubemap

            QRhiTextureRenderTargetDescription rtDesc;

            rtDesc.setColorAttachments({ att });

            rtDesc.setDepthStencilBuffer(pEntry->m_rhiDepthStencilCube);

            rt = rhi->newTextureRenderTarget(rtDesc);

            rt->setDescription(rtDesc);

            if (!pEntry->m_rhiRenderPassDescCube)

                pEntry->m_rhiRenderPassDescCube = rt->newCompatibleRenderPassDescriptor();

            rt->setRenderPassDescriptor(pEntry->m_rhiRenderPassDescCube);

            if (!rt->create())

                qWarning("Failed to build shadow map render target");

            rt->setName(rtName + QByteArrayLiteral(" shadow cube face: ") + QSSGBaseTypeHelpers::displayName(face));

        if (!pEntry->m_cubeToAtlasFrontSrb) {

            pEntry->m_cubeToAtlasFrontSrb = rhi->newShaderResourceBindings();

            pEntry->m_cubeToAtlasFrontSrb->setBindings({

                QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::FragmentStage, m_sharedFrontCubeToAtlasUniformBuffer.get()),

                QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, pEntry->m_rhiDepthCube, m_sharedCubeToAtlasSampler.get())

});

            pEntry->m_cubeToAtlasFrontSrb->create();

        if (!pEntry->m_cubeToAtlasBackSrb) {

            pEntry->m_cubeToAtlasBackSrb = rhi->newShaderResourceBindings();

            pEntry->m_cubeToAtlasBackSrb->setBindings({

                    QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::FragmentStage, m_sharedBackCubeToAtlasUniformBuffer.get()),

                    QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, pEntry->m_rhiDepthCube, m_sharedCubeToAtlasSampler.get())

});

            pEntry->m_cubeToAtlasBackSrb->create();

    // Additional graphics resources: samplers, render targets.

    const quint32 entriesCount = atlasEntries.size();

    for (quint32 splitIndex = 0; splitIndex < entriesCount; splitIndex++) {

        pEntry->m_atlasInfo[splitIndex].layerIndex = atlasEntries.at(splitIndex).layerIndex;

        pEntry->m_atlasInfo[splitIndex].uOffset = atlasEntries.at(splitIndex).uOffset;

        pEntry->m_atlasInfo[splitIndex].vOffset = atlasEntries.at(splitIndex).vOffset;

        pEntry->m_atlasInfo[splitIndex].uvScale = atlasEntries.at(splitIndex).uvScale;

        quint32 layerId = atlasEntries.at(splitIndex).layerIndex;

        pEntry->m_rhiRenderTargets[splitIndex] = m_layerRenderTargets[layerId];

        pEntry->m_rhiRenderPassDesc[splitIndex] = m_layerRenderPassDescriptors[layerId];

    pEntry->m_lightIndex = lightIdx;

    return pEntry;

QSSGShadowMapEntry *QSSGRenderShadowMap::shadowMapEntry(int lightIdx)

    Q_ASSERT(lightIdx >= 0);

    for (int i = 0; i < m_shadowMapList.size(); i++) {

        QSSGShadowMapEntry *pEntry = &m_shadowMapList[i];

        if (pEntry->m_lightIndex == quint32(lightIdx))

            return pEntry;

    return nullptr;

QRhiTextureRenderTarget *QSSGRenderShadowMap::layerRenderTarget(int layerIndex)

    if (layerIndex < 0 || layerIndex >= m_layerRenderTargets.size())

        return nullptr;

    return m_layerRenderTargets.at(layerIndex);

QRhiRenderPassDescriptor *QSSGRenderShadowMap::layerRenderPassDescriptor(int layerIndex)

    if (layerIndex < 0 || layerIndex >= m_layerRenderPassDescriptors.size())

        return nullptr;

    return m_layerRenderPassDescriptors.at(layerIndex);

QRhiTexture *QSSGRenderShadowMap::shadowMapAtlasTexture() const

    return m_shadowMapAtlasTexture.get();

QRhiTexture *QSSGRenderShadowMap::shadowMapBlueNoiseTexture() const

    return m_shadowMapBlueNoiseTexture.get();

QSSGShadowMapEntry::QSSGShadowMapEntry()

    : m_lightIndex(std::numeric_limits<quint32>::max())

QSSGShadowMapEntry QSSGShadowMapEntry::withAtlas(quint32 lightIdx)

    QSSGShadowMapEntry e;

    e.m_lightIndex = lightIdx;

    return e;

void QSSGShadowMapEntry::destroyRhiResources()

    delete m_rhiDepthCube;

    m_rhiDepthCube = nullptr;

    delete m_rhiDepthStencilCube;

    m_rhiDepthStencilCube = nullptr;

    qDeleteAll(m_rhiRenderTargetCube);

    m_rhiRenderTargetCube.fill(nullptr);

    delete m_rhiRenderPassDescCube;

    m_rhiRenderPassDescCube = nullptr;

    delete m_cubeToAtlasFrontSrb;

    m_cubeToAtlasFrontSrb = nullptr;

    delete m_cubeToAtlasBackSrb;

    m_cubeToAtlasBackSrb = nullptr;

    // un-owned references

    m_rhiRenderTargets.fill(nullptr);

    m_rhiRenderPassDesc.fill(nullptr);

QT_END_NAMESPACE

Revision control

Copy as Markdown