path: root/tests/manual/shaderpoker/shaderpoker.cpp

// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "shaderpoker.h"

#include <QtQuick3DRuntimeRender/private/qssgrenderdefaultmaterialshadergenerator_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrhieffectsystem_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrhicustommaterialsystem_p.h>
#include <QtQuick3DRuntimeRender/private/qssgdebugdrawsystem_p.h>
#include <QtQuick3DRuntimeRender/ssg/qssgrendercontextcore.h>
#include <QtQuick3DRuntimeRender/private/qssgvertexpipelineimpl_p.h>

namespace {
QStringList splitIgnoringBraces(const QString &input) {
    QStringList result;
    QString currentPart;
    int braceDepth = 0;

    for (QChar c : input) {
        if (c == '{') {
            ++braceDepth;
            currentPart += c;
        } else if (c == '}') {
            --braceDepth;
            if (braceDepth < 0) {
                // because something is busted
                braceDepth = 0;
            }
            currentPart += c;
        } else if (c == ';' && braceDepth == 0) {
            result.append(currentPart);
            currentPart.clear();
        } else {
            currentPart += c;
        }
    }

    if (!currentPart.isEmpty()) {
        result.append(currentPart); // Add the last segment
    }

    return result;
}
}

ShaderPoker::ShaderPoker(QObject *parent)
    : QObject{parent}
{
    m_rhi = QRhi::create(QRhi::Null, nullptr);
    std::unique_ptr<QSSGRhiContext> rhiContext = std::make_unique<QSSGRhiContext>(m_rhi);

    m_renderContext = std::make_shared<QSSGRenderContextInterface>(std::make_unique<QSSGBufferManager>(),
                                                                    std::make_unique<QSSGRenderer>(),
                                                                    std::make_shared<QSSGShaderLibraryManager>(),
                                                                    std::make_unique<QSSGShaderCache>(*rhiContext),
                                                                    std::make_unique<QSSGCustomMaterialSystem>(),
                                                                    std::make_unique<QSSGProgramGenerator>(),
                                                                    std::move(rhiContext));

    m_material = new QSSGRenderDefaultMaterial(QSSGRenderGraphObject::Type::DefaultMaterial);

    connect(this, &ShaderPoker::shaderIndexChanged, this, &ShaderPoker::fragmentShaderChanged);
    connect(this, &ShaderPoker::shaderIndexChanged, this, &ShaderPoker::vertexShaderChanged);

    // points to builtin
    setShaderProperties(&m_builtinProperties);
    generateShader();
}

ShaderPoker::~ShaderPoker()
{
    delete m_material;
}

void ShaderPoker::generateShader()
{
    const auto &shaderLibraryManager = m_renderContext->shaderLibraryManager();
    const auto &shaderCache = m_renderContext->shaderCache();
    const auto &shaderProgramGenerator = m_renderContext->shaderProgramGenerator();
    const auto &renderer = m_renderContext->renderer();

    QSSGRenderModel renderModel;
    QSSGRenderSubset renderSubset;
    QSSGModelContext modelContext(renderModel, QMatrix4x4(), QSSGRenderCameraDataList());
    QSSGShaderLightListView lights;
    QSSGRenderableImage *images = nullptr;

    QSSGShaderDefaultMaterialKey shaderKey;
    QSSGSubsetRenderable renderable(QSSGRenderableObject::Type::DefaultMaterialMeshSubset,
                                    QSSGRenderableObjectFlags(),
                                    QVector3D(),
                                    &*renderer,
                                    renderSubset,
                                    modelContext,
                                    1,
                                    0,
                                    *m_material,
                                    images,
                                    m_shaderProperties->key(),
                                    lights,
                                    false);

    QByteArray materialInfoString;
    m_currentShaderPipeline = QSSGRendererPrivate::generateRhiShaderPipelineImpl(renderable,
                                                                                 *shaderLibraryManager,
                                                                                 *shaderCache,
                                                                                 *shaderProgramGenerator,
                                                                                 m_shaderProperties->properties(),
                                                                                 m_featureSet,
                                                                                 materialInfoString);

    QSSGShaderCacheKey cacheKey(materialInfoString);
    cacheKey.m_features = m_featureSet;
    cacheKey.updateHashCode();
    const auto theIter = m_generatedShaderCodeCache.constFind(cacheKey);
    if (theIter != m_generatedShaderCodeCache.constEnd()) {
        auto &shaderCode = theIter.value();
        // Add it to the list
        m_vertexShader = shaderCode.first;
        m_fragmentShader = shaderCode.second;
    } else {
        // put it in the cache instead
        auto shaderCodePair = std::pair<QString, QString>(QString::fromLocal8Bit(shaderProgramGenerator->m_vs.m_finalBuilder.constData()),
                                                          QString::fromLocal8Bit(shaderProgramGenerator->m_fs.m_finalBuilder.constData()));
        m_generatedShaderCodeCache.insert(cacheKey, shaderCodePair);
        m_vertexShader = shaderCodePair.first;
        m_fragmentShader = shaderCodePair.second;
    }

    emit vertexShaderChanged();
    emit fragmentShaderChanged();


    //qDebug() << test->fragmentStage()->shader().availableShaders();

    m_shaderKey = QString::fromLocal8Bit(materialInfoString);
    emit shaderKeyChanged();
    m_shaderKeysList = splitIgnoringBraces(m_shaderKey);
    emit shaderKeysListChanged();

    updateAvailableShadersList();

    // // m_vertexShader = QString::fromLocal8Bit(shaderProgramGenerator->m_vs.m_finalBuilder.constData());
    // m_vertexShader = test->vertexStage()->shader().shader(test->vertexStage()->shader().availableShaders().last()).shader();
    // emit vertexShaderChanged();

    // // m_fragmentShader = QString::fromLocal8Bit(shaderProgramGenerator->m_fs.m_finalBuilder.constData());
    // m_fragmentShader = test->fragmentStage()->shader().shader(test->fragmentStage()->shader().availableShaders().last()).shader();
    // emit fragmentShaderChanged();
}

