Revision control
Copy as Markdown
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtTest/QtTest>
#include <QFile>
#include <rhi/qshaderbaker.h>
#include <rhi/qshaderdescription.h>
#include <private/qshader_p.h>
class tst_QShaderBaker : public QObject
{
Q_OBJECT
private slots:
void initTestCase();
void cleanup();
void emptyCompile();
void noFileCompile();
void noTargetsCompile();
void noVariantsCompile();
void simpleCompile();
void simpleCompileNoSpirvSpecified();
void simpleCompileCheckResults();
void simpleCompileFromDevice();
void simpleCompileFromString();
void multiCompile();
void reuse();
void compileError();
void translateError();
void genVariants();
void defines();
void reflectArrayOfStructInBlock();
void reflectCombinedImageSampler();
void mslNativeBindingMap();
void mslArgumentBuffers();
void hlslNativeBindingMap();
void reflectArraysOfSamplers();
void perTargetCompileMode();
void perTargetCompileModeReproducible();
void serializeDeserialize();
void spirvOptions();
void separateImagesAndSamplers();
void tessellationForMetalVertCompile();
void tessellationCompile();
void tessellationCompileWithChangedTessArgs();
void dontBreakOnTranslationError();
void storageImageFlags();
void storageBufferRuntimeArrayStride();
void storageBufferQualifiers();
void multiview();
void mediump();
void geometryShader();
};
void tst_QShaderBaker::initTestCase()
{
}
void tst_QShaderBaker::cleanup()
{
}
void tst_QShaderBaker::emptyCompile()
{
QShaderBaker baker;
QShader s = baker.bake();
QVERIFY(!s.isValid());
QVERIFY(!baker.errorMessage().isEmpty());
qDebug() << baker.errorMessage();
}
void tst_QShaderBaker::noFileCompile()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/nonexistant.vert"));
QShader s = baker.bake();
QVERIFY(!s.isValid());
QVERIFY(!baker.errorMessage().isEmpty());
qDebug() << baker.errorMessage();
}
void tst_QShaderBaker::noTargetsCompile()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
QShader s = baker.bake();
// an empty shader pack is invalid
QVERIFY(!s.isValid());
// not an error from the baker's point of view however
QVERIFY(baker.errorMessage().isEmpty());
}
void tst_QShaderBaker::noVariantsCompile()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
// an empty shader pack is invalid
QVERIFY(!s.isValid());
// not an error from the baker's point of view however
QVERIFY(baker.errorMessage().isEmpty());
}
void tst_QShaderBaker::simpleCompile()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
QVERIFY(s.availableShaders().contains(QShaderKey(QShader::SpirvShader, QShaderVersion(100))));
}
void tst_QShaderBaker::simpleCompileNoSpirvSpecified()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::GlslShader, QShaderVersion(330) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
QVERIFY(s.availableShaders().contains(QShaderKey(QShader::GlslShader, QShaderVersion(330))));
QVERIFY(s.shader(s.availableShaders().first()).shader().contains(QByteArrayLiteral("#version 330")));
}
void tst_QShaderBaker::simpleCompileCheckResults()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
const QShaderCode shader = s.shader(QShaderKey(QShader::SpirvShader,
QShaderVersion(100)));
QVERIFY(!shader.shader().isEmpty());
QCOMPARE(shader.entryPoint(), QByteArrayLiteral("main"));
const QShaderDescription desc = s.description();
QVERIFY(desc.isValid());
QCOMPARE(desc.inputVariables().size(), 2);
for (const QShaderDescription::InOutVariable &v : desc.inputVariables()) {
switch (v.location) {
case 0:
QCOMPARE(v.name, QByteArrayLiteral("position"));
QCOMPARE(v.type, QShaderDescription::Vec4);
break;
case 1:
QCOMPARE(v.name, QByteArrayLiteral("color"));
QCOMPARE(v.type, QShaderDescription::Vec3);
break;
default:
QFAIL(qPrintable(QStringLiteral("Unexpected location value: %1").arg(v.location)));
break;
}
}
QCOMPARE(desc.outputVariables().size(), 1);
for (const QShaderDescription::InOutVariable &v : desc.outputVariables()) {
switch (v.location) {
case 0:
QCOMPARE(v.name, QByteArrayLiteral("v_color"));
QCOMPARE(v.type, QShaderDescription::Vec3);
break;
default:
QFAIL(qPrintable(QStringLiteral("Unexpected location value: %1").arg(v.location)));
break;
}
}
QCOMPARE(desc.uniformBlocks().size(), 1);
const QShaderDescription::UniformBlock blk = desc.uniformBlocks().first();
QCOMPARE(blk.blockName, QByteArrayLiteral("buf"));
QCOMPARE(blk.structName, QByteArrayLiteral("ubuf"));
QCOMPARE(blk.size, 68);
QCOMPARE(blk.binding, 0);
QCOMPARE(blk.descriptorSet, 0);
QCOMPARE(blk.members.size(), 2);
for (int i = 0; i < blk.members.size(); ++i) {
const QShaderDescription::BlockVariable v = blk.members[i];
switch (i) {
case 0:
QCOMPARE(v.offset, 0);
QCOMPARE(v.size, 64);
QCOMPARE(v.name, QByteArrayLiteral("mvp"));
QCOMPARE(v.type, QShaderDescription::Mat4);
QCOMPARE(v.matrixStride, 16);
break;
case 1:
QCOMPARE(v.offset, 64);
QCOMPARE(v.size, 4);
QCOMPARE(v.name, QByteArrayLiteral("opacity"));
QCOMPARE(v.type, QShaderDescription::Float);
break;
default:
QFAIL(qPrintable(QStringLiteral("Too many blocks").arg(blk.members.size())));
break;
}
}
}
void tst_QShaderBaker::simpleCompileFromDevice()
{
QFile f(QLatin1String(":/data/color.vert"));
QVERIFY(f.open(QIODevice::ReadOnly | QIODevice::Text));
QShaderBaker baker;
baker.setSourceDevice(&f, QShader::VertexStage);
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
}
void tst_QShaderBaker::simpleCompileFromString()
{
QFile f(QLatin1String(":/data/color.vert"));
QVERIFY(f.open(QIODevice::ReadOnly | QIODevice::Text));
const QByteArray contents = f.readAll();
f.close();
QVERIFY(!contents.isEmpty());
QShaderBaker baker;
baker.setSourceString(contents, QShader::VertexStage);
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
}
void tst_QShaderBaker::multiCompile()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 5);
for (const QShaderBaker::GeneratedShader &genShader : targets) {
const QShaderKey key(genShader.first, genShader.second);
const QShaderCode shader = s.shader(key);
QVERIFY(!shader.shader().isEmpty());
if (genShader.first != QShader::MslShader)
QCOMPARE(shader.entryPoint(), QByteArrayLiteral("main"));
}
}
void tst_QShaderBaker::reuse()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
baker.setSourceFileName(QLatin1String(":/data/color.frag"));
targets.clear();
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 5);
}
void tst_QShaderBaker::compileError()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/error.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(!s.isValid());
QVERIFY(!baker.errorMessage().isEmpty());
qDebug() << baker.errorMessage();
}
void tst_QShaderBaker::translateError()
{
// assume the shader here fails in SPIRV-Cross with "cbuffer cannot be expressed with either HLSL packing layout or packoffset"
//
// This has been improved in SPIRV-Cross, presumably by 0ac65a353e94e9756e8b89fa74e953c482a915e0, so skip this test.
QSKIP("Not applicable with updated SPIRV-Cross");
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/hlsl_cbuf_error.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::HlslShader, QShaderVersion(50) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(!s.isValid());
QVERIFY(!baker.errorMessage().isEmpty());
qDebug() << baker.errorMessage();
}
void tst_QShaderBaker::genVariants()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({
QShader::StandardShader,
QShader::BatchableVertexShader
});
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(330) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 2 * 6);
int batchableVariantCount = 0;
int batchableGlslVariantCount = 0;
for (const QShaderKey &key : s.availableShaders()) {
if (key.sourceVariant() == QShader::BatchableVertexShader) {
++batchableVariantCount;
if (key.source() == QShader::GlslShader) {
++batchableGlslVariantCount;
const QByteArray src = s.shader(key).shader();
QVERIFY(src.contains(QByteArrayLiteral("_qt_order * ")));
}
} else {
if (key.source() == QShader::GlslShader) {
// make sure it did not get rewritten
const QByteArray src = s.shader(key).shader();
QVERIFY(!src.contains(QByteArrayLiteral("_qt_order * ")));
}
}
}
QCOMPARE(batchableVariantCount, 6);
QCOMPARE(batchableGlslVariantCount, 3);
}
void tst_QShaderBaker::defines()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/defines.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
baker.setGeneratedShaders({ { QShader::SpirvShader, QShaderVersion(100) } });
QShader s = baker.bake();
QVERIFY(!s.isValid());
QVERIFY(!baker.errorMessage().isEmpty());
qDebug() << baker.errorMessage();
QByteArray preamble;
preamble = QByteArrayLiteral("#define DO_NOT_BREAK\n");
baker.setPreamble(preamble);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QShaderDescription desc = s.description();
QCOMPARE(desc.uniformBlocks().size(), 1);
QShaderDescription::UniformBlock blk = desc.uniformBlocks().first();
QCOMPARE(blk.members.size(), 2);
bool opacity_ok = false;
for (int i = 0; i < blk.members.size(); ++i) {
const QShaderDescription::BlockVariable v = blk.members[i];
if (v.name == QByteArrayLiteral("opacity")) {
opacity_ok = v.type == QShaderDescription::Vec4;
break;
}
}
QVERIFY(opacity_ok);
preamble += QByteArrayLiteral("#define OPACITY_SIZE 1\n");
baker.setPreamble(preamble);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
desc = s.description();
blk = desc.uniformBlocks().first();
opacity_ok = false;
for (int i = 0; i < blk.members.size(); ++i) {
const QShaderDescription::BlockVariable v = blk.members[i];
if (v.name == QByteArrayLiteral("opacity")) {
opacity_ok = v.type == QShaderDescription::Float;
break;
}
}
QVERIFY(opacity_ok);
}
void tst_QShaderBaker::reflectArrayOfStructInBlock()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/array_of_struct_in_ubuf.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::GlslShader, QShaderVersion(150) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QShaderDescription desc = s.description();
QCOMPARE(desc.inputVariables().size(), 3);
QCOMPARE(desc.outputVariables().size(), 1);
QCOMPARE(desc.uniformBlocks().size(), 1);
const QList<QShaderDescription::InOutVariable> inputs = desc.inputVariables();
for (const auto &var : inputs) {
switch (var.location) {
case 0:
QCOMPARE(var.name, QByteArrayLiteral("vECVertNormal"));
QCOMPARE(var.type, QShaderDescription::Vec3);
break;
case 1:
QCOMPARE(var.name, QByteArrayLiteral("vECVertPos"));
QCOMPARE(var.type, QShaderDescription::Vec3);
break;
case 2:
QCOMPARE(var.name, QByteArrayLiteral("vDiffuseAdjust"));
QCOMPARE(var.type, QShaderDescription::Vec3);
break;
default:
QFAIL(qPrintable(QStringLiteral("Unexpected input variable: %1").arg(var.location)));
return;
}
}
const QList<QShaderDescription::InOutVariable> outputs = desc.outputVariables();
QCOMPARE(outputs.first().location, 0);
QCOMPARE(outputs.first().name, QByteArrayLiteral("fragColor"));
QCOMPARE(outputs.first().type, QShaderDescription::Vec4);
const QList<QShaderDescription::UniformBlock> ublocks = desc.uniformBlocks();
const QShaderDescription::UniformBlock ub = ublocks.first();
QCOMPARE(ub.binding, 1);
QCOMPARE(ub.blockName, QByteArrayLiteral("buf"));
QCOMPARE(ub.structName, QByteArrayLiteral("ubuf"));
QCOMPARE(ub.size, 768);
QCOMPARE(ub.members.size(), 7);
for (const QShaderDescription::BlockVariable &var : ub.members) {
if (var.name == QByteArrayLiteral("ECCameraPosition")) {
QCOMPARE(var.offset, 0);
QCOMPARE(var.size, 12);
QCOMPARE(var.type, QShaderDescription::Vec3);
} else if (var.name == QByteArrayLiteral("ka")) {
QCOMPARE(var.offset, 16);
QCOMPARE(var.size, 12);
QCOMPARE(var.type, QShaderDescription::Vec3);
} else if (var.name == QByteArrayLiteral("kd")) {
QCOMPARE(var.offset, 32);
QCOMPARE(var.size, 12);
QCOMPARE(var.type, QShaderDescription::Vec3);
} else if (var.name == QByteArrayLiteral("ks")) {
QCOMPARE(var.offset, 48);
QCOMPARE(var.size, 12);
QCOMPARE(var.type, QShaderDescription::Vec3);
} else if (var.name == QByteArrayLiteral("numLights")) {
QCOMPARE(var.offset, 704);
QCOMPARE(var.size, 4);
QCOMPARE(var.type, QShaderDescription::Int);
} else if (var.name == QByteArrayLiteral("mm")) {
QCOMPARE(var.offset, 720);
QCOMPARE(var.size, 48);
QCOMPARE(var.type, QShaderDescription::Mat3);
QCOMPARE(var.matrixStride, 16);
QCOMPARE(var.matrixIsRowMajor, true);
} else if (var.name == QByteArrayLiteral("lights")) {
QCOMPARE(var.offset, 64);
QCOMPARE(var.size, 640);
QCOMPARE(var.type, QShaderDescription::Struct);
QCOMPARE(var.arrayDims, QList<int>() << 10);
QCOMPARE(var.structMembers.size(), 8);
for (const QShaderDescription::BlockVariable &structVar : var.structMembers) {
if (structVar.name == QByteArrayLiteral("ECLightPosition")) {
QCOMPARE(structVar.offset, 0);
QCOMPARE(structVar.size, 12);
QCOMPARE(structVar.type, QShaderDescription::Vec3);
} else if (structVar.name == QByteArrayLiteral("attenuation")) {
QCOMPARE(structVar.offset, 16);
QCOMPARE(structVar.size, 12);
QCOMPARE(structVar.type, QShaderDescription::Vec3);
} else if (structVar.name == QByteArrayLiteral("color")) {
QCOMPARE(structVar.offset, 32);
QCOMPARE(structVar.size, 12);
QCOMPARE(structVar.type, QShaderDescription::Vec3);
} else if (structVar.name == QByteArrayLiteral("intensity")) {
QCOMPARE(structVar.offset, 48);
QCOMPARE(structVar.size, 4);
QCOMPARE(structVar.type, QShaderDescription::Float);
} else if (structVar.name == QByteArrayLiteral("specularExp")) {
QCOMPARE(structVar.offset, 52);
QCOMPARE(structVar.size, 4);
QCOMPARE(structVar.type, QShaderDescription::Float);
} else if (structVar.name == QByteArrayLiteral("padding1")) {
QCOMPARE(structVar.offset, 12);
QCOMPARE(structVar.size, 4);
QCOMPARE(structVar.type, QShaderDescription::Float);
} else if (structVar.name == QByteArrayLiteral("padding2")) {
QCOMPARE(structVar.offset, 28);
QCOMPARE(structVar.size, 4);
QCOMPARE(structVar.type, QShaderDescription::Float);
} else if (structVar.name == QByteArrayLiteral("padding3")) {
QCOMPARE(structVar.offset, 44);
QCOMPARE(structVar.size, 4);
QCOMPARE(structVar.type, QShaderDescription::Float);
} else {
QFAIL(qPrintable(
QStringLiteral(
"Unexpected member in 'lights' struct in uniform block: %1")
.arg(structVar.name)));
}
}
} else {
QFAIL(qPrintable(QStringLiteral("Unexpected uniform block member: %1").arg(var.name)));
}
}
}
void tst_QShaderBaker::reflectCombinedImageSampler()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/sgtexture.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::GlslShader, QShaderVersion(150) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QShaderDescription desc = s.description();
QCOMPARE(desc.inputVariables().size(), 1);
QCOMPARE(desc.outputVariables().size(), 1);
QCOMPARE(desc.uniformBlocks().size(), 1);
QCOMPARE(desc.combinedImageSamplers().size(), 2);
auto inputVar = desc.inputVariables().first();
QCOMPARE(inputVar.location, 0);
QCOMPARE(inputVar.name, QByteArrayLiteral("qt_TexCoord"));
QCOMPARE(inputVar.type, QShaderDescription::Vec2);
auto outputVar = desc.outputVariables().first();
QCOMPARE(outputVar.location, 0);
QCOMPARE(outputVar.name, QByteArrayLiteral("fragColor"));
QCOMPARE(outputVar.type, QShaderDescription::Vec4);
auto block = desc.uniformBlocks().first();
QCOMPARE(block.binding, 0);
QCOMPARE(block.size, 68);
QCOMPARE(block.blockName, QByteArrayLiteral("buf"));
QCOMPARE(block.structName, QByteArrayLiteral("ubuf"));
QCOMPARE(block.members.size(), 2);
for (int i = 0; i < block.members.size(); ++i) {
const QShaderDescription::BlockVariable &blockVar(block.members[i]);
switch (i) {
case 0:
QCOMPARE(blockVar.name, QByteArrayLiteral("qt_Matrix"));
QCOMPARE(blockVar.offset, 0);
QCOMPARE(blockVar.size, 64);
QCOMPARE(blockVar.type, QShaderDescription::Mat4);
QCOMPARE(blockVar.matrixStride, 16);
QCOMPARE(blockVar.matrixIsRowMajor, false);
break;
case 1:
QCOMPARE(blockVar.name, QByteArrayLiteral("opacity"));
QCOMPARE(blockVar.offset, 64);
QCOMPARE(blockVar.size, 4);
QCOMPARE(blockVar.type, QShaderDescription::Float);
break;
default:
break;
}
}
for (const QShaderDescription::InOutVariable &imSampVar : desc.combinedImageSamplers()) {
switch (imSampVar.binding) {
case 1:
QCOMPARE(imSampVar.name, QByteArrayLiteral("qt_Texture"));
QCOMPARE(imSampVar.type, QShaderDescription::Sampler2D);
break;
case 2:
QCOMPARE(imSampVar.name, QByteArrayLiteral("t1"));
QCOMPARE(imSampVar.type, QShaderDescription::Sampler2D);
break;
default:
QFAIL(qPrintable(QStringLiteral("Unexpected combined image sampler: %1")
.arg(imSampVar.binding)));
return;
}
}
}
void tst_QShaderBaker::mslNativeBindingMap()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/sgtexture.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::GlslShader, QShaderVersion(150) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
const QShaderKey mslShaderKey(QShader::MslShader, QShaderVersion(12));
QVERIFY(!s.nativeResourceBindingMap(mslShaderKey).isEmpty());
QShader::NativeResourceBindingMap nativeBindingMap = s.nativeResourceBindingMap(mslShaderKey);
QCOMPARE(nativeBindingMap.size(), 3);
QVERIFY(nativeBindingMap.contains(0)); // uniform block
QVERIFY(nativeBindingMap.contains(1)); // combined image sampler, maps to a texture and sampler in MSL
QVERIFY(nativeBindingMap.contains(2)); // same
// MSL has per-resource namespaces
std::pair<int, int> nativeBindingPair = nativeBindingMap.value(0);
QCOMPARE(nativeBindingPair.first, 0); // uniform buffer
nativeBindingPair = nativeBindingMap.value(1);
QCOMPARE(nativeBindingPair.first, 0); // texture
QCOMPARE(nativeBindingPair.second, 0); // sampler
nativeBindingPair = nativeBindingMap.value(2);
QCOMPARE(nativeBindingPair.first, 1); // texture
QCOMPARE(nativeBindingPair.second, 1); // sampler
baker.setSourceFileName(QLatin1String(":/data/manyresources.frag"));
targets.clear();
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
nativeBindingMap = s.nativeResourceBindingMap(mslShaderKey);
QCOMPARE(nativeBindingMap.size(), 8);
// rather won't compare with exact values, do not make assumptions, just
// make sure there is a valid value for each since all resources are used
// in the shader code
QVERIFY(nativeBindingMap.value(1).first != -1);
QVERIFY(nativeBindingMap.value(2).first != -1);
QVERIFY(nativeBindingMap.value(3).first != -1);
QVERIFY(nativeBindingMap.value(4).first != -1);
QVERIFY(nativeBindingMap.value(5).first != -1);
QVERIFY(nativeBindingMap.value(10).first != -1);
QVERIFY(nativeBindingMap.value(11).first != -1);
QVERIFY(nativeBindingMap.value(12).first != -1);
}
void tst_QShaderBaker::mslArgumentBuffers()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/sgtexture.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader, QShader::ArgumentBufferShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(150) });
targets.append({ QShader::MslShader, QShaderVersion(21) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
// the variant is MSL-only
QCOMPARE(s.availableShaders().size(), 4);
const QShaderKey stdKey(QShader::MslShader, QShaderVersion(21));
const QShaderKey argBufKey(QShader::MslShader, QShaderVersion(21), QShader::ArgumentBufferShader);
QVERIFY(s.availableShaders().contains(stdKey));
QVERIFY(s.availableShaders().contains(argBufKey));
const QByteArray argBufSource = s.shader(argBufKey).shader();
QVERIFY(argBufSource.contains(QByteArrayLiteral("struct spvDescriptorSetBuffer1")));
QVERIFY(argBufSource.contains(QByteArrayLiteral("[[id(0)]]")));
// buffers stay bound individually
QVERIFY(argBufSource.contains(QByteArrayLiteral("constant buf& ubuf [[buffer(1)]]")));
QVERIFY(!s.shader(stdKey).shader().contains(QByteArrayLiteral("spvDescriptorSetBuffer")));
const int argBufIndex = s.nativeShaderInfo(argBufKey).extraBufferBindings.value(
QShaderPrivate::MslArgumentBufferBinding, -1);
QCOMPARE(argBufIndex, 0);
QVERIFY(!s.nativeShaderInfo(stdKey).extraBufferBindings.contains(QShaderPrivate::MslArgumentBufferBinding));
// the combined image samplers now name slots in the argument buffer, and
// the uniform block has moved up to make room for the argument buffer
QShader::NativeResourceBindingMap map = s.nativeResourceBindingMap(argBufKey);
QCOMPARE(map.size(), 3);
QCOMPARE(map.value(0).first, 1);
QCOMPARE(map.value(1), std::make_pair(0, 1));
QCOMPARE(map.value(2), std::make_pair(2, 3));
map = s.nativeResourceBindingMap(stdKey);
QCOMPARE(map.value(0).first, 0);
QCOMPARE(map.value(1), std::make_pair(0, 0));
// no images or samplers, so no argument buffer and no extra key
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(!s.availableShaders().contains(argBufKey));
// below MSL 2.0 the variant cannot be generated
baker.setSourceFileName(QLatin1String(":/data/sgtexture.frag"));
targets.clear();
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(!s.availableShaders().contains(QShaderKey(QShader::MslShader, QShaderVersion(12),
QShader::ArgumentBufferShader)));
// arrays keep their declared size, and the texture and sampler slots of an
// array stay that many ids apart
baker.setSourceFileName(QLatin1String(":/data/arrays_of_samplers.frag"));
targets.clear();
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::MslShader, QShaderVersion(21) });
baker.setGeneratedShaders(targets);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(s.availableShaders().contains(argBufKey));
QVERIFY(s.shader(argBufKey).shader().contains(
QByteArrayLiteral("array<texture2d<float>, 4> shadowMaps")));
map = s.nativeResourceBindingMap(argBufKey);
QCOMPARE(map.value(8).second - map.value(8).first, 4);
QCOMPARE(map.value(9).second - map.value(9).first, 4);
}
void tst_QShaderBaker::hlslNativeBindingMap()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/manyresources.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
const QShaderKey shaderKey(QShader::HlslShader, QShaderVersion(50));
QShader::NativeResourceBindingMap nativeBindingMap = s.nativeResourceBindingMap(shaderKey);
QCOMPARE(nativeBindingMap.size(), 8);
// do not assume anything about the ordering, so verify that we have valid
// values, not the register binding values themselves
// combined image samplers
QVERIFY(nativeBindingMap.value(1).first != -1);
QVERIFY(nativeBindingMap.value(1).second == nativeBindingMap.value(1).first);
QVERIFY(nativeBindingMap.value(2).first != -1);
QVERIFY(nativeBindingMap.value(2).second == nativeBindingMap.value(2).first);
QVERIFY(nativeBindingMap.value(3).first != -1);
QVERIFY(nativeBindingMap.value(3).second == nativeBindingMap.value(3).first);
QVERIFY(nativeBindingMap.value(1).first != nativeBindingMap.value(2).first);
QVERIFY(nativeBindingMap.value(1).first != nativeBindingMap.value(3).first);
// storage images
QVERIFY(nativeBindingMap.value(4).first != -1);
QVERIFY(nativeBindingMap.value(5).first != -1);
QVERIFY(nativeBindingMap.value(4).first != nativeBindingMap.value(5).first);
// storage buffer
QVERIFY(nativeBindingMap.value(10).first != -1);
// uniform buffers
QVERIFY(nativeBindingMap.value(11).first != -1);
QVERIFY(nativeBindingMap.value(12).first != -1);
QVERIFY(nativeBindingMap.value(11).first != nativeBindingMap.value(12).first);
}
void tst_QShaderBaker::reflectArraysOfSamplers()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/arrays_of_samplers.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::GlslShader, QShaderVersion(150) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(20) }); // arrays of textures needs MSL 2.0
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(baker.errorMessage().isEmpty());
QVERIFY(s.isValid());
QShaderDescription desc = s.description();
QCOMPARE(desc.inputVariables().size(), 1);
QCOMPARE(desc.outputVariables().size(), 1);
QCOMPARE(desc.combinedImageSamplers().size(), 4);
for (const QShaderDescription::InOutVariable &var : desc.combinedImageSamplers()) {
switch (var.binding) {
case 4:
QCOMPARE(var.type, QShaderDescription::Sampler2D);
QVERIFY(var.arrayDims.isEmpty());
break;
case 8:
QCOMPARE(var.type, QShaderDescription::Sampler2D);
QCOMPARE(var.arrayDims.size(), 1);
QCOMPARE(var.arrayDims.first(), 4);
break;
case 9:
QCOMPARE(var.type, QShaderDescription::SamplerCube);
QCOMPARE(var.arrayDims.size(), 1);
QCOMPARE(var.arrayDims.first(), 4);
break;
case 10:
QCOMPARE(var.type, QShaderDescription::Sampler2DArray);
QVERIFY(var.arrayDims.isEmpty());
break;
default:
QFAIL(qPrintable(QStringLiteral("Wrong binding value: %1").arg(var.binding)));
}
}
}
void tst_QShaderBaker::perTargetCompileMode()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color_pertarget.vert"));
baker.setGeneratedShaderVariants({
QShader::StandardShader,
QShader::BatchableVertexShader
});
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(330) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
baker.setPreamble(QByteArrayLiteral("#define MY_VALUE 321\n#define MY_MACRO\n"));
baker.setPerTargetCompilation(true);
QShader s = baker.bake();
if (!s.isValid())
qDebug() << baker.errorMessage();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 2 * 6);
int batchableVariantCount = 0;
int batchableGlslVariantCount = 0;
for (const QShaderKey &key : s.availableShaders()) {
if (key.sourceVariant() == QShader::BatchableVertexShader) {
++batchableVariantCount;
if (key.source() == QShader::GlslShader) {
++batchableGlslVariantCount;
const QByteArray src = s.shader(key).shader();
QVERIFY(src.contains(QByteArrayLiteral("_qt_order * ")));
}
} else {
if (key.source() == QShader::GlslShader) {
// make sure it did not get rewritten
const QByteArray src = s.shader(key).shader();
QVERIFY(!src.contains(QByteArrayLiteral("_qt_order * ")));
}
}
}
QCOMPARE(batchableVariantCount, 6);
QCOMPARE(batchableGlslVariantCount, 3);
// now compile something that succeeds only if the QSHADER_SPIRV macros are
// present as expected
baker.setSourceFileName(QLatin1String(":/data/color_spirv_only.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
targets.clear();
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
baker.setPreamble(QByteArray());
s = baker.bake();
if (!s.isValid())
qDebug() << baker.errorMessage();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
// now something similar, with GLSL. This will mean no QSHADER_SPIRV,
// QSHADER_HLSL, QSHADER_MSL are defined (and is an error if they are)
baker.setSourceFileName(QLatin1String(":/data/color_glsl_only.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
targets.clear();
targets.append({ QShader::GlslShader, QShaderVersion(330) });
targets.append({ QShader::GlslShader, QShaderVersion(440) });
baker.setGeneratedShaders(targets);
s = baker.bake();
if (!s.isValid())
qDebug() << baker.errorMessage();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 2);
// HLSL 5.0 + MSL 1.2 (fails with others)
baker.setSourceFileName(QLatin1String(":/data/color_hlsl_msl_only.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
targets.clear();
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
s = baker.bake();
if (!s.isValid())
qDebug() << baker.errorMessage();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 2);
}
void tst_QShaderBaker::perTargetCompileModeReproducible()
{
// In per-target compilation mode there is one SPIR-V binary per target, and
// the single QShaderDescription of the resulting QShader has to be generated
// from one of them. Which one that is must not vary between bakes, not even
// when the reflection info differs per target (which it can, when the source
// declares its resources based on the QSHADER_* macros).
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color_pertarget_reflect.vert"));
baker.setGeneratedShaderVariants({
QShader::StandardShader,
QShader::BatchableVertexShader
});
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(330) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
baker.setPerTargetCompilation(true);
QByteArray reference;
for (int i = 0; i < 8; ++i) {
// Get a different QHash seed on every round. Picking the SPIR-V binary
// to reflect on out of a QHash would make the result depend on this.
QHashSeed::resetRandomGlobalSeed();
QShader s = baker.bake();
if (!s.isValid())
qDebug() << baker.errorMessage();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 2 * 5);
// The plain SPIR-V target is the one that wins, so the uniform block
// must have the single mat4 member and nothing else.
const QList<QShaderDescription::UniformBlock> blocks = s.description().uniformBlocks();
QCOMPARE(blocks.size(), 1);
QCOMPARE(blocks[0].members.size(), 1);
QCOMPARE(blocks[0].members[0].name, QByteArrayLiteral("mvp"));
// and the whole thing must serialize to the exact same bytes every time
const QByteArray serialized = s.serialized();
QVERIFY(!serialized.isEmpty());
if (reference.isEmpty())
reference = serialized;
else
QCOMPARE(serialized, reference);
}
}
void tst_QShaderBaker::serializeDeserialize()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 5);
QByteArray data = s.serialized();
QVERIFY(!data.isEmpty());
QShader s2;
QVERIFY(!s2.isValid());
s2 = QShader::fromSerialized(data);
QVERIFY(s2.isValid());
QCOMPARE(s, s2);
}
void tst_QShaderBaker::spirvOptions()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
// no options specified (no full debug info, no strip)
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
const QShaderKey key(QShader::SpirvShader, QShaderVersion(100));
QVERIFY(s.availableShaders().contains(key));
QCOMPARE(s.shader(key).entryPoint(), "main");
QByteArray bin = s.shader(key).shader();
// full debug info
baker.setSpirvOptions(QShaderBaker::SpirvOption::GenerateFullDebugInfo);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
QCOMPARE(s.shader(key).entryPoint(), "main");
QByteArray debugBin = s.shader(key).shader();
QVERIFY(bin != debugBin);
QVERIFY(debugBin.size() > bin.size());
// strip all (variable names, etc.)
baker.setSpirvOptions(QShaderBaker::SpirvOption::StripDebugAndVarInfo);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 1);
QCOMPARE(s.shader(key).entryPoint(), "main");
QByteArray strippedBin = s.shader(key).shader();
QVERIFY(strippedBin != debugBin);
QVERIFY(debugBin.size() > strippedBin.size());
QVERIFY(strippedBin != bin);
QVERIFY(bin.size() > strippedBin.size());
}
void tst_QShaderBaker::separateImagesAndSamplers()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/combined_and_separate_samplers.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(330) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
for (QShaderKey shaderKey : {
QShaderKey(QShader::HlslShader, QShaderVersion(50)),
QShaderKey(QShader::MslShader, QShaderVersion(12)) })
{
QShader::NativeResourceBindingMap nativeBindingMap = s.nativeResourceBindingMap(shaderKey);
QCOMPARE(nativeBindingMap.size(), 4);
// binding 1 is a combined image sampler
QVERIFY(nativeBindingMap.value(1).first != -1);
QVERIFY(nativeBindingMap.value(1).second != -1);
// binding 2 is a separate image
QVERIFY(nativeBindingMap.value(2).first != -1);
// presumably binding 1 got t0, then this is probably t1, the point is that they should be something different
QVERIFY(nativeBindingMap.value(2).first != nativeBindingMap.value(1).first);
// binding 3 is a separate sampler
QVERIFY(nativeBindingMap.value(3).first != -1);
// binding 4 as well
QVERIFY(nativeBindingMap.value(4).first != -1);
QVERIFY(nativeBindingMap.value(4).first != nativeBindingMap.value(3).first);
QVERIFY(s.separateToCombinedImageSamplerMappingList(shaderKey).isEmpty());
}
// Now onto to the real special deal here: OpenGL. That has its own mapping
// table because SPIRV-Cross auto-generates a "combined image sampler"
// (e.g. a sampler2D) for each separate texture+sampler combination.
for (QShaderKey shaderKey : {
QShaderKey(QShader::GlslShader, QShaderVersion(330)),
QShaderKey(QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs)) })
{
QShader::SeparateToCombinedImageSamplerMappingList list = s.separateToCombinedImageSamplerMappingList(shaderKey);
QCOMPARE(list.size(), 2);
for (int i = 0; i < list.size(); ++i) {
int tbinding = list.at(i).textureBinding;
int sbinding = list.at(i).samplerBinding;
QCOMPARE(tbinding, 2);
QVERIFY(sbinding == 3 || sbinding == 4);
QByteArray combinedName = list.at(i).combinedSamplerName;
QVERIFY(!combinedName.isEmpty());
}
QVERIFY(s.nativeResourceBindingMap(shaderKey).isEmpty());
}
}
void tst_QShaderBaker::tessellationForMetalVertCompile()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader,
QShader::NonIndexedVertexAsComputeShader,
QShader::UInt16IndexedVertexAsComputeShader,
QShader::UInt32IndexedVertexAsComputeShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(430) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QVERIFY(s.stage() == QShader::VertexStage);
QCOMPARE(s.availableShaders().size(), 6);
QVERIFY(!s.shader(QShaderKey(QShader::MslShader, QShaderVersion(12), QShader::NonIndexedVertexAsComputeShader)).shader().isEmpty());
QVERIFY(!s.shader(QShaderKey(QShader::MslShader, QShaderVersion(12), QShader::UInt16IndexedVertexAsComputeShader)).shader().isEmpty());
QVERIFY(!s.shader(QShaderKey(QShader::MslShader, QShaderVersion(12), QShader::UInt32IndexedVertexAsComputeShader)).shader().isEmpty());
QShaderDescription desc = s.description();
QCOMPARE(desc.outputBuiltinVariables().size(), 1);
QCOMPARE(desc.outputBuiltinVariables()[0].type, QShaderDescription::PositionBuiltin);
QShader::NativeShaderInfo info = s.nativeShaderInfo(QShaderKey(QShader::MslShader, QShaderVersion(12), QShader::NonIndexedVertexAsComputeShader));
QCOMPARE(info.extraBufferBindings.size(), 1);
QVERIFY(info.extraBufferBindings.value(QShaderPrivate::MslTessVertTescOutputBufferBinding, -1) >= 0);
info = s.nativeShaderInfo(QShaderKey(QShader::MslShader, QShaderVersion(12), QShader::UInt32IndexedVertexAsComputeShader));
QCOMPARE(info.extraBufferBindings.size(), 2);
const int outVertBufIndex = info.extraBufferBindings.value(QShaderPrivate::MslTessVertTescOutputBufferBinding, -1);
QVERIFY(outVertBufIndex >= 0);
QVERIFY(info.extraBufferBindings.value(QShaderPrivate::MslTessVertIndicesBufferBinding, -1) >= 0);
QVERIFY(info.extraBufferBindings.value(QShaderPrivate::MslTessVertIndicesBufferBinding, -1) != outVertBufIndex);
}
void tst_QShaderBaker::tessellationCompile()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/tess.tesc"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(430) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
baker.setTessellationMode(QShaderDescription::TrianglesTessellationMode);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(s.stage() == QShader::TessellationControlStage);
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 3);
QShaderDescription desc = s.description();
// builtins are expected to be stored sorted by type
QCOMPARE(desc.inputBuiltinVariables()[0].type, QShaderDescription::PositionBuiltin);
QCOMPARE(desc.inputBuiltinVariables()[1].type, QShaderDescription::InvocationIdBuiltin);
QCOMPARE(desc.outputBuiltinVariables()[0].type, QShaderDescription::PositionBuiltin);
QCOMPARE(desc.outputBuiltinVariables()[1].type, QShaderDescription::TessLevelOuterBuiltin);
QCOMPARE(desc.outputBuiltinVariables()[2].type, QShaderDescription::TessLevelInnerBuiltin);
QCOMPARE(desc.tessellationOutputVertexCount(), uint(3));
QCOMPARE(desc.outputVariables().size(), 3);
for (const QShaderDescription::InOutVariable &v : desc.outputVariables()) {
switch (v.location) {
case 0:
QCOMPARE(v.name, QByteArrayLiteral("outColor"));
QCOMPARE(v.type, QShaderDescription::Vec3);
QCOMPARE(v.perPatch, false);
break;
case 1:
QCOMPARE(v.name, QByteArrayLiteral("stuff"));
QCOMPARE(v.type, QShaderDescription::Vec3);
QCOMPARE(v.perPatch, true);
break;
case 2:
QCOMPARE(v.name, QByteArrayLiteral("more_stuff"));
QCOMPARE(v.type, QShaderDescription::Float);
QCOMPARE(v.perPatch, true);
break;
default:
QFAIL(qPrintable(QStringLiteral("Bad location: %1").arg(v.location)));
break;
}
}
QVERIFY(s.shader(QShaderKey(QShader::MslShader, QShaderVersion(12))).shader().contains(QByteArrayLiteral("MTLTriangleTessellationFactorsHalf")));
QCOMPARE(s.nativeShaderInfo(QShaderKey(QShader::MslShader, QShaderVersion(12))).extraBufferBindings.size(), 5);
baker.setSourceFileName(QLatin1String(":/data/tess.tese"));
baker.setGeneratedShaders(targets);
baker.setTessellationOutputVertexCount(3);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(s.stage() == QShader::TessellationEvaluationStage);
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 3);
desc = s.description();
QCOMPARE(desc.inputBuiltinVariables()[0].type, QShaderDescription::PositionBuiltin);
QCOMPARE(desc.inputBuiltinVariables()[1].type, QShaderDescription::TessLevelOuterBuiltin);
QCOMPARE(desc.inputBuiltinVariables()[2].type, QShaderDescription::TessLevelInnerBuiltin);
QCOMPARE(desc.inputBuiltinVariables()[3].type, QShaderDescription::TessCoordBuiltin);
QCOMPARE(desc.tessellationMode(), QShaderDescription::TrianglesTessellationMode);
QCOMPARE(desc.tessellationWindingOrder(), QShaderDescription::CcwTessellationWindingOrder);
QCOMPARE(desc.tessellationPartitioning(), QShaderDescription::FractionalOddTessellationPartitioning);
QCOMPARE(desc.inputVariables().size(), 3);
for (const QShaderDescription::InOutVariable &v : desc.inputVariables()) {
switch (v.location) {
case 0:
QCOMPARE(v.name, QByteArrayLiteral("inColor"));
QCOMPARE(v.type, QShaderDescription::Vec3);
QCOMPARE(v.perPatch, false);
break;
case 1:
QCOMPARE(v.name, QByteArrayLiteral("stuff"));
QCOMPARE(v.type, QShaderDescription::Vec3);
QCOMPARE(v.perPatch, true);
break;
case 2:
QCOMPARE(v.name, QByteArrayLiteral("more_stuff"));
QCOMPARE(v.type, QShaderDescription::Float);
QCOMPARE(v.perPatch, true);
break;
default:
QFAIL(qPrintable(QStringLiteral("Bad location: %1").arg(v.location)));
break;
}
}
// the uniform buffer binding -> Metal buffer index mapping
QCOMPARE(s.nativeResourceBindingMap(QShaderKey(QShader::MslShader, QShaderVersion(12))).size(), 1);
QCOMPARE(s.nativeResourceBindingMap(QShaderKey(QShader::MslShader, QShaderVersion(12))).value(0), std::make_pair(0, -1));
QVERIFY(s.shader(QShaderKey(QShader::MslShader, QShaderVersion(12))).shader().contains(QByteArrayLiteral("[[ patch(triangle, 3) ]]")));
}
void tst_QShaderBaker::tessellationCompileWithChangedTessArgs()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/tess.tesc"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
// not what the .tese would say but let's pretend
baker.setTessellationMode(QShaderDescription::QuadTessellationMode);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QVERIFY(s.shader(QShaderKey(QShader::MslShader, QShaderVersion(12))).shader().contains(QByteArrayLiteral("MTLQuadTessellationFactorsHalf")));
baker.setSourceFileName(QLatin1String(":/data/tess.tese"));
baker.setGeneratedShaders(targets);
baker.setTessellationOutputVertexCount(13);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(s.stage() == QShader::TessellationEvaluationStage);
QVERIFY(baker.errorMessage().isEmpty());
QVERIFY(s.shader(QShaderKey(QShader::MslShader, QShaderVersion(12))).shader().contains(QByteArrayLiteral("[[ patch(triangle, 13) ]]")));
}
void tst_QShaderBaker::dontBreakOnTranslationError()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/texturesize.frag"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QVector<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(300, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QCOMPARE(s.availableShaders().size(), 5);
QVERIFY(baker.errorMessage().isEmpty());
// now add a problematic target (no textureSize() in GLSL ES 100)
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
baker.setGeneratedShaders(targets);
QVERIFY(!baker.bake().isValid());
QVERIFY(!baker.errorMessage().isEmpty());
// now make it succeed by skipping the failing targets
baker.setBreakOnShaderTranslationError(false);
s = baker.bake();
QVERIFY(s.isValid());
// somewhat undocumented but the error message still contains the
// SPIRV-Cross error message about GLSL ES 100 even though the
// baking succeeded
QVERIFY(!baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 5);
}
void tst_QShaderBaker::storageImageFlags()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/imageloadstore.comp"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QVector<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QCOMPARE(s.description().storageImages().size(), 4);
QCOMPARE(s.description().storageImages().at(0).binding, 0);
QCOMPARE(s.description().storageImages().at(0).imageFlags, QShaderDescription::ImageFlags());
QCOMPARE(s.description().storageImages().at(1).binding, 1);
QCOMPARE(s.description().storageImages().at(1).imageFlags,
QShaderDescription::ImageFlags(QShaderDescription::ImageFlag::WriteOnlyImage));
QCOMPARE(s.description().storageImages().at(2).binding, 2);
QCOMPARE(s.description().storageImages().at(2).imageFlags,
QShaderDescription::ImageFlags(QShaderDescription::ImageFlag::ReadOnlyImage));
QCOMPARE(s.description().storageImages().at(3).binding, 3);
QCOMPARE(s.description().storageImages().at(3).imageFlags,
QShaderDescription::ImageFlags(QShaderDescription::ImageFlag::ReadOnlyImage
| QShaderDescription::ImageFlag::WriteOnlyImage));
}
void tst_QShaderBaker::storageBufferRuntimeArrayStride()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/storagebuffer.comp"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QVector<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QCOMPARE(s.description().storageBlocks().size(), 8);
QCOMPARE(s.description().storageBlocks().at(0).binding, 0);
QCOMPARE(s.description().storageBlocks().at(0).runtimeArrayStride, 4);
QCOMPARE(s.description().storageBlocks().at(1).binding, 1);
QCOMPARE(s.description().storageBlocks().at(1).runtimeArrayStride, 16);
QCOMPARE(s.description().storageBlocks().at(2).binding, 2);
QCOMPARE(s.description().storageBlocks().at(2).runtimeArrayStride, 8);
QCOMPARE(s.description().storageBlocks().at(3).binding, 3);
QCOMPARE(s.description().storageBlocks().at(3).runtimeArrayStride, 16);
QCOMPARE(s.description().storageBlocks().at(4).binding, 4);
QCOMPARE(s.description().storageBlocks().at(4).runtimeArrayStride, 16);
QCOMPARE(s.description().storageBlocks().at(5).binding, 5);
QCOMPARE(s.description().storageBlocks().at(5).runtimeArrayStride, 16);
QCOMPARE(s.description().storageBlocks().at(6).binding, 6);
QCOMPARE(s.description().storageBlocks().at(6).runtimeArrayStride, 16);
QCOMPARE(s.description().storageBlocks().at(7).binding, 7);
QCOMPARE(s.description().storageBlocks().at(7).runtimeArrayStride, 16);
}
void tst_QShaderBaker::storageBufferQualifiers()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/storagebuffer.comp"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QVector<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
// GLSL 4.60 Specification - Section 4.10 Memory Qualifiers:
// Since the external source reading or writing a volatile variable may be another shader
// invocation, variables declared as volatile are automatically treated as coherent.
QCOMPARE(s.description().storageBlocks().size(), 8);
QCOMPARE(s.description().storageBlocks().at(0).binding, 0);
QCOMPARE(s.description().storageBlocks().at(0).qualifierFlags,
QShaderDescription::QualifierFlags());
QCOMPARE(s.description().storageBlocks().at(1).binding, 1);
QCOMPARE(s.description().storageBlocks().at(1).qualifierFlags,
QShaderDescription::QualifierFlags(QShaderDescription::QualifierCoherent));
QCOMPARE(s.description().storageBlocks().at(2).binding, 2);
QCOMPARE(s.description().storageBlocks().at(2).qualifierFlags,
QShaderDescription::QualifierFlags(QShaderDescription::QualifierWriteOnly
| QShaderDescription::QualifierVolatile
| QShaderDescription::QualifierCoherent));
QCOMPARE(s.description().storageBlocks().at(3).binding, 3);
QCOMPARE(s.description().storageBlocks().at(3).qualifierFlags,
QShaderDescription::QualifierFlags(QShaderDescription::QualifierWriteOnly
| QShaderDescription::QualifierRestrict));
QCOMPARE(s.description().storageBlocks().at(4).binding, 4);
QCOMPARE(s.description().storageBlocks().at(4).qualifierFlags,
QShaderDescription::QualifierFlags(QShaderDescription::QualifierReadOnly));
QCOMPARE(s.description().storageBlocks().at(5).binding, 5);
QCOMPARE(s.description().storageBlocks().at(5).qualifierFlags,
QShaderDescription::QualifierFlags(QShaderDescription::QualifierReadOnly
| QShaderDescription::QualifierCoherent));
QCOMPARE(s.description().storageBlocks().at(6).binding, 6);
QCOMPARE(s.description().storageBlocks().at(6).qualifierFlags,
QShaderDescription::QualifierFlags(QShaderDescription::QualifierWriteOnly
| QShaderDescription::QualifierReadOnly
| QShaderDescription::QualifierVolatile
| QShaderDescription::QualifierCoherent));
QCOMPARE(s.description().storageBlocks().at(7).binding, 7);
QCOMPARE(s.description().storageBlocks().at(7).qualifierFlags,
QShaderDescription::QualifierFlags(QShaderDescription::QualifierWriteOnly
| QShaderDescription::QualifierReadOnly
| QShaderDescription::QualifierRestrict));
}
void tst_QShaderBaker::multiview()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/multiview_simple.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QVector<QShaderBaker::GeneratedShader> targets;
// SPV_KHR_multiview
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
// SV_ViewID is in shader model 6.1
targets.append({ QShader::HlslShader, QShaderVersion(61) });
// GL_OVR_multiview(2) is written for OpenGL 3.0 / OpenGL ES 3.0 and newer, just pick
// some GLSL versions accordingly for the test
targets.append({ QShader::GlslShader, QShaderVersion(150) });
targets.append({ QShader::GlslShader, QShaderVersion(300, QShaderVersion::GlslEs) });
baker.setGeneratedShaders(targets);
// should fail due to GLSL
QShader s = baker.bake();
QVERIFY(!s.isValid());
QVERIFY(!baker.errorMessage().isEmpty());
qDebug() << baker.errorMessage();
// now provide num_views and it should succeed
baker.setMultiViewCount(2);
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
}
void tst_QShaderBaker::mediump()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/color.vert"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs) });
targets.append({ QShader::GlslShader, QShaderVersion(120) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
targets.append({ QShader::MslShader, QShaderVersion(12) });
baker.setGlslOptions(QShaderBaker::GlslOption::GlslEsFragDefaultFloatPrecisionMedium);
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 5);
QShaderCode shader = s.shader(QShaderKey(QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs)));
QVERIFY(!shader.shader().isEmpty());
QVERIFY(!shader.shader().contains("precision ")); // no effect for vertex shaders
baker.setSourceFileName(QLatin1String(":/data/color.frag"));
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 5);
shader = s.shader(QShaderKey(QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs)));
QVERIFY(!shader.shader().isEmpty());
QVERIFY(shader.shader().contains("precision mediump float;"));
// back to defaults
baker.setGlslOptions({});
s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 5);
shader = s.shader(QShaderKey(QShader::GlslShader, QShaderVersion(100, QShaderVersion::GlslEs)));
QVERIFY(!shader.shader().isEmpty());
QVERIFY(shader.shader().contains("precision highp float;"));
}
void tst_QShaderBaker::geometryShader()
{
QShaderBaker baker;
baker.setSourceFileName(QLatin1String(":/data/voxelize.geom"));
baker.setGeneratedShaderVariants({ QShader::StandardShader });
QList<QShaderBaker::GeneratedShader> targets;
targets.append({ QShader::SpirvShader, QShaderVersion(100) });
targets.append({ QShader::GlslShader, QShaderVersion(410) });
targets.append({ QShader::GlslShader, QShaderVersion(320, QShaderVersion::GlslEs) });
targets.append({ QShader::HlslShader, QShaderVersion(50) });
baker.setGeneratedShaders(targets);
QShader s = baker.bake();
QVERIFY(s.isValid());
QVERIFY(s.stage() == QShader::GeometryStage);
QVERIFY(baker.errorMessage().isEmpty());
QCOMPARE(s.availableShaders().size(), 4);
}
#include <tst_qshaderbaker.moc>
QTEST_MAIN(tst_QShaderBaker)