qssgrendermotionvectormap.cpp

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

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

// Qt-Security score:significant reason:default

#include <ssg/qssgrendercontextcore.h>

#include <QtQuick3DRuntimeRender/private/qssgrenderlayer_p.h>

#include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrendermotionvectormap_p.h>

QT_BEGIN_NAMESPACE

QSSGRenderMotionVectorMap::QSSGRenderMotionVectorMap(const QSSGRenderContextInterface &inContext)

    : m_context(inContext)

QSSGRenderMotionVectorMap::~QSSGRenderMotionVectorMap()

    releaseCachedResources();

void QSSGRenderMotionVectorMap::endFrame()

    cleanupStaleEntries();

static void copyToTextureData(QSSGRenderTextureData *dst, QSSGRenderTextureData *src) {

    dst->setTextureData(src->textureData());

    dst->setDepth(src->depth());

    dst->setFormat(src->format());

    dst->setHasTransparency(src->hasTransparency());

    dst->setSize(src->size());

static void copyToTextureData(QSSGRenderTextureData *dst, QSSGRenderInstanceTable *src) {

    dst->setDepth(0);

    dst->setFormat(QSSGRenderTextureFormat::RGBA32F);

    dst->setHasTransparency(false);

    auto instanceCount = src->count();

    int totalPixels = qMax(instanceCount * 4, 1);

    int width = qCeil(qSqrt(static_cast<float>(totalPixels)));

    int height = qCeil(static_cast<float>(totalPixels) / width);

    dst->setSize(QSize(width, height));

    QByteArray instanceBuffer(width * height * 4 * sizeof(float), Qt::Uninitialized);

    float *ptr = reinterpret_cast<float*>(instanceBuffer.data());

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

        memcpy(ptr + i * 16, src->getTransform(i).constData(), 16 * sizeof(float));

    dst->setTextureData(instanceBuffer);

static void copyToTextureData(QSSGRenderTextureData *dst, const QVector<float> &src) {

    dst->setDepth(0);

    dst->setFormat(QSSGRenderTextureFormat::R32F);

    dst->setHasTransparency(false);

    dst->setSize(QSize(src.count(), 1));

    QByteArray textureData(reinterpret_cast<const char*>(src.constData()), src.count() * sizeof(float));

    dst->setTextureData(textureData);

QSSGRenderImageTexture QSSGRenderMotionVectorMap::loadAndReleaseIfNeeded(const std::shared_ptr<QSSGRenderTextureData>& textureData, QSize lastSize)

    if (!textureData)

        return QSSGRenderImageTexture();

    auto texture = m_context.bufferManager()->loadTextureData(textureData.get(), QSSGBufferManager::MipModeDisable);

    // the only thing might to force to recreate new texture is changing the texture data size

    // so we should release last one

    if (lastSize != textureData->size()) {

        m_context.bufferManager()->releaseTextureData(

                QSSGBufferManager::CustomImageCacheKey{

                                                         textureData.get(),

                                                         lastSize,

                                                         QSSGBufferManager::MipMode::MipModeDisable});

    return texture;

QSSGRenderMotionVectorMap::MotionResultData QSSGRenderMotionVectorMap::trackMotionData(

        const void *modelKey,

        const QMatrix4x4 &currentModelViewProjection,

        const QMatrix4x4 &currentInstanceLocal,

        const QMatrix4x4 &currentInstanceGlobal,

        QSSGRenderTextureData *currentBoneTextureData,

        QSSGRenderInstanceTable *currentInstanceTable,

        const QVector<float> &currentMorphWeights)

    auto lastFrameDataIterator = m_cache.find(modelKey);

    if (lastFrameDataIterator == m_cache.end()) {

        MotionStoreData dataToStore;

        dataToStore.prevModelViewProjection = currentModelViewProjection;

        dataToStore.prevInstanceLocal = currentInstanceLocal;

        dataToStore.prevInstanceGlobal = currentInstanceGlobal;

        dataToStore.frameAge = 0;

        dataToStore.visitedThisFrame = true;

        if (currentBoneTextureData) {

            dataToStore.prevBoneTextureData = std::make_shared<QSSGRenderTextureData>();

            copyToTextureData(dataToStore.prevBoneTextureData.get(), currentBoneTextureData);

            dataToStore.lastPrevBoneTextureDataSize = dataToStore.prevBoneTextureData->size();

        if (currentInstanceTable) {

            dataToStore.prevInstanceTextureData = std::make_shared<QSSGRenderTextureData>();

            copyToTextureData(dataToStore.prevInstanceTextureData.get(), currentInstanceTable);

            dataToStore.lastPrevInstanceTextureDataSize = dataToStore.prevInstanceTextureData->size();

        if (currentMorphWeights.size()) {

            dataToStore.currentMorphWeightTextureData = std::make_shared<QSSGRenderTextureData>();

            copyToTextureData(dataToStore.currentMorphWeightTextureData.get(), currentMorphWeights);

            dataToStore.lastCurrentMorphWeightTextureDataSize = dataToStore.currentMorphWeightTextureData->size();

            dataToStore.prevMorphWeightTextureData = std::make_shared<QSSGRenderTextureData>();

            copyToTextureData(dataToStore.prevMorphWeightTextureData.get(), currentMorphWeights);

            dataToStore.lastPrevMorphWeightTextureDataSize = dataToStore.prevMorphWeightTextureData->size();

        MotionResultData firstFrameResult = { currentModelViewProjection, currentInstanceLocal, currentInstanceGlobal,

                                              loadAndReleaseIfNeeded(dataToStore.prevBoneTextureData, dataToStore.lastPrevBoneTextureDataSize),

                                              loadAndReleaseIfNeeded(dataToStore.prevInstanceTextureData, dataToStore.lastPrevInstanceTextureDataSize),

                                              loadAndReleaseIfNeeded(dataToStore.currentMorphWeightTextureData, dataToStore.lastCurrentMorphWeightTextureDataSize),

                                              loadAndReleaseIfNeeded(dataToStore.prevMorphWeightTextureData, dataToStore.lastPrevMorphWeightTextureDataSize) };

        dataToStore.cachedResult = firstFrameResult;

        m_cache[modelKey] = dataToStore;

        return firstFrameResult;

    if (lastFrameDataIterator->visitedThisFrame)

        return lastFrameDataIterator->cachedResult;

    MotionResultData motionResult;

    motionResult.prevModelViewProjection = lastFrameDataIterator->prevModelViewProjection;

    lastFrameDataIterator->prevModelViewProjection = currentModelViewProjection;

    motionResult.prevInstanceLocal = lastFrameDataIterator->prevInstanceLocal;

    lastFrameDataIterator->prevInstanceLocal = currentInstanceLocal;

    motionResult.prevInstanceGlobal = lastFrameDataIterator->prevInstanceGlobal;

    lastFrameDataIterator->prevInstanceGlobal = currentInstanceGlobal;

    motionResult.prevBoneTexture = loadAndReleaseIfNeeded(

            lastFrameDataIterator->prevBoneTextureData,

            lastFrameDataIterator->lastPrevBoneTextureDataSize);

    motionResult.prevInstanceTexture = loadAndReleaseIfNeeded(

            lastFrameDataIterator->prevInstanceTextureData,

            lastFrameDataIterator->lastPrevInstanceTextureDataSize);

    motionResult.prevMorphWeightTexture = loadAndReleaseIfNeeded(

            lastFrameDataIterator->prevMorphWeightTextureData,

            lastFrameDataIterator->lastPrevMorphWeightTextureDataSize);

    motionResult.currentMorphWeightTexture = loadAndReleaseIfNeeded(

            lastFrameDataIterator->currentMorphWeightTextureData,

            lastFrameDataIterator->lastCurrentMorphWeightTextureDataSize);

    if (currentBoneTextureData) {

        if (!lastFrameDataIterator->prevBoneTextureData)

            lastFrameDataIterator->prevBoneTextureData = std::make_shared<QSSGRenderTextureData>();

        lastFrameDataIterator->lastPrevBoneTextureDataSize = lastFrameDataIterator->prevBoneTextureData->size();

        copyToTextureData(lastFrameDataIterator->prevBoneTextureData.get(), currentBoneTextureData);

    if (currentInstanceTable) {

        if (!lastFrameDataIterator->prevInstanceTextureData)

            lastFrameDataIterator->prevInstanceTextureData = std::make_shared<QSSGRenderTextureData>();

        lastFrameDataIterator->lastPrevInstanceTextureDataSize = lastFrameDataIterator->prevInstanceTextureData->size();

        copyToTextureData(lastFrameDataIterator->prevInstanceTextureData.get(), currentInstanceTable);

    if (currentMorphWeights.size()) {

        if (!lastFrameDataIterator->prevMorphWeightTextureData)

            lastFrameDataIterator->prevMorphWeightTextureData = std::make_shared<QSSGRenderTextureData>();

        lastFrameDataIterator->lastPrevMorphWeightTextureDataSize = lastFrameDataIterator->prevMorphWeightTextureData->size();

        if (lastFrameDataIterator->currentMorphWeightTextureData)

            copyToTextureData(lastFrameDataIterator->prevMorphWeightTextureData.get(), lastFrameDataIterator->currentMorphWeightTextureData.get());

        else

            copyToTextureData(lastFrameDataIterator->prevMorphWeightTextureData.get(), currentMorphWeights);

        if (!lastFrameDataIterator->currentMorphWeightTextureData)

            lastFrameDataIterator->currentMorphWeightTextureData = std::make_shared<QSSGRenderTextureData>();

        lastFrameDataIterator->lastCurrentMorphWeightTextureDataSize = lastFrameDataIterator->currentMorphWeightTextureData->size();

        copyToTextureData(lastFrameDataIterator->currentMorphWeightTextureData.get(), currentMorphWeights);

    lastFrameDataIterator->frameAge = 0;

    lastFrameDataIterator->visitedThisFrame = true;

    lastFrameDataIterator->cachedResult = motionResult;

    return motionResult;

void QSSGRenderMotionVectorMap::releaseEntryResources(MotionStoreData& entry)

    if (entry.prevBoneTextureData)

        m_context.bufferManager()->releaseTextureData(entry.prevBoneTextureData.get());

    if (entry.prevInstanceTextureData)

        m_context.bufferManager()->releaseTextureData(entry.prevInstanceTextureData.get());

    if (entry.prevMorphWeightTextureData)

        m_context.bufferManager()->releaseTextureData(entry.prevMorphWeightTextureData.get());

    if (entry.currentMorphWeightTextureData)

        m_context.bufferManager()->releaseTextureData(entry.currentMorphWeightTextureData.get());

void QSSGRenderMotionVectorMap::releaseCachedResources()

    for (auto& entry : m_cache)

        releaseEntryResources(entry);

    m_cache.clear();

void QSSGRenderMotionVectorMap::cleanupStaleEntries()

    constexpr int maxFrameAge = 2;

    auto it = m_cache.begin();

    while (it != m_cache.end()) {

        it->visitedThisFrame = false;

        it->frameAge++;

        if (it->frameAge > maxFrameAge) {

            releaseEntryResources(*it);

            it = m_cache.erase(it);

        } else {

            ++it;

QT_END_NAMESPACE

Revision control

Copy as Markdown