QString ShaderPoker::vertexShader() const
{
    if (m_shaderIndex == 0)
        return m_vertexShader;

    int index = m_shaderIndex - 1;
    if (index >= m_availableShadersList.size() || index < 0)
        return QString();


    return QString::fromLocal8Bit(m_currentShaderPipeline->vertexStage()->shader().shader(m_currentShaderPipeline->vertexStage()->shader().availableShaders().at(index)).shader());
}

QString ShaderPoker::fragmentShader() const
{
    if (m_shaderIndex == 0)
        return m_fragmentShader;

    int index = m_shaderIndex - 1;
    if (index >= m_availableShadersList.size() || index < 0)
        return QString();

    return QString::fromLocal8Bit(m_currentShaderPipeline->fragmentStage()->shader().shader(m_currentShaderPipeline->fragmentStage()->shader().availableShaders().at(index)).shader());
}

QString ShaderPoker::shaderKey() const
{
    return m_shaderKey;
}

QStringList ShaderPoker::shaderKeysList() const
{
    return m_shaderKeysList;
}

ShaderPoker::MaterialType ShaderPoker::materialType() const
{
    return m_materialType;
}

void ShaderPoker::setMaterialType(const MaterialType &newMaterialType)
{
    if (m_materialType == newMaterialType)
        return;
    m_materialType = newMaterialType;

    delete m_material;
    if (m_materialType == MaterialType::Default)
        m_material = new QSSGRenderDefaultMaterial(QSSGRenderGraphObject::Type::DefaultMaterial);
    else if (m_materialType == MaterialType::Principled) {
        m_material = new QSSGRenderDefaultMaterial(QSSGRenderGraphObject::Type::PrincipledMaterial);
    } else if (m_materialType == MaterialType::SpecularGlossy) {
        m_material = new QSSGRenderDefaultMaterial(QSSGRenderGraphObject::Type::SpecularGlossyMaterial);
    }

    emit materialTypeChanged();

    generateShader();
}

quint32 ShaderPoker::featureBitfield() const
{
    return m_featureBitfield;
}

void ShaderPoker::setFeatureBitfield(quint32 newFeatureBitfield)
{
    if (m_featureBitfield == newFeatureBitfield)
        return;
    m_featureBitfield = newFeatureBitfield;
    emit featureBitfieldChanged();

    m_featureSet.flags = newFeatureBitfield;
    generateShader();
}

QStringList ShaderPoker::availableShadersList() const
{
    return m_availableShadersList;
}

void ShaderPoker::updateAvailableShadersList()
{
    m_availableShadersList.clear();
    m_availableShadersList.append("Original");

    if (m_currentShaderPipeline) {
        const auto &availableShaders = m_currentShaderPipeline->fragmentStage()->shader().availableShaders();
        for (const QShaderKey &shaderKey : availableShaders) {
            QString source;
            QString version;

            switch (shaderKey.source()) {
            case QShader::SpirvShader:
                source = "SPIR-V";
                break;
            case QShader::GlslShader:
                source = "GLSL";
                break;
            case QShader::HlslShader:
                source = "HLSL";
                break;
            case QShader::DxbcShader:
                source = "DXBC";
                break;
            case QShader::MslShader:
                source = "MSL";
                break;
            case QShader::DxilShader:
                source = "DXIL";
                break;
            case QShader::MetalLibShader:
                source = "MetalLib";
                break;
            case QShader::WgslShader:
                source = "WGSL";
                break;
            }
            version = QString::number(shaderKey.sourceVersion().version());

            m_availableShadersList.append(source + " Version: " + version);
        }
    }

    emit availableShadersListChanged();
}

int ShaderPoker::shaderIndex() const
{
    return m_shaderIndex;
}

void ShaderPoker::setShaderIndex(int newShaderIndex)
{
    if (m_shaderIndex == newShaderIndex)
        return;
    m_shaderIndex = newShaderIndex;
    emit shaderIndexChanged();
}

DefaultMaterialShaderProperties *ShaderPoker::shaderProperties() const
{
    return m_shaderProperties;
}

void ShaderPoker::setShaderProperties(DefaultMaterialShaderProperties *newShaderProperties)
{
    if (m_shaderProperties == newShaderProperties)
        return;

    if (m_shaderPropertiesDirtyConnection)
        disconnect(m_shaderPropertiesDirtyConnection);

    if (newShaderProperties == nullptr)
        m_shaderProperties = &m_builtinProperties;
    else
        m_shaderProperties = newShaderProperties;

    m_shaderPropertiesDirtyConnection = connect(m_shaderProperties, &DefaultMaterialShaderProperties::shaderKeyUpdated, this, &ShaderPoker::shaderPropertiesDirty);

    emit shaderPropertiesChanged();
    generateShader();
}

void ShaderPoker::shaderPropertiesDirty()
{
    generateShader();
}