Revision control
Copy as Markdown
// 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
/* clang-format off */
#include <QtQuick3DRuntimeRender/private/qssgshadermaterialadapter_p.h>
#include "qssgrendercontextcore.h"
#include <QtQuick3DRuntimeRender/private/qssgrhicustommaterialsystem_p.h>
QT_BEGIN_NAMESPACE
QSSGShaderMaterialAdapter::~QSSGShaderMaterialAdapter() = default;
QSSGShaderMaterialAdapter *QSSGShaderMaterialAdapter::create(const QSSGRenderGraphObject &materialNode)
{
switch (materialNode.type) {
case QSSGRenderGraphObject::Type::DefaultMaterial:
case QSSGRenderGraphObject::Type::PrincipledMaterial:
case QSSGRenderGraphObject::Type::SpecularGlossyMaterial:
return new QSSGShaderDefaultMaterialAdapter(static_cast<const QSSGRenderDefaultMaterial &>(materialNode));
case QSSGRenderGraphObject::Type::CustomMaterial:
return new QSSGShaderCustomMaterialAdapter(static_cast<const QSSGRenderCustomMaterial &>(materialNode));
default:
break;
}
return nullptr;
}
bool QSSGShaderMaterialAdapter::isUnshaded()
{
return false;
}
bool QSSGShaderMaterialAdapter::hasCustomShaderSnippet(QSSGShaderCache::ShaderType)
{
return false;
}
QByteArray QSSGShaderMaterialAdapter::customShaderSnippet(QSSGShaderCache::ShaderType,
QSSGShaderLibraryManager &,
bool)
{
return QByteArray();
}
bool QSSGShaderMaterialAdapter::hasCustomShaderFunction(QSSGShaderCache::ShaderType,
const QByteArray &,
QSSGShaderLibraryManager &)
{
return false;
}
void QSSGShaderMaterialAdapter::setCustomPropertyUniforms(char *,
QSSGRhiShaderPipeline &,
const QSSGRenderContextInterface &)
{
}
bool QSSGShaderMaterialAdapter::usesSharedVariables()
{
return false;
}
QSSGShaderDefaultMaterialAdapter::QSSGShaderDefaultMaterialAdapter(const QSSGRenderDefaultMaterial &material)
: m_material(material)
{
}
bool QSSGShaderDefaultMaterialAdapter::isPrincipled()
{
return m_material.type == QSSGRenderGraphObject::Type::PrincipledMaterial;
}
bool QSSGShaderDefaultMaterialAdapter::isSpecularGlossy()
{
return m_material.type == QSSGRenderGraphObject::Type::SpecularGlossyMaterial;
}
bool QSSGShaderDefaultMaterialAdapter::isMetalnessEnabled()
{
return m_material.isMetalnessEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isSpecularEnabled()
{
return m_material.isSpecularEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isVertexColorsEnabled()
{
return m_material.isVertexColorsEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isVertexColorsMaskEnabled()
{
return m_material.isVertexColorsMaskEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isInvertOpacityMapValue()
{
return m_material.isInvertOpacityMapValue();
}
bool QSSGShaderDefaultMaterialAdapter::isBaseColorSingleChannelEnabled()
{
return m_material.isBaseColorSingleChannelEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isSpecularAmountSingleChannelEnabled()
{
return m_material.isSpecularAmountSingleChannelEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isEmissiveSingleChannelEnabled()
{
return m_material.isEmissiveSingleChannelEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isClearcoatEnabled()
{
return m_material.isClearcoatEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isSheenEnabled()
{
return m_material.isSheenEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isAnisotropyEnabled()
{
return m_material.isAnisotropyEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isIridescenceEnabled()
{
return m_material.isIridescenceEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isDispersionEnabled()
{
return m_material.isDispersionEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::isTransmissionEnabled()
{
return m_material.isTransmissionEnabled();
}
bool QSSGShaderDefaultMaterialAdapter::hasLighting()
{
return m_material.hasLighting();
}
bool QSSGShaderDefaultMaterialAdapter::usesCustomSkinning()
{
return false;
}
bool QSSGShaderDefaultMaterialAdapter::usesCustomMorphing()
{
return false;
}
QSSGRenderDefaultMaterial::MaterialSpecularModel QSSGShaderDefaultMaterialAdapter::specularModel()
{
return m_material.specularModel;
}
QSSGRenderDefaultMaterial::MaterialAlphaMode QSSGShaderDefaultMaterialAdapter::alphaMode()
{
return m_material.alphaMode;
}
QSSGRenderDefaultMaterial::VertexColorMaskFlags QSSGShaderDefaultMaterialAdapter::vertexColorRedMask()
{
return m_material.vertexColorRedMask;
}
QSSGRenderDefaultMaterial::VertexColorMaskFlags QSSGShaderDefaultMaterialAdapter::vertexColorGreenMask()
{
return m_material.vertexColorGreenMask;
}
QSSGRenderDefaultMaterial::VertexColorMaskFlags QSSGShaderDefaultMaterialAdapter::vertexColorBlueMask()
{
return m_material.vertexColorBlueMask;
}
QSSGRenderDefaultMaterial::VertexColorMaskFlags QSSGShaderDefaultMaterialAdapter::vertexColorAlphaMask()
{
return m_material.vertexColorAlphaMask;
}
QSSGRenderImage *QSSGShaderDefaultMaterialAdapter::iblProbe()
{
return m_material.iblProbe;
}
QVector3D QSSGShaderDefaultMaterialAdapter::emissiveColor()
{
return m_material.emissiveColor;
}
QVector4D QSSGShaderDefaultMaterialAdapter::color()
{
return m_material.color;
}
QVector3D QSSGShaderDefaultMaterialAdapter::specularTint()
{
return m_material.specularTint;
}
float QSSGShaderDefaultMaterialAdapter::ior()
{
return m_material.ior;
}
bool QSSGShaderDefaultMaterialAdapter::isFresnelScaleBiasEnabled()
{
return m_material.fresnelScaleBiasEnabled;
}
float QSSGShaderDefaultMaterialAdapter::fresnelScale()
{
return m_material.fresnelScale;
}
float QSSGShaderDefaultMaterialAdapter::fresnelBias()
{
return m_material.fresnelBias;
}
float QSSGShaderDefaultMaterialAdapter::fresnelPower()
{
return m_material.fresnelPower;
}
bool QSSGShaderDefaultMaterialAdapter::isClearcoatFresnelScaleBiasEnabled()
{
return m_material.clearcoatFresnelScaleBiasEnabled;
}
float QSSGShaderDefaultMaterialAdapter::clearcoatFresnelScale()
{
return m_material.clearcoatFresnelScale;
}
float QSSGShaderDefaultMaterialAdapter::clearcoatFresnelBias()
{
return m_material.clearcoatFresnelBias;
}
float QSSGShaderDefaultMaterialAdapter::clearcoatFresnelPower()
{
return m_material.clearcoatFresnelPower;
}
float QSSGShaderDefaultMaterialAdapter::metalnessAmount()
{
return m_material.metalnessAmount;
}
float QSSGShaderDefaultMaterialAdapter::specularAmount()
{
return m_material.specularAmount;
}
float QSSGShaderDefaultMaterialAdapter::specularRoughness()
{
return m_material.specularRoughness;
}
float QSSGShaderDefaultMaterialAdapter::bumpAmount()
{
return m_material.bumpAmount;
}
float QSSGShaderDefaultMaterialAdapter::translucentFallOff()
{
return m_material.translucentFalloff;
}
float QSSGShaderDefaultMaterialAdapter::diffuseLightWrap()
{
return m_material.diffuseLightWrap;
}
float QSSGShaderDefaultMaterialAdapter::occlusionAmount()
{
return m_material.occlusionAmount;
}
float QSSGShaderDefaultMaterialAdapter::alphaCutOff()
{
return m_material.alphaCutoff;
}
float QSSGShaderDefaultMaterialAdapter::pointSize()
{
return m_material.pointSize;
}
float QSSGShaderDefaultMaterialAdapter::lineWidth()
{
return m_material.lineWidth;
}
float QSSGShaderDefaultMaterialAdapter::heightAmount()
{
return m_material.heightAmount;
}
float QSSGShaderDefaultMaterialAdapter::minHeightSamples()
{
return m_material.minHeightSamples;
}
float QSSGShaderDefaultMaterialAdapter::maxHeightSamples()
{
return m_material.maxHeightSamples;
}
float QSSGShaderDefaultMaterialAdapter::clearcoatAmount()
{
return m_material.clearcoatAmount;
}
float QSSGShaderDefaultMaterialAdapter::clearcoatRoughnessAmount()
{
return m_material.clearcoatRoughnessAmount;
}
float QSSGShaderDefaultMaterialAdapter::clearcoatNormalStrength()
{
return m_material.clearcoatNormalStrength;
}
QVector3D QSSGShaderDefaultMaterialAdapter::sheenColor()
{
return m_material.sheenColor;
}
float QSSGShaderDefaultMaterialAdapter::sheenRoughness()
{
return m_material.sheenRoughness;
}
float QSSGShaderDefaultMaterialAdapter::anisotropyStrength()
{
return m_material.anisotropyStrength;
}
float QSSGShaderDefaultMaterialAdapter::anisotropyRotation()
{
return m_material.anisotropyRotation;
}
float QSSGShaderDefaultMaterialAdapter::iridescenceFactor()
{
return m_material.iridescenceFactor;
}
float QSSGShaderDefaultMaterialAdapter::iridescenceIndexOfRefraction()
{
return m_material.iridescenceIndexOfRefraction;
}
float QSSGShaderDefaultMaterialAdapter::iridescenceThicknessMinimum()
{
return m_material.iridescenceThicknessMinimum;
}
float QSSGShaderDefaultMaterialAdapter::iridescenceThicknessMaximum()
{
return m_material.iridescenceThicknessMaximum;
}
float QSSGShaderDefaultMaterialAdapter::dispersion()
{
return m_material.dispersion;
}
float QSSGShaderDefaultMaterialAdapter::transmissionFactor()
{
return m_material.transmissionFactor;
}
float QSSGShaderDefaultMaterialAdapter::thicknessFactor()
{
return m_material.thicknessFactor;
}
float QSSGShaderDefaultMaterialAdapter::attenuationDistance()
{
return m_material.attenuationDistance;
}
QVector3D QSSGShaderDefaultMaterialAdapter::attenuationColor()
{
return m_material.attenuationColor;
}
QSSGShaderCustomMaterialAdapter::QSSGShaderCustomMaterialAdapter(const QSSGRenderCustomMaterial &material)
: m_material(material)
{
}
// Act like Principled. Lighting is always on, specular, metalness, etc. support should all be enabled.
// Unlike Principled, the *enabled values do not depend on the metalness or specularAmount values
// (we cannot tell what those are if they are written in the shader).
bool QSSGShaderCustomMaterialAdapter::isPrincipled()
{
return true;
}
bool QSSGShaderCustomMaterialAdapter::isSpecularGlossy()
{
return false;
}
bool QSSGShaderCustomMaterialAdapter::isMetalnessEnabled()
{
return true;
}
bool QSSGShaderCustomMaterialAdapter::isSpecularEnabled()
{
return true;
}
bool QSSGShaderCustomMaterialAdapter::isVertexColorsEnabled()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::VarColor);
}
bool QSSGShaderCustomMaterialAdapter::isVertexColorsMaskEnabled()
{
return false;
}
bool QSSGShaderCustomMaterialAdapter::isInvertOpacityMapValue()
{
return false;
}
bool QSSGShaderCustomMaterialAdapter::isBaseColorSingleChannelEnabled()
{
return false;
}
bool QSSGShaderCustomMaterialAdapter::isSpecularAmountSingleChannelEnabled()
{
return false;
}
bool QSSGShaderCustomMaterialAdapter::isEmissiveSingleChannelEnabled()
{
return false;
}
bool QSSGShaderCustomMaterialAdapter::isClearcoatEnabled()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Clearcoat);
}
bool QSSGShaderCustomMaterialAdapter::isSheenEnabled()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Sheen);
}
bool QSSGShaderCustomMaterialAdapter::isAnisotropyEnabled()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Anisotropy);
}
bool QSSGShaderCustomMaterialAdapter::isIridescenceEnabled()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Iridescence);
}
bool QSSGShaderCustomMaterialAdapter::isDispersionEnabled()
{
// Only declares the keyword; it is applied when transmission is used too
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Dispersion);
}
bool QSSGShaderCustomMaterialAdapter::isTransmissionEnabled()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Transmission);
}
bool QSSGShaderCustomMaterialAdapter::hasLighting()
{
return true;
}
bool QSSGShaderCustomMaterialAdapter::usesCustomSkinning()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Skinning);
}
bool QSSGShaderCustomMaterialAdapter::usesCustomMorphing()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::Morphing);
}
QSSGRenderDefaultMaterial::MaterialSpecularModel QSSGShaderCustomMaterialAdapter::specularModel()
{
return QSSGRenderDefaultMaterial::MaterialSpecularModel::SchlickGGX;
}
QSSGRenderDefaultMaterial::MaterialAlphaMode QSSGShaderCustomMaterialAdapter::alphaMode()
{
return QSSGRenderDefaultMaterial::MaterialAlphaMode::Default;
}
QSSGRenderDefaultMaterial::VertexColorMaskFlags QSSGShaderCustomMaterialAdapter::vertexColorRedMask()
{
return QSSGRenderDefaultMaterial::NoMask;
}
QSSGRenderDefaultMaterial::VertexColorMaskFlags QSSGShaderCustomMaterialAdapter::vertexColorGreenMask()
{
return QSSGRenderDefaultMaterial::NoMask;
}
QSSGRenderDefaultMaterial::VertexColorMaskFlags QSSGShaderCustomMaterialAdapter::vertexColorBlueMask()
{
return QSSGRenderDefaultMaterial::NoMask;
}
QSSGRenderDefaultMaterial::VertexColorMaskFlags QSSGShaderCustomMaterialAdapter::vertexColorAlphaMask()
{
return QSSGRenderDefaultMaterial::NoMask;
}
QSSGRenderImage *QSSGShaderCustomMaterialAdapter::iblProbe()
{
return m_material.m_iblProbe;
}
// The following are the values that get set into uniforms such as
// qt_material_properties etc. When a custom shader is present, these values
// are not used at all. However, a CustomMaterial is also valid without a
// vertex/fragment shader, or with no custom shaders at all. Therefore the
// values here must match the defaults of PrincipledMaterial, in order to make
// PrincipledMaterial { } and CustomMaterial { } identical.
QVector3D QSSGShaderCustomMaterialAdapter::emissiveColor()
{
return QVector3D(0, 0, 0);
}
QVector4D QSSGShaderCustomMaterialAdapter::color()
{
return QVector4D(1, 1, 1, 1);
}
QVector3D QSSGShaderCustomMaterialAdapter::specularTint()
{
return QVector3D(1, 1, 1);
}
float QSSGShaderCustomMaterialAdapter::ior()
{
return 1.45f;
}
bool QSSGShaderCustomMaterialAdapter::isFresnelScaleBiasEnabled()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::FresnelScaleBias);
}
float QSSGShaderCustomMaterialAdapter::fresnelScale()
{
return 1.0f;
}
float QSSGShaderCustomMaterialAdapter::fresnelBias()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::fresnelPower()
{
return 0.0f;
}
bool QSSGShaderCustomMaterialAdapter::isClearcoatFresnelScaleBiasEnabled()
{
return m_material.m_renderFlags.testFlag(QSSGRenderCustomMaterial::RenderFlag::ClearcoatFresnelScaleBias);
}
float QSSGShaderCustomMaterialAdapter::clearcoatFresnelScale()
{
return 1.0f;
}
float QSSGShaderCustomMaterialAdapter::clearcoatFresnelBias()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::clearcoatFresnelPower()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::metalnessAmount()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::specularAmount()
{
return 0.5f;
}
float QSSGShaderCustomMaterialAdapter::specularRoughness()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::bumpAmount()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::translucentFallOff()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::diffuseLightWrap()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::occlusionAmount()
{
return 1.0f;
}
float QSSGShaderCustomMaterialAdapter::alphaCutOff()
{
return 0.5f;
}
float QSSGShaderCustomMaterialAdapter::pointSize()
{
return 1.0f;
}
float QSSGShaderCustomMaterialAdapter::lineWidth()
{
return m_material.m_lineWidth;
}
float QSSGShaderCustomMaterialAdapter::heightAmount()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::minHeightSamples()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::maxHeightSamples()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::clearcoatAmount()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::clearcoatRoughnessAmount()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::clearcoatNormalStrength()
{
return 1.0f;
}
QVector3D QSSGShaderCustomMaterialAdapter::sheenColor()
{
// Custom materials provide the value through the SHEEN_COLOR keyword
return { 0.0f, 0.0f, 0.0f };
}
float QSSGShaderCustomMaterialAdapter::sheenRoughness()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::anisotropyStrength()
{
// Custom materials provide the value through the ANISOTROPY_STRENGTH keyword
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::anisotropyRotation()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::iridescenceFactor()
{
// Custom materials provide the value through the IRIDESCENCE_FACTOR keyword
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::iridescenceIndexOfRefraction()
{
return 1.3f;
}
float QSSGShaderCustomMaterialAdapter::iridescenceThicknessMinimum()
{
return 100.0f;
}
float QSSGShaderCustomMaterialAdapter::iridescenceThicknessMaximum()
{
return 400.0f;
}
float QSSGShaderCustomMaterialAdapter::dispersion()
{
// Custom materials provide the value through the DISPERSION keyword
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::transmissionFactor()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::thicknessFactor()
{
return 0.0f;
}
float QSSGShaderCustomMaterialAdapter::attenuationDistance()
{
return std::numeric_limits<float>::infinity();
}
QVector3D QSSGShaderCustomMaterialAdapter::attenuationColor()
{
return { 1.0f, 1.0f, 1.0f };
}
bool QSSGShaderCustomMaterialAdapter::isUnshaded()
{
return m_material.m_shadingMode == QSSGRenderCustomMaterial::ShadingMode::Unshaded;
}
bool QSSGShaderCustomMaterialAdapter::hasCustomShaderSnippet(QSSGShaderCache::ShaderType type)
{
if (type == QSSGShaderCache::ShaderType::Vertex)
return m_material.m_customShaderPresence.testFlag(QSSGRenderCustomMaterial::CustomShaderPresenceFlag::Vertex);
return m_material.m_customShaderPresence.testFlag(QSSGRenderCustomMaterial::CustomShaderPresenceFlag::Fragment);
}
QByteArray QSSGShaderCustomMaterialAdapter::customShaderSnippet(QSSGShaderCache::ShaderType type,
QSSGShaderLibraryManager &shaderLibraryManager,
bool multiViewCompatible)
{
if (hasCustomShaderSnippet(type)) {
const QByteArray shaderPathKey = m_material.m_shaderPathKey[multiViewCompatible ? QSSGRenderCustomMaterial::MultiViewShaderPathKeyIndex
: QSSGRenderCustomMaterial::RegularShaderPathKeyIndex];
return shaderLibraryManager.getShaderSource(shaderPathKey, type);
}
return QByteArray();
}
bool QSSGShaderCustomMaterialAdapter::hasCustomShaderFunction(QSSGShaderCache::ShaderType shaderType,
const QByteArray &funcName,
QSSGShaderLibraryManager &shaderLibraryManager)
{
if (hasCustomShaderSnippet(shaderType))
return shaderLibraryManager.getShaderMetaData(m_material.m_shaderPathKey[QSSGRenderCustomMaterial::RegularShaderPathKeyIndex],
shaderType).customFunctions.contains(funcName);
return false;
}
void QSSGShaderCustomMaterialAdapter::setCustomPropertyUniforms(char *ubufData,
QSSGRhiShaderPipeline &shaderPipeline,
const QSSGRenderContextInterface &context)
{
context.customMaterialSystem()->applyRhiShaderPropertyValues(ubufData, m_material, shaderPipeline);
}
bool QSSGShaderCustomMaterialAdapter::usesSharedVariables()
{
return m_material.m_usesSharedVariables;
}
namespace {
// Custom material shader substitution table.
// Must be in sync with the shader generator.
static const QSSGCustomMaterialVariableSubstitution qssg_var_subst_tab[] = {
// uniform (block members)
{ "MODELVIEWPROJECTION_MATRIX", "qt_modelViewProjection", true },
{ "VIEWPROJECTION_MATRIX", "qt_viewProjectionMatrix", true },
{ "MODEL_MATRIX", "qt_modelMatrix", false },
{ "VIEW_MATRIX", "qt_viewMatrix", true },
{ "NORMAL_MATRIX", "qt_normalMatrix", false },
{ "BONE_TRANSFORMS", "qt_getTexMatrix", false },
{ "BONE_NORMAL_TRANSFORMS", "qt_getTexMatrix", false },
{ "PROJECTION_MATRIX", "qt_projectionMatrix", true },
{ "INVERSE_PROJECTION_MATRIX", "qt_inverseProjectionMatrix", true },
{ "CAMERA_POSITION", "qt_cameraPosition", true },
{ "CAMERA_DIRECTION", "qt_cameraDirection", true },
{ "CAMERA_PROPERTIES", "qt_cameraProperties", false },
{ "FRAMEBUFFER_Y_UP", "qt_rhi_properties.x", false },
{ "NDC_Y_UP", "qt_rhi_properties.y", false },
{ "NEAR_CLIP_VALUE", "qt_rhi_properties.z", false },
{ "IBL_MAXMIPMAP", "qt_lightProbeProperties.y", false },
{ "IBL_HORIZON", "qt_lightProbeProperties.z", false },
{ "IBL_EXPOSE", "qt_lightProbeProperties.w", false },
// outputs
{ "POSITION", "gl_Position", false },
{ "FRAGCOLOR", "fragOutput", false },
{ "POINT_SIZE", "gl_PointSize", false },
// fragment inputs
{ "FRAGCOORD", "gl_FragCoord", false },
// functions
{ "DIRECTIONAL_LIGHT", "qt_directionalLightProcessor", false },
{ "POINT_LIGHT", "qt_pointLightProcessor", false },
{ "SPOT_LIGHT", "qt_spotLightProcessor", false },
{ "AMBIENT_LIGHT", "qt_ambientLightProcessor", false },
{ "SPECULAR_LIGHT", "qt_specularLightProcessor", false },
{ "MAIN", "qt_customMain", false },
{ "POST_PROCESS", "qt_customPostProcessor", false },
{ "IBL_PROBE", "qt_iblProbeProcessor", false },
// textures
{ "SCREEN_TEXTURE", "qt_screenTexture", true },
{ "SCREEN_MIP_TEXTURE", "qt_screenTexture", true }, // same resource as SCREEN_TEXTURE under the hood
{ "DEPTH_TEXTURE", "qt_depthTexture", true },
{ "AO_TEXTURE", "qt_aoTexture", true },
{ "IBL_TEXTURE", "qt_lightProbe", false },
{ "LIGHTMAP", "qt_lightmap", false },
{ "NORMAL_ROUGHNESS_TEXTURE", "qt_normalTexture", false },
{ "MOTION_VECTOR_TEXTURE", "qt_motionVectorTexture", false },
// For shaded only: vertex outputs, for convenience and perf. (only those
// that are always present when lighting is enabled) The custom vertex main
// can also calculate on its own and pass them on with VARYING but that's a
// bit wasteful since we calculate these anyways.
{ "VAR_WORLD_NORMAL", "qt_varNormal", false },
{ "VAR_WORLD_TANGENT", "qt_varTangent", false },
{ "VAR_WORLD_BINORMAL", "qt_varBinormal", false },
{ "VAR_WORLD_POSITION", "qt_varWorldPos", false },
// vertex color is always enabled for custom materials (shaded)
{ "VAR_COLOR", "qt_varColor", false },
// effects
{ "INPUT", "qt_inputTexture", true },
{ "INPUT_UV", "qt_inputUV", false },
{ "TEXTURE_UV", "qt_textureUV", false },
{ "INPUT_SIZE", "qt_inputSize", false },
{ "OUTPUT_SIZE", "qt_outputSize", false },
{ "FRAME", "qt_frame_num", false },
// instancing
{ "INSTANCE_COLOR", "qt_instanceColor", false },
{ "INSTANCE_DATA", "qt_instanceData", false },
{ "INSTANCE_INDEX", "gl_InstanceIndex", false },
// morphing
{ "MORPH_POSITION", "qt_getTargetPositionFromTargetId", false },
{ "MORPH_NORMAL", "qt_getTargetNormalFromTargetId", false },
{ "MORPH_TANGENT", "qt_getTargetTangentFromTargetId", false },
{ "MORPH_BINORMAL", "qt_getTargetBinormalFromTargetId", false },
{ "MORPH_WEIGHTS", "qt_morphWeights", false },
// custom variables
{ "SHARED_VARS", "struct QT_SHARED_VARS", false },
// multiview
{ "VIEW_INDEX", "qt_viewIndex", false }
};
// Functions that, if present, get an argument list injected.
static const QByteArrayView qssg_func_injectarg_tab[] = {
"DIRECTIONAL_LIGHT",
"POINT_LIGHT",
"SPOT_LIGHT",
"AMBIENT_LIGHT",
"SPECULAR_LIGHT",
"MAIN",
"POST_PROCESS",
"IBL_PROBE"
};
// This is based on the Qt Quick shader rewriter (with fixes)
struct Tokenizer {
enum Token {
Token_Comment,
Token_OpenBrace,
Token_CloseBrace,
Token_OpenParen,
Token_CloseParen,
Token_SemiColon,
Token_Identifier,
Token_OpenBraket,
Token_CloseBraket,
Token_Unspecified,
Token_EOF
};
void initialize(const QByteArray &input);
Token next();
const char *stream;
const char *pos;
const char *identifier;
};
void Tokenizer::initialize(const QByteArray &input)
{
stream = input.constData();
pos = input;
identifier = input;
}
Tokenizer::Token Tokenizer::next()
{
while (*pos) {
char c = *pos++;
switch (c) {
case '/':
if (*pos == '/') {
// '//' comment
++pos;
while (*pos && *pos != '\n') ++pos;
return Token_Comment;
} else if (*pos == '*') {
// /* */ comment
++pos;
while (*pos && (*pos != '*' || pos[1] != '/')) ++pos;
if (*pos) pos += 2;
return Token_Comment;
}
return Token_Unspecified;
case ';': return Token_SemiColon;
case '\0': return Token_EOF;
case '{': return Token_OpenBrace;
case '}': return Token_CloseBrace;
case '(': return Token_OpenParen;
case ')': return Token_CloseParen;
case '[': return Token_OpenBraket;
case ']': return Token_CloseBraket;
case ' ':
case '\n':
case '\r': break;
default:
// Identifier...
if ((c >= 'a' && c <= 'z' ) || (c >= 'A' && c <= 'Z' ) || c == '_') {
identifier = pos - 1;
while (*pos && ((*pos >= 'a' && *pos <= 'z')
|| (*pos >= 'A' && *pos <= 'Z')
|| *pos == '_'
|| (*pos >= '0' && *pos <= '9'))) {
++pos;
}
return Token_Identifier;
} else {
return Token_Unspecified;
}
}
}
return Token_EOF;
}
} // namespace
void QSSGShaderCustomMaterialAdapter::beginPrepareCustomShader(
CustomShaderPrepWorkData *workData,
ShaderCodeAndMetaData *codeAndMetaData,
const QByteArray &shaderCode,
QSSGShaderCache::ShaderType type,
bool multiViewCompatible)
{
QByteArrayList inputs;
QByteArrayList outputs;
Tokenizer tok;
tok.initialize(shaderCode);
QSSGCustomShaderMetaData md = {};
QByteArray result;
result.reserve(1024);
// If shader debugging is not enabled we reset the line count to make error message
// when a shader fails more useful. When shader debugging is enabled the whole shader
// will be printed and not just the user written part, so in that case we do not want
// to adjust the line numbers.
//
// NOTE: This is not perfect, we do expend the custom material and effect shaders, so
// there cane still be cases where the reported line numbers are slightly off.
if (!QSSGRhiContextPrivate::shaderDebuggingEnabled())
result.prepend("#line 1\n");
const char *lastPos = shaderCode.constData();
int funcFinderState = 0;
int useJointTexState = -1;
int useJointNormalTexState = -1;
QByteArray currentShadedFunc;
Tokenizer::Token t = tok.next();
while (t != Tokenizer::Token_EOF) {
switch (t) {
case Tokenizer::Token_Comment:
break;
case Tokenizer::Token_Identifier:
{
QByteArray id = QByteArray::fromRawData(lastPos, tok.pos - lastPos);
if (id.trimmed() == QByteArrayLiteral("VARYING")) {
QByteArray vtype;
QByteArray vname;
bool vflat = false;
lastPos = tok.pos;
t = tok.next();
while (t != Tokenizer::Token_EOF) {
QByteArray data = QByteArray::fromRawData(lastPos, tok.pos - lastPos);
if (t == Tokenizer::Token_Identifier) {
if (vtype.isEmpty()) {
vtype = data.trimmed();
if (vtype == QByteArrayLiteral("flat")) {
vflat = true;
vtype.clear();
}
} else if (vname.isEmpty()) {
vname = data.trimmed();
}
}
if (t == Tokenizer::Token_SemiColon)
break;
lastPos = tok.pos;
t = tok.next();
}
if (type == QSSGShaderCache::ShaderType::Vertex)
outputs.append((vflat ? "flat " : "") + vtype + " " + vname);
else
inputs.append((vflat ? "flat " : "") + vtype + " " + vname);
} else {
const QByteArray trimmedId = id.trimmed();
if (funcFinderState == 0 && trimmedId == QByteArrayLiteral("void")) {
funcFinderState += 1;
} else if (funcFinderState == 1) {
auto begin = qssg_func_injectarg_tab;
const auto end = qssg_func_injectarg_tab + (sizeof(qssg_func_injectarg_tab) / sizeof(qssg_func_injectarg_tab[0]));
const auto foundIt = std::find_if(begin, end, [trimmedId](const QByteArrayView &entry) { return entry == trimmedId; });
if (foundIt != end) {
currentShadedFunc = trimmedId;
funcFinderState += 1;
}
} else {
funcFinderState = 0;
}
if (trimmedId == QByteArrayLiteral("SCREEN_TEXTURE"))
md.flags |= QSSGCustomShaderMetaData::UsesScreenTexture;
else if (trimmedId == QByteArrayLiteral("SCREEN_MIP_TEXTURE"))
md.flags |= QSSGCustomShaderMetaData::UsesScreenMipTexture;
else if (trimmedId == QByteArrayLiteral("DEPTH_TEXTURE"))
md.flags |= QSSGCustomShaderMetaData::UsesDepthTexture;
else if (trimmedId == QByteArrayLiteral("NORMAL_ROUGHNESS_TEXTURE"))
md.flags |= QSSGCustomShaderMetaData::UsesNormalTexture;
else if (trimmedId == QByteArrayLiteral("AO_TEXTURE"))
md.flags |= QSSGCustomShaderMetaData::UsesAoTexture;
else if (trimmedId == QByteArrayLiteral("POSITION"))
md.flags |= QSSGCustomShaderMetaData::OverridesPosition;
else if (trimmedId == QByteArrayLiteral("PROJECTION_MATRIX"))
md.flags |= QSSGCustomShaderMetaData::UsesProjectionMatrix;
else if (trimmedId == QByteArrayLiteral("INVERSE_PROJECTION_MATRIX"))
md.flags |= QSSGCustomShaderMetaData::UsesInverseProjectionMatrix;
else if (trimmedId == QByteArrayLiteral("VIEW_MATRIX"))
md.flags |= QSSGCustomShaderMetaData::UsesViewMatrix;
else if (trimmedId == QByteArrayLiteral("VAR_COLOR"))
md.flags |= QSSGCustomShaderMetaData::UsesVarColor;
else if (trimmedId == QByteArrayLiteral("SHARED_VARS"))
md.flags |= QSSGCustomShaderMetaData::UsesSharedVars;
else if (trimmedId == QByteArrayLiteral("IBL_ORIENTATION"))
md.flags |= QSSGCustomShaderMetaData::UsesIblOrientation;
else if (trimmedId == QByteArrayLiteral("LIGHTMAP"))
md.flags |= QSSGCustomShaderMetaData::UsesLightmap;
else if (trimmedId == QByteArrayLiteral("VIEW_INDEX"))
md.flags |= QSSGCustomShaderMetaData::UsesViewIndex;
else if (trimmedId == QByteArrayLiteral("INPUT"))
md.flags |= QSSGCustomShaderMetaData::UsesInputTexture;
else if (trimmedId == QByteArrayLiteral("CLEARCOAT_AMOUNT"))
md.flags |= QSSGCustomShaderMetaData::UsesClearcoat;
else if (trimmedId == QByteArrayLiteral("SHEEN_COLOR")
|| trimmedId == QByteArrayLiteral("SHEEN_ROUGHNESS"))
md.flags |= QSSGCustomShaderMetaData::UsesSheen;
else if (trimmedId == QByteArrayLiteral("ANISOTROPY_STRENGTH")
|| trimmedId == QByteArrayLiteral("ANISOTROPY_ROTATION"))
md.flags |= QSSGCustomShaderMetaData::UsesAnisotropy;
else if (trimmedId == QByteArrayLiteral("IRIDESCENCE_FACTOR")
|| trimmedId == QByteArrayLiteral("IRIDESCENCE_IOR")
|| trimmedId == QByteArrayLiteral("IRIDESCENCE_THICKNESS"))
md.flags |= QSSGCustomShaderMetaData::UsesIridescence;
else if (trimmedId == QByteArrayLiteral("DISPERSION"))
md.flags |= QSSGCustomShaderMetaData::UsesDispersion;
else if (trimmedId == QByteArrayLiteral("CLEARCOAT_FRESNEL_SCALE") ||
trimmedId == QByteArrayLiteral("CLEARCOAT_FRESNEL_BIAS"))
md.flags |= QSSGCustomShaderMetaData::UsesClearcoatFresnelScaleBias;
else if (trimmedId == QByteArrayLiteral("FRESNEL_SCALE") ||
trimmedId == QByteArrayLiteral("FRESNEL_BIAS"))
md.flags |= QSSGCustomShaderMetaData::UsesFresnelScaleBias;
else if (trimmedId == QByteArrayLiteral("MOTION_VECTOR_TEXTURE"))
md.flags |= QSSGCustomShaderMetaData::UsesMotionVectorTexture;
else if (trimmedId == QByteArrayLiteral("TRANSMISSION_FACTOR")) {
md.flags |= QSSGCustomShaderMetaData::UsesTransmission;
md.flags |= QSSGCustomShaderMetaData::UsesScreenTexture;
md.flags |= QSSGCustomShaderMetaData::UsesScreenMipTexture;
}
for (const QSSGCustomMaterialVariableSubstitution &subst : qssg_var_subst_tab) {
if (trimmedId == subst.builtin) {
QByteArray newExpr;
newExpr.assign(subst.actualName);
if (subst.multiViewDependent && multiViewCompatible) {
if (subst.builtin.endsWith(QByteArrayLiteral("_TEXTURE"))
|| subst.builtin == QByteArrayLiteral("INPUT"))
{
newExpr += QByteArrayLiteral("Array"); // e.g. qt_depthTexture -> qt_depthTextureArray
} else {
newExpr += QByteArrayLiteral("[qt_viewIndex]"); // e.g. qt_viewProjectionMatrix -> qt_viewProjectionMatrix[qt_viewIndex]
}
}
id.replace(subst.builtin, newExpr); // replace, not assignment, to keep whitespace etc.
if (trimmedId == QByteArrayLiteral("BONE_TRANSFORMS")) {
useJointTexState = 0;
md.flags |= QSSGCustomShaderMetaData::UsesSkinning;
} else if (trimmedId == QByteArrayLiteral("BONE_NORMAL_TRANSFORMS")) {
useJointNormalTexState = 0;
md.flags |= QSSGCustomShaderMetaData::UsesSkinning;
}
if (trimmedId == QByteArrayLiteral("MORPH_POSITION") ||
trimmedId == QByteArrayLiteral("MORPH_NORMAL") ||
trimmedId == QByteArrayLiteral("MORPH_TANGENT") ||
trimmedId == QByteArrayLiteral("MORPH_BINORMAL"))
md.flags |= QSSGCustomShaderMetaData::UsesMorphing;
break;
}
}
result += id;
}
}
break;
case Tokenizer::Token_OpenParen:
result += QByteArray::fromRawData(lastPos, tok.pos - lastPos);
if (funcFinderState == 2) {
result += QByteArrayLiteral("/*%QT_ARGS_");
result += currentShadedFunc;
result += QByteArrayLiteral("%*/");
for (const QSSGCustomMaterialVariableSubstitution &subst : qssg_var_subst_tab) {
if (currentShadedFunc == subst.builtin) {
currentShadedFunc = subst.actualName.toByteArray();
break;
}
}
md.customFunctions.insert(currentShadedFunc);
currentShadedFunc.clear();
}
funcFinderState = 0;
break;
case Tokenizer::Token_OpenBraket:
// copy everything as-is up to the [
result += QByteArray::fromRawData(lastPos, tok.pos - lastPos - 1);
if (useJointTexState == 0) {
result += QByteArrayLiteral("(2 * (");
++useJointTexState;
break;
} else if (useJointNormalTexState == 0) {
result += QByteArrayLiteral("(1 + 2 * (");
++useJointNormalTexState;
break;
}
if (useJointTexState >= 0)
++useJointTexState;
else if (useJointNormalTexState >= 0)
++useJointNormalTexState;
result += QByteArrayLiteral("[");
break;
case Tokenizer::Token_CloseBraket:
// copy everything as-is up to the ]
result += QByteArray::fromRawData(lastPos, tok.pos - lastPos - 1);
// This implementation will not allow mixed usages of BONE_TRANSFORMS and
// BONE_NORMAL_TRANSFORMS.
// For example, BONE_TRANSFORM[int(BONE_NORMAL_TRANFORMS[i][0].x)]
// cannot be compiled successfully.
if (useJointTexState <= 0 && useJointNormalTexState <= 0) {
result += QByteArrayLiteral("]");
break;
}
if (useJointTexState > 1) {
result += QByteArrayLiteral("]");
--useJointTexState;
break;
} else if (useJointNormalTexState > 1) {
result += QByteArrayLiteral("]");
--useJointNormalTexState;
break;
}
result += QByteArrayLiteral("))");
useJointTexState = -1;
useJointNormalTexState = -1;
break;
default:
result += QByteArray::fromRawData(lastPos, tok.pos - lastPos);
break;
}
lastPos = tok.pos;
t = tok.next();
}
result += '\n';
workData->inputs = inputs;
workData->outputs = outputs;
if (md.flags.testFlag(QSSGCustomShaderMetaData::UsesDispersion)
&& !md.flags.testFlag(QSSGCustomShaderMetaData::UsesTransmission)) {
qWarning("Custom material writes DISPERSION but never sets TRANSMISSION_FACTOR; "
"dispersion requires transmission and will have no effect");
}
*codeAndMetaData = { result, md };
}
void QSSGShaderCustomMaterialAdapter::finishPrepareCustomShader(
QByteArray *dst,
const CustomShaderPrepWorkData &workData,
const ShaderCodeAndMetaData &codeAndMetaData,
QSSGShaderCache::ShaderType type,
bool multiViewCompatible,
const StringPairList &baseUniforms,
const StringPairList &baseInputs,
const StringPairList &baseOutputs,
const StringPairList &multiViewDependentSamplers,
const StringPairList &multiViewDependentUniforms)
{
StringPairList allUniforms = baseUniforms;
for (const StringPair &samplerTypeAndName : multiViewDependentSamplers) {
if (multiViewCompatible)
allUniforms.append({ "sampler2DArray", samplerTypeAndName.second });
else
allUniforms.append(samplerTypeAndName);
}
const QSSGCustomShaderMetaData &md(codeAndMetaData.second);
// We either have qt_depthTexture or qt_depthTextureArray (or none of them),
// but never both. We do not generally support binding a 2D texture to a
// sampler2DArray binding point and vice versa. Therefore it is up to the
// shader snippet to ifdef with QSHADER_VIEW_COUNT if it wants to support
// both multiview and non-multiview rendering.
if (md.flags.testFlag(QSSGCustomShaderMetaData::UsesDepthTexture)) {
if (multiViewCompatible)
allUniforms.append({ "sampler2DArray", "qt_depthTextureArray" });
else
allUniforms.append({ "sampler2D", "qt_depthTexture" });
}
// And the same pattern for qt_screenTexture(Array).
if ((md.flags.testFlag(QSSGCustomShaderMetaData::UsesScreenTexture) || md.flags.testFlag(QSSGCustomShaderMetaData::UsesScreenMipTexture))) {
if (multiViewCompatible)
allUniforms.append({ "sampler2DArray", "qt_screenTextureArray" });
else
allUniforms.append({ "sampler2D", "qt_screenTexture" });
}
// And for SSAO.
if (md.flags.testFlag(QSSGCustomShaderMetaData::UsesAoTexture)) {
if (multiViewCompatible)
allUniforms.append({ "sampler2DArray", "qt_aoTextureArray" });
else
allUniforms.append({ "sampler2D", "qt_aoTexture" });
}
if (md.flags.testFlag(QSSGCustomShaderMetaData::UsesNormalTexture))
allUniforms.append({ "sampler2D", "qt_normalTexture" });
// Input texture for post-processing effects.
if (md.flags.testFlag(QSSGCustomShaderMetaData::UsesInputTexture)) {
if (multiViewCompatible)
allUniforms.append({ "sampler2DArray", "qt_inputTextureArray" });
else
allUniforms.append({ "sampler2D", "qt_inputTexture" });
}
if (md.flags.testFlag(QSSGCustomShaderMetaData::UsesLightmap))
allUniforms.append({ "sampler2D", "qt_lightmap" });
if (md.flags.testFlag(QSSGCustomShaderMetaData::UsesMotionVectorTexture))
allUniforms.append({ "sampler2D", "qt_motionVectorTexture" });
static const char *metaStart = "#ifdef QQ3D_SHADER_META\n/*{\n \"uniforms\": [\n";
static const char *metaEnd = " ]\n}*/\n#endif\n";
dst->append(metaStart);
for (int i = 0, count = allUniforms.size(); i < count; ++i) {
const auto &typeAndName(allUniforms[i]);
dst->append(" { \"type\": \"" + typeAndName.first + "\", \"name\": \"" + typeAndName.second + "\" }");
if (i < count - 1 || !multiViewDependentUniforms.isEmpty())
dst->append(",");
dst->append("\n");
}
// multiViewDependentUniforms are not in allUniforms. For these we leave it to the
// metadata processor to add an array suffix (e.g., qt_projectionMatrix[2]) when needed.
for (int i = 0, count = multiViewDependentUniforms.size(); i < count; ++i) {
const auto &typeAndName(multiViewDependentUniforms[i]);
dst->append(" { \"type\": \"" + typeAndName.first + "\", \"name\": \"" + typeAndName.second + "\", \"multiview_dependent\": true }");
if (i < count - 1)
dst->append(",");
dst->append("\n");
}
dst->append(metaEnd);
const char *stageStr = type == QSSGShaderCache::ShaderType::Vertex ? "vertex" : "fragment";
StringPairList allInputs = baseInputs;
QVarLengthArray<bool, 16> inputIsFlat(allInputs.count(), false);
for (const QByteArray &inputTypeAndName : workData.inputs) {
const QByteArrayList typeAndName = inputTypeAndName.split(' ');
if (typeAndName.size() == 2) {
allInputs.append({ typeAndName[0].trimmed(), typeAndName[1].trimmed() });
inputIsFlat.append(false);
} else if (typeAndName.size() == 3 && typeAndName[0].startsWith("flat")) {
allInputs.append({ typeAndName[1].trimmed(), typeAndName[2].trimmed() });
inputIsFlat.append(true);
}
}
if (!allInputs.isEmpty()) {
static const char *metaStart = "#ifdef QQ3D_SHADER_META\n/*{\n \"inputs\": [\n";
static const char *metaEnd = " ]\n}*/\n#endif\n";
dst->append(metaStart);
for (int i = 0, count = allInputs.size(); i < count; ++i) {
dst->append(" { \"type\": \"" + allInputs[i].first
+ "\", \"name\": \"" + allInputs[i].second
+ "\", \"stage\": \"" + stageStr
+ (inputIsFlat[i] ? "\", \"flat\": true" : "\"")
+ " }");
if (i < count - 1)
dst->append(",");
dst->append("\n");
}
dst->append(metaEnd);
}
StringPairList allOutputs = baseOutputs;
QVarLengthArray<bool, 16> outputIsFlat(allOutputs.count(), false);
for (const QByteArray &outputTypeAndName : workData.outputs) {
const QByteArrayList typeAndName = outputTypeAndName.split(' ');
if (typeAndName.size() == 2) {
allOutputs.append({ typeAndName[0].trimmed(), typeAndName[1].trimmed() });
outputIsFlat.append(false);
} else if (typeAndName.size() == 3 && typeAndName[0].startsWith("flat")) {
allOutputs.append({ typeAndName[1].trimmed(), typeAndName[2].trimmed() });
outputIsFlat.append(true);
}
}
if (!allOutputs.isEmpty()) {
static const char *metaStart = "#ifdef QQ3D_SHADER_META\n/*{\n \"outputs\": [\n";
static const char *metaEnd = " ]\n}*/\n#endif\n";
dst->append(metaStart);
for (int i = 0, count = allOutputs.size(); i < count; ++i) {
dst->append(" { \"type\": \"" + allOutputs[i].first
+ "\", \"name\": \"" + allOutputs[i].second
+ "\", \"stage\": \"" + stageStr
+ (outputIsFlat[i] ? "\", \"flat\": true" : "\"")
+ " }");
if (i < count - 1)
dst->append(",");
dst->append("\n");
}
dst->append(metaEnd);
}
}
QList<QByteArrayView> QtQuick3DEditorHelpers::CustomMaterial::preprocessorVars()
{
QList<QByteArrayView> k;
k.reserve(std::size(qssg_var_subst_tab));
for (const auto &v : qssg_var_subst_tab)
k.push_back(v.builtin);
return k;
}
QT_END_NAMESPACE