path: root/src/render/materialsystem/shaderdata.cpp

// Copyright (C) 2014 Klaralvdalens Datakonsult AB (KDAB).
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

#include "shaderdata_p.h"
#include "qshaderdata.h"
#include "qshaderdata_p.h"
#include <QMetaProperty>
#include <QMetaObject>
#include <private/qbackendnode_p.h>
#include <private/managers_p.h>
#include <private/nodemanagers_p.h>
#include <Qt3DRender/private/stringtoint_p.h>

QT_BEGIN_NAMESPACE

namespace Qt3DRender {
namespace Render {

using namespace Qt3DCore;

namespace {

const int qNodeIdTypeId = qMetaTypeId<Qt3DCore::QNodeId>();

}

ShaderData::ShaderData()
    : m_managers(nullptr)
{
}

ShaderData::~ShaderData()
{
}

void ShaderData::setManagers(NodeManagers *managers)
{
    m_managers = managers;
}

void ShaderData::syncFromFrontEnd(const QNode *frontEnd, bool firstTime)
{
    const QShaderData *node = qobject_cast<const QShaderData *>(frontEnd);
    if (!node)
        return;
    BackendNode::syncFromFrontEnd(frontEnd, firstTime);

    if (firstTime) {
        m_propertyReader = node->propertyReader();
        m_blockNameToPropertyValues.clear();

        const QMetaObject *metaObj = node->metaObject();
        const int propertyOffset = QShaderData::staticMetaObject.propertyOffset();
        const int propertyCount = metaObj->propertyCount();
        // Dynamic properties names
        const auto dynamicPropertyNames = node->dynamicPropertyNames();

        QList<QString> propertyNames;
        propertyNames.reserve(propertyCount - propertyOffset + dynamicPropertyNames.size());

        // Statiically defined properties
        for (int i = propertyOffset; i < propertyCount; ++i) {
            const QMetaProperty pro = metaObj->property(i);
            if (pro.isWritable())
                propertyNames.push_back(QString::fromLatin1(pro.name()));
        }
        // Dynamic properties
        for (const QByteArray &propertyName : dynamicPropertyNames)
            propertyNames.push_back(QString::fromLatin1(propertyName));

        for (const QString &propertyName : propertyNames) {
            if (propertyName == QStringLiteral("data") ||
                    propertyName == QStringLiteral("objectName") ||
                    propertyName == QStringLiteral("childNodes")) // We don't handle default Node properties
                continue;

            const QVariant &propertyValue = m_propertyReader->readProperty(node->property(propertyName.toLatin1()));
            bool isNode = false;
            bool isTransformed = false;
            bool isArray = false;

            // We check if the property is a QNodeId
            isNode = (propertyValue.userType() == qNodeIdTypeId);
            // We check if QList<QNodeId>
            if (propertyValue.userType() == QMetaType::QVariantList) {
                isArray = true;
                QVariantList list = propertyValue.value<QVariantList>();
                if (list.size() > 0 && list.at(0).userType() == qNodeIdTypeId)
                    isNode = true;
            }

            // We check if property is a Transformed property
            QString transformedPropertyName;
            if (propertyValue.userType() == QMetaType::QVector3D) {
                // if there is a matching QShaderData::TransformType propertyTransformed
                transformedPropertyName = propertyName + QLatin1String("Transformed");
                isTransformed = propertyNames.contains(transformedPropertyName);
                if (!isTransformed)
                    transformedPropertyName.clear();
            }
            m_originalProperties.insert(propertyName, { propertyValue, isNode, isArray, isTransformed, transformedPropertyName });
        }
        BackendNode::markDirty(AbstractRenderer::ParameterDirty);
    } else {
        // Updates
        if (!m_propertyReader.isNull()) {
            auto it = m_originalProperties.begin();
            const auto end = m_originalProperties.end();

            while (it != end) {
                const QVariant newValue = m_propertyReader->readProperty(node->property(it.key().toLatin1()));
                PropertyValue &propValue = it.value();
                if (propValue.value != newValue) {
                    // Note we aren't notified about nested QShaderData in this call
                    // only scalar / vec properties
                    propValue.value = newValue;
                    BackendNode::markDirty(AbstractRenderer::ParameterDirty);
                }
                ++it;
            }
        }
    }
}

const ShaderData::PropertyValuesForBlock &ShaderData::propertyValuesForBlock(int blockName) const
{
    std::shared_lock readLocker(m_lock);
    return m_blockNameToPropertyValues.at(blockName);
}

void ShaderData::generatePropertyValuesForBlockIfNeeded(const QString &fullBlockName)
{
    const int fullBlockNameId = StringToInt::lookupId(fullBlockName);

    std::unique_lock readWriteLocker(m_lock);
    const bool hasPropertyValuesForBlock = m_blockNameToPropertyValues.find(fullBlockNameId) != m_blockNameToPropertyValues.cend();
    if (hasPropertyValuesForBlock) {
        return;
    }

    const QHash<QString, ShaderData::PropertyValue> &props = properties();

    ShaderData::PropertyValuesForBlock valueBlock;
    valueBlock.reserve(props.size());

    auto it = props.cbegin();
    const auto end = props.cend();
    while (it != end) {
        QString propertyName = it.key();
        // If we are dealing with a nested value, check if it is an an array
        if (it->isArray && !it->isNode)
            propertyName += QLatin1String("[0]");

        QString fullPropertyName;
        fullPropertyName.reserve(fullBlockName.size() + 1 + it.key().size());
        fullPropertyName.append(fullBlockName);
        fullPropertyName.append(QLatin1String("."));
        fullPropertyName.append(propertyName);

        // We only do this for properties on root level
        valueBlock.push_back({ StringToInt::lookupId(fullPropertyName),
                               StringToInt::lookupId(propertyName),
                               it.operator ->() });
        ++it;
    }

    m_blockNameToPropertyValues[StringToInt::lookupId(fullBlockName)] = std::move(valueBlock);
}

ShaderData *ShaderData::lookupResource(NodeManagers *managers, QNodeId id)
{
    return managers->shaderDataManager()->lookupResource(id);
}

ShaderData *ShaderData::lookupResource(QNodeId id)
{
    return ShaderData::lookupResource(m_managers, id);
}

// RenderCommand updater jobs
QVariant ShaderData::getTransformedProperty(const PropertyValue *v, const Matrix4x4 &viewMatrix) const noexcept
{
    // Note protecting m_worldMatrix at this point as we assume all world updates
    // have been performed when reaching this point
    if (v->isTransformed) {
        const auto transformedIt = m_originalProperties.constFind(v->transformedPropertyName);
        if (transformedIt != m_originalProperties.constEnd()) {
            const PropertyValue &transformedValue = transformedIt.value();
            const TransformType transformType = static_cast<TransformType>(transformedValue.value.toInt());
            switch (transformType) {
            case ModelToEye:
                return QVariant::fromValue(viewMatrix.map(m_worldMatrix.map(Vector3D(v->value.value<QVector3D>()))));
            case ModelToWorld:
                return QVariant::fromValue(m_worldMatrix.map(Vector3D(v->value.value<QVector3D>())));
            case ModelToWorldDirection:
                return QVariant::fromValue(Vector3D(m_worldMatrix * Vector4D(v->value.value<QVector3D>(), 0.0f)));
            case NoTransform:
                break;
            }
        }
    }
    return v->value;
}

// Unit tests only
ShaderData::TransformType ShaderData::propertyTransformType(const QString &name) const
{
    const auto it = m_originalProperties.constFind(name);
    if (it != m_originalProperties.constEnd()) {
        const PropertyValue &propertyValue = it.value();
        if (propertyValue.isTransformed) {
            auto transformedIt = m_originalProperties.constFind(name + QLatin1String("Transformed"));
            if (transformedIt != m_originalProperties.end())
                return static_cast<TransformType>(transformedIt.value().value.toInt());
        }
    }
    return NoTransform;
}

// Called by FramePreparationJob or by RenderView when dealing with lights
void ShaderData::updateWorldTransform(const Matrix4x4 &worldMatrix)
{
    if (m_worldMatrix != worldMatrix) {
        m_worldMatrix = worldMatrix;
    }
}

RenderShaderDataFunctor::RenderShaderDataFunctor(AbstractRenderer *renderer, NodeManagers *managers)
    : m_managers(managers)
    , m_renderer(renderer)
{
}

Qt3DCore::QBackendNode *RenderShaderDataFunctor::create(Qt3DCore::QNodeId id) const
{
    ShaderData *backend = m_managers->shaderDataManager()->getOrCreateResource(id);
    backend->setManagers(m_managers);
    backend->setRenderer(m_renderer);
    return backend;
}

Qt3DCore::QBackendNode *RenderShaderDataFunctor::get(Qt3DCore::QNodeId id) const
{
    return m_managers->shaderDataManager()->lookupResource(id);
}

void RenderShaderDataFunctor::destroy(Qt3DCore::QNodeId id) const
{
    m_managers->shaderDataManager()->releaseResource(id);
}

} // namespace Render
} // namespace Qt3DRender

QT_END_NAMESPACE