Revision control
Copy as Markdown
// 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(), QMatrix3x3(), QSSGRenderMvpArray());
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,
{ /* augmented shader */ },
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;
// This doesn't really matter in practice
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();
}