Revision control
Copy as Markdown
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qspirvshader_p.h"
#include "qspirvshaderremap_p.h"
#include <private/qshaderdescription_p.h>
#include <private/qshader_p.h>
#include <spirv_cross_c.h>
QT_BEGIN_NAMESPACE
struct QSpirvShaderPrivate
{
~QSpirvShaderPrivate();
void createCompiler(spvc_backend backend);
void reflect();
QShaderDescription::InOutVariable inOutVar(const spvc_reflected_resource &r);
QShaderDescription::BlockVariable blockVar(spvc_type_id typeId, uint32_t memberIdx);
QShader::Stage stage;
QByteArray ir;
QShaderDescription shaderDescription;
spvc_context ctx = nullptr;
spvc_compiler glslGen = nullptr;
spvc_compiler hlslGen = nullptr;
spvc_compiler mslGen = nullptr;
QString spirvCrossErrorMsg;
};
QSpirvShaderPrivate::~QSpirvShaderPrivate()
{
spvc_context_destroy(ctx);
}
void QSpirvShaderPrivate::createCompiler(spvc_backend backend)
{
if (!ctx) {
if (spvc_context_create(&ctx) != SPVC_SUCCESS) {
qWarning("Failed to create SPIRV-Cross context");
return;
}
}
const SpvId *spirv = reinterpret_cast<const SpvId *>(ir.constData());
size_t wordCount = size_t(ir.size()) / sizeof(SpvId);
spvc_parsed_ir parsedIr;
if (spvc_context_parse_spirv(ctx, spirv, wordCount, &parsedIr) != SPVC_SUCCESS) {
qWarning("Failed to parse SPIR-V: %s", spvc_context_get_last_error_string(ctx));
return;
}
spvc_compiler *outCompiler = nullptr;
switch (backend) {
case SPVC_BACKEND_GLSL:
outCompiler = &glslGen;
break;
case SPVC_BACKEND_HLSL:
outCompiler = &hlslGen;
break;
case SPVC_BACKEND_MSL:
outCompiler = &mslGen;
break;
default:
return;
}
if (spvc_context_create_compiler(ctx, backend, parsedIr,
SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, outCompiler) != SPVC_SUCCESS)
{
qWarning("Failed to create SPIRV-Cross compiler: %s", spvc_context_get_last_error_string(ctx));
return;
}
}
static QShaderDescription::VariableType matVarType(const spvc_type &t, QShaderDescription::VariableType compType)
{
const unsigned vecsize = spvc_type_get_vector_size(t);
switch (spvc_type_get_columns(t)) {
case 2:
return QShaderDescription::VariableType(compType + 4 + (vecsize == 3 ? 1 : vecsize == 4 ? 2 : 0));
case 3:
return QShaderDescription::VariableType(compType + 7 + (vecsize == 2 ? 1 : vecsize == 4 ? 2 : 0));
case 4:
return QShaderDescription::VariableType(compType + 10 + (vecsize == 2 ? 1 : vecsize == 3 ? 2 : 0));
default:
return QShaderDescription::Unknown;
}
}
static QShaderDescription::VariableType vecVarType(const spvc_type &t, QShaderDescription::VariableType compType)
{
switch (spvc_type_get_vector_size(t)) {
case 1:
return compType;
case 2:
return QShaderDescription::VariableType(compType + 1);
case 3:
return QShaderDescription::VariableType(compType + 2);
case 4:
return QShaderDescription::VariableType(compType + 3);
default:
return QShaderDescription::Unknown;
}
}
static QShaderDescription::VariableType sampledImageVarType(const spvc_type &t)
{
switch (spvc_type_get_image_dimension(t)) {
case SpvDim1D:
return spvc_type_get_image_arrayed(t) ? QShaderDescription::Sampler1DArray
: QShaderDescription::Sampler1D;
case SpvDim2D:
return spvc_type_get_image_arrayed(t)
? (spvc_type_get_image_multisampled(t) ? QShaderDescription::Sampler2DMSArray
: QShaderDescription::Sampler2DArray)
: (spvc_type_get_image_multisampled(t) ? QShaderDescription::Sampler2DMS
: QShaderDescription::Sampler2D);
case SpvDim3D:
return spvc_type_get_image_arrayed(t) ? QShaderDescription::Sampler3DArray
: QShaderDescription::Sampler3D;
case SpvDimCube:
return spvc_type_get_image_arrayed(t) ? QShaderDescription::SamplerCubeArray
: QShaderDescription::SamplerCube;
case SpvDimRect:
return QShaderDescription::SamplerRect;
case SpvDimBuffer:
return QShaderDescription::SamplerBuffer;
default:
return QShaderDescription::Unknown;
}
}
static QShaderDescription::VariableType imageVarType(const spvc_type &t)
{
switch (spvc_type_get_image_dimension(t)) {
case SpvDim1D:
return spvc_type_get_image_arrayed(t) ? QShaderDescription::Image1DArray
: QShaderDescription::Image1D;
case SpvDim2D:
return spvc_type_get_image_arrayed(t)
? (spvc_type_get_image_multisampled(t) ? QShaderDescription::Image2DMSArray
: QShaderDescription::Image2DArray)
: (spvc_type_get_image_multisampled(t) ? QShaderDescription::Image2DMS
: QShaderDescription::Image2D);
case SpvDim3D:
return spvc_type_get_image_arrayed(t) ? QShaderDescription::Image3DArray
: QShaderDescription::Image3D;
case SpvDimCube:
return spvc_type_get_image_arrayed(t) ? QShaderDescription::ImageCubeArray
: QShaderDescription::ImageCube;
case SpvDimRect:
return QShaderDescription::ImageRect;
case SpvDimBuffer:
return QShaderDescription::ImageBuffer;
default:
return QShaderDescription::Unknown;
}
}
static QShaderDescription::VariableType varType(const spvc_type &t)
{
QShaderDescription::VariableType vt = QShaderDescription::Unknown;
const spvc_basetype basetype = spvc_type_get_basetype(t);
switch (basetype) {
case SPVC_BASETYPE_FP32:
vt = spvc_type_get_columns(t) > 1 ? matVarType(t, QShaderDescription::Float)
: vecVarType(t, QShaderDescription::Float);
break;
case SPVC_BASETYPE_FP64:
vt = spvc_type_get_columns(t) > 1 ? matVarType(t, QShaderDescription::Double)
: vecVarType(t, QShaderDescription::Double);
break;
case SPVC_BASETYPE_UINT32:
vt = vecVarType(t, QShaderDescription::Uint);
break;
case SPVC_BASETYPE_INT32:
vt = vecVarType(t, QShaderDescription::Int);
break;
case SPVC_BASETYPE_BOOLEAN:
vt = vecVarType(t, QShaderDescription::Uint);
break;
case SPVC_BASETYPE_SAMPLED_IMAGE:
vt = sampledImageVarType(t);
break;
case SPVC_BASETYPE_IMAGE:
vt = imageVarType(t);
break;
case SPVC_BASETYPE_SAMPLER:
vt = QShaderDescription::Sampler;
break;
case SPVC_BASETYPE_STRUCT:
vt = QShaderDescription::Struct;
break;
default:
// can encounter types we do not (yet) handle, return Unknown for those
qWarning("Unsupported base type %d", basetype);
break;
}
return vt;
}
QShaderDescription::InOutVariable QSpirvShaderPrivate::inOutVar(const spvc_reflected_resource &r)
{
QShaderDescription::InOutVariable v;
v.name = r.name;
spvc_type baseTypeHandle = spvc_compiler_get_type_handle(glslGen, r.base_type_id);
v.type = varType(baseTypeHandle);
spvc_type typeHandle = spvc_compiler_get_type_handle(glslGen, r.type_id);
for (unsigned i = 0, dimCount = spvc_type_get_num_array_dimensions(typeHandle); i < dimCount; ++i)
v.arrayDims.append(int(spvc_type_get_array_dimension(typeHandle, i)));
if (spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationLocation))
v.location = spvc_compiler_get_decoration(glslGen, r.id, SpvDecorationLocation);
if (spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationBinding))
v.binding = spvc_compiler_get_decoration(glslGen, r.id, SpvDecorationBinding);
if (spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationDescriptorSet))
v.descriptorSet = spvc_compiler_get_decoration(glslGen, r.id, SpvDecorationDescriptorSet);
if (spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationPatch))
v.perPatch = spvc_compiler_get_decoration(glslGen, r.id, SpvDecorationPatch);
if (spvc_type_get_basetype(baseTypeHandle) == SPVC_BASETYPE_IMAGE) {
v.imageFormat = QShaderDescription::ImageFormat(spvc_type_get_image_storage_format(baseTypeHandle));
v.imageFlags.setFlag(QShaderDescription::ImageFlag::WriteOnlyImage,
spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationNonReadable));
v.imageFlags.setFlag(QShaderDescription::ImageFlag::ReadOnlyImage,
spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationNonWritable));
}
if (v.type == QShaderDescription::Struct) {
const unsigned count = spvc_type_get_num_member_types(baseTypeHandle);
const spvc_type_id id = spvc_type_get_base_type_id(baseTypeHandle);
for (unsigned idx = 0; idx < count; ++idx) {
v.structMembers.append(blockVar(id, idx));
v.perPatch |= bool(spvc_compiler_has_member_decoration(glslGen, id, idx, SpvDecorationPatch));
}
}
return v;
}
QShaderDescription::BlockVariable QSpirvShaderPrivate::blockVar(spvc_type_id typeId, uint32_t memberIdx)
{
QShaderDescription::BlockVariable v;
v.name = spvc_compiler_get_member_name(glslGen, typeId, memberIdx);
spvc_type t = spvc_compiler_get_type_handle(glslGen, typeId);
spvc_type_id memberTypeId = spvc_type_get_member_type(t, memberIdx);
spvc_type memberType = spvc_compiler_get_type_handle(glslGen, memberTypeId);
v.type = varType(memberType);
v.offset = -1;
unsigned offset = 0;
if (spvc_compiler_type_struct_member_offset(glslGen, t, memberIdx, &offset) == SPVC_SUCCESS)
v.offset = int(offset);
size_t size = 0;
if (spvc_compiler_get_declared_struct_member_size(glslGen, t, memberIdx, &size) == SPVC_SUCCESS)
v.size = int(size);
for (unsigned i = 0, dimCount = spvc_type_get_num_array_dimensions(memberType); i < dimCount; ++i)
v.arrayDims.append(int(spvc_type_get_array_dimension(memberType, i)));
if (spvc_compiler_has_member_decoration(glslGen, typeId, memberIdx, SpvDecorationArrayStride)) {
unsigned stride = 0;
if (spvc_compiler_type_struct_member_array_stride(glslGen, t, memberIdx, &stride) == SPVC_SUCCESS)
v.arrayStride = int(stride);
}
if (spvc_compiler_has_member_decoration(glslGen, typeId, memberIdx, SpvDecorationMatrixStride)) {
unsigned stride = 0;
if (spvc_compiler_type_struct_member_matrix_stride(glslGen, t, memberIdx, &stride) == SPVC_SUCCESS)
v.matrixStride = int(stride);
}
if (spvc_compiler_has_member_decoration(glslGen, typeId, memberIdx, SpvDecorationRowMajor))
v.matrixIsRowMajor = true;
if (v.type == QShaderDescription::Struct) {
unsigned count = spvc_type_get_num_member_types(memberType);
for (unsigned idx = 0; idx < count; ++idx)
v.structMembers.append(blockVar(spvc_type_get_base_type_id(memberType), idx));
}
return v;
}
void QSpirvShaderPrivate::reflect()
{
if (!glslGen)
return;
shaderDescription = QShaderDescription();
QShaderDescriptionPrivate *dd = QShaderDescriptionPrivate::get(&shaderDescription);
dd->localSize[0] = spvc_compiler_get_execution_mode_argument_by_index(glslGen, SpvExecutionModeLocalSize, 0);
dd->localSize[1] = spvc_compiler_get_execution_mode_argument_by_index(glslGen, SpvExecutionModeLocalSize, 1);
dd->localSize[2] = spvc_compiler_get_execution_mode_argument_by_index(glslGen, SpvExecutionModeLocalSize, 2);
dd->tessOutVertCount = spvc_compiler_get_execution_mode_argument(glslGen, SpvExecutionModeOutputVertices);
dd->tessMode = QShaderDescription::UnknownTessellationMode;
dd->tessWind = QShaderDescription::UnknownTessellationWindingOrder;
dd->tessPart = QShaderDescription::UnknownTessellationPartitioning;
const SpvExecutionMode *execModes = nullptr;
size_t execModeCount = 0;
if (spvc_compiler_get_execution_modes(glslGen, &execModes, &execModeCount) != SPVC_SUCCESS) {
qWarning("Failed to get shader execution modes: %s", spvc_context_get_last_error_string(ctx));
return;
}
for (size_t i = 0; i < execModeCount; ++i) {
switch (execModes[i]) {
case SpvExecutionModeTriangles:
dd->tessMode = QShaderDescription::TrianglesTessellationMode;
break;
case SpvExecutionModeQuads:
dd->tessMode = QShaderDescription::QuadTessellationMode;
break;
case SpvExecutionModeIsolines:
qWarning("Isoline execution mode used for tessellation,"
" this is not portable and may not work as expected.");
dd->tessMode = QShaderDescription::IsolineTessellationMode;
break;
case SpvExecutionModeSpacingEqual:
dd->tessPart = QShaderDescription::EqualTessellationPartitioning;
break;
case SpvExecutionModeSpacingFractionalEven:
dd->tessPart = QShaderDescription::FractionalEvenTessellationPartitioning;
break;
case SpvExecutionModeSpacingFractionalOdd:
dd->tessPart = QShaderDescription::FractionalOddTessellationPartitioning;
break;
case SpvExecutionModeVertexOrderCw:
dd->tessWind = QShaderDescription::CwTessellationWindingOrder;
break;
case SpvExecutionModeVertexOrderCcw :
dd->tessWind = QShaderDescription::CcwTessellationWindingOrder;
break;
default:
break;
}
}
// For builtin inputs/outputs (think of things like gl_Position (or
// gl_out[].gl_Position), gl_InvocationID, gl_TessLevelOuter, etc.) we only
// want the ones that are active (really read or written).
spvc_compiler_update_active_builtins(glslGen);
spvc_resources resources;
if (spvc_compiler_create_shader_resources(glslGen, &resources) != SPVC_SUCCESS) {
qWarning("Failed to get shader resources: %s", spvc_context_get_last_error_string(ctx));
return;
}
const spvc_reflected_resource *resourceList = nullptr;
const spvc_reflected_builtin_resource *builtinResourceList = nullptr;
size_t resourceListCount = 0;
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STAGE_INPUT,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const QShaderDescription::InOutVariable v = inOutVar(resourceList[i]);
if (v.type != QShaderDescription::Unknown)
dd->inVars.append(v);
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STAGE_OUTPUT,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const QShaderDescription::InOutVariable v = inOutVar(resourceList[i]);
if (v.type != QShaderDescription::Unknown)
dd->outVars.append(v);
}
}
if (spvc_resources_get_builtin_resource_list_for_type(resources, SPVC_BUILTIN_RESOURCE_TYPE_STAGE_INPUT,
&builtinResourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
if (spvc_compiler_has_active_builtin(glslGen, builtinResourceList[i].builtin, SpvStorageClassInput)) {
QShaderDescription::BuiltinVariable v;
v.type = QShaderDescription::BuiltinType(builtinResourceList[i].builtin);
spvc_type type = spvc_compiler_get_type_handle(
glslGen, builtinResourceList[i].value_type_id);
v.varType = varType(type);
for (unsigned i = 0, dimCount = spvc_type_get_num_array_dimensions(type);
i < dimCount; ++i)
v.arrayDims.append(int(spvc_type_get_array_dimension(type, i)));
dd->inBuiltins.append(v);
}
}
std::sort(dd->inBuiltins.begin(), dd->inBuiltins.end(),
[](const QShaderDescription::BuiltinVariable &a, const QShaderDescription::BuiltinVariable &b)
{
return a.type < b.type;
});
}
if (spvc_resources_get_builtin_resource_list_for_type(resources, SPVC_BUILTIN_RESOURCE_TYPE_STAGE_OUTPUT,
&builtinResourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
if (spvc_compiler_has_active_builtin(glslGen, builtinResourceList[i].builtin, SpvStorageClassOutput)) {
QShaderDescription::BuiltinVariable v;
v.type = QShaderDescription::BuiltinType(builtinResourceList[i].builtin);
spvc_type type = spvc_compiler_get_type_handle(
glslGen, builtinResourceList[i].value_type_id);
v.varType = varType(type);
for (unsigned i = 0, dimCount = spvc_type_get_num_array_dimensions(type);
i < dimCount; ++i)
v.arrayDims.append(int(spvc_type_get_array_dimension(type, i)));
dd->outBuiltins.append(v);
}
}
std::sort(dd->outBuiltins.begin(), dd->outBuiltins.end(),
[](const QShaderDescription::BuiltinVariable &a, const QShaderDescription::BuiltinVariable &b)
{
return a.type < b.type;
});
}
// uniform blocks map to either a uniform buffer or a plain struct
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_UNIFORM_BUFFER,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const spvc_reflected_resource &r(resourceList[i]);
spvc_type t = spvc_compiler_get_type_handle(glslGen, r.base_type_id);
QShaderDescription::UniformBlock block;
block.blockName = r.name;
// the simple case:
// layout(...) uniform blk { T v; } inst;
// gives us blockName "blk" and structName "inst" because
// in GLSL without uniform blocks this ends up being
// struct blk { T v; }; uniform blk inst;
// or, where real UBs are used, for instance Metal:
// struct blk { T v; }; constant blk& inst [[buffer(N)]]
block.structName = spvc_compiler_get_name(glslGen, r.id);
// the annoying case:
// layout(...) uniform blk { T v; };
// here structName is empty and the generated code (when no uniform
// blocks) uses _ID as a fallback name:
// struct blk { T v; }; uniform blk _ID;
// or, with real uniform buffers, f.ex. Metal:
// struct blk { T v; }; constant blk& _ID [[buffer(N)]]
// Let's make sure the fallback name is filled in correctly.
if (block.structName.isEmpty()) {
// The catch (matters only when uniform blocks are not used in
// the output) is that ID is per-shader and so may differ
// between shaders, meaning that having the same uniform block
// in a vertex and fragment shader will lead to each stage
// having its own set of uniforms corresponding to the ub
// members (ofc, inactive uniforms may get optimized out by the
// compiler, so the duplication then is only there for members
// used in both stages). Not much we can do about that here,
// though. The GL backend of QRhi can deal with this.
block.structName = QByteArrayLiteral("_") + QByteArray::number(r.id);
}
size_t size = 0;
spvc_compiler_get_declared_struct_size(glslGen, t, &size);
block.size = int(size);
if (spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationBinding))
block.binding = int(spvc_compiler_get_decoration(glslGen, r.id, SpvDecorationBinding));
if (spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationDescriptorSet))
block.descriptorSet = int(spvc_compiler_get_decoration(glslGen, r.id, SpvDecorationDescriptorSet));
unsigned count = spvc_type_get_num_member_types(t);
for (unsigned idx = 0; idx < count; ++idx) {
const QShaderDescription::BlockVariable v = blockVar(r.base_type_id, idx);
if (v.type != QShaderDescription::Unknown)
block.members.append(v);
}
dd->uniformBlocks.append(block);
}
}
// push constant blocks map to a plain GLSL struct regardless of version
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_PUSH_CONSTANT,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const spvc_reflected_resource &r(resourceList[i]);
spvc_type t = spvc_compiler_get_type_handle(glslGen, r.base_type_id);
QShaderDescription::PushConstantBlock block;
block.name = spvc_compiler_get_name(glslGen, r.id);
if (block.name.isEmpty()) {
// The block was declared without an instance name. Match the
// fallback SPIRV-Cross generates, so that the name is still
// usable for looking up the members of the plain uniform
// struct in the GLSL output. (same as for uniform blocks)
block.name = QByteArrayLiteral("_") + QByteArray::number(r.id);
}
size_t size = 0;
spvc_compiler_get_declared_struct_size(glslGen, t, &size);
block.size = int(size);
unsigned count = spvc_type_get_num_member_types(t);
for (unsigned idx = 0; idx < count; ++idx) {
const QShaderDescription::BlockVariable v = blockVar(r.base_type_id, idx);
if (v.type != QShaderDescription::Unknown)
block.members.append(v);
}
dd->pushConstantBlocks.append(block);
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STORAGE_BUFFER,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const spvc_reflected_resource &r(resourceList[i]);
spvc_type t = spvc_compiler_get_type_handle(glslGen, r.base_type_id);
QShaderDescription::StorageBlock block;
block.blockName = r.name;
block.instanceName = spvc_compiler_get_name(glslGen, r.id);
size_t size = 0;
spvc_compiler_get_declared_struct_size(glslGen, t, &size);
block.knownSize = int(size);
if (spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationBinding))
block.binding = int(spvc_compiler_get_decoration(glslGen, r.id, SpvDecorationBinding));
if (spvc_compiler_has_decoration(glslGen, r.id, SpvDecorationDescriptorSet))
block.descriptorSet = int(spvc_compiler_get_decoration(glslGen, r.id, SpvDecorationDescriptorSet));
size_t offset0 = 0;
spvc_compiler_get_declared_struct_size_runtime_array(glslGen, t, 0, &offset0);
size_t offset1 = 0;
spvc_compiler_get_declared_struct_size_runtime_array(glslGen, t, 1, &offset1);
block.runtimeArrayStride = int(offset1 - offset0);
const SpvDecoration *decorations;
spvc_compiler_get_buffer_block_decorations(glslGen, r.id, &decorations, &size);
for (uint i = 0; i < size; ++i) {
switch (decorations[i]) {
case SpvDecorationCoherent:
block.qualifierFlags.setFlag(QShaderDescription::QualifierCoherent);
break;
case SpvDecorationVolatile:
block.qualifierFlags.setFlag(QShaderDescription::QualifierVolatile);
break;
case SpvDecorationRestrict:
block.qualifierFlags.setFlag(QShaderDescription::QualifierRestrict);
break;
case SpvDecorationNonWritable:
block.qualifierFlags.setFlag(QShaderDescription::QualifierReadOnly);
break;
case SpvDecorationNonReadable:
block.qualifierFlags.setFlag(QShaderDescription::QualifierWriteOnly);
break;
default:
break;
}
}
unsigned count = spvc_type_get_num_member_types(t);
for (unsigned idx = 0; idx < count; ++idx) {
const QShaderDescription::BlockVariable v = blockVar(r.base_type_id, idx);
if (v.type != QShaderDescription::Unknown)
block.members.append(v);
}
dd->storageBlocks.append(block);
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_SAMPLED_IMAGE,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const spvc_reflected_resource &r(resourceList[i]);
const QShaderDescription::InOutVariable v = inOutVar(r);
if (v.type != QShaderDescription::Unknown)
dd->combinedImageSamplers.append(v);
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_SEPARATE_IMAGE,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const spvc_reflected_resource &r(resourceList[i]);
const QShaderDescription::InOutVariable v = inOutVar(r);
if (v.type != QShaderDescription::Unknown)
dd->separateImages.append(v);
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const spvc_reflected_resource &r(resourceList[i]);
const QShaderDescription::InOutVariable v = inOutVar(r);
if (v.type != QShaderDescription::Unknown)
dd->separateSamplers.append(v);
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STORAGE_IMAGE,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
const spvc_reflected_resource &r(resourceList[i]);
const QShaderDescription::InOutVariable v = inOutVar(r);
if (v.type != QShaderDescription::Unknown)
dd->storageImages.append(v);
}
}
}
QSpirvShader::QSpirvShader()
: d(new QSpirvShaderPrivate)
{
}
QSpirvShader::~QSpirvShader()
{
delete d;
}
void QSpirvShader::setSpirvBinary(const QByteArray &spirv, QShader::Stage stage)
{
d->stage = stage;
d->ir = spirv;
d->createCompiler(SPVC_BACKEND_GLSL);
d->reflect();
}
QShaderDescription QSpirvShader::shaderDescription() const
{
return d->shaderDescription;
}
QByteArray QSpirvShader::spirvBinary() const
{
return d->ir;
}
QByteArray QSpirvShader::remappedSpirvBinary(RemapFlags flags, QString *errorMessage) const
{
QSpirvShaderRemapper remapper;
QByteArray result = remapper.remap(d->ir, flags);
if (errorMessage)
*errorMessage = remapper.errorMessage();
return result;
}
QByteArray QSpirvShader::translateToGLSL(int version,
GlslFlags flags,
QShader::Stage stage,
const MultiViewInfo &multiViewInfo,
QVector<SeparateToCombinedImageSamplerMapping> *separateToCombinedImageSamplerMappings) const
{
d->spirvCrossErrorMsg.clear();
d->createCompiler(SPVC_BACKEND_GLSL);
if (!d->glslGen)
return QByteArray();
spvc_compiler_options options = nullptr;
if (spvc_compiler_create_compiler_options(d->glslGen, &options) != SPVC_SUCCESS)
return QByteArray();
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_VERSION,
version);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES,
flags.testFlag(GlslFlag::GlslEs));
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_FIXUP_DEPTH_CONVENTION,
flags.testFlag(GlslFlag::FixClipSpace));
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_FLOAT_PRECISION_HIGHP,
!flags.testFlag(GlslFlag::EsFragDefaultFloatPrecisionMedium));
// The gl backend of QRhi is not prepared for UBOs atm. Have a uniform (heh)
// behavior regardless of the GLSL version.
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_EMIT_UNIFORM_BUFFER_AS_PLAIN_UNIFORMS,
true);
// Do not emit binding qualifiers for samplers (and for uniform blocks, but
// those we just disabled above).
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ENABLE_420PACK_EXTENSION,
false);
if (stage == QShader::VertexStage && multiViewInfo.viewCount > 1) {
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_OVR_MULTIVIEW_VIEW_COUNT,
uint(multiViewInfo.viewCount));
}
spvc_compiler_install_compiler_options(d->glslGen, options);
// Let's say the shader has these separate imagers and samplers:
// layout(binding = 2) uniform texture2D sepTex;
// layout(binding = 3) uniform sampler sepSampler;
// layout(binding = 4) uniform sampler sepSampler2;
// where sepTex is used with both samplers in the shader.
// For OpenGL this is mapped to "combined image samplers", i.e. the
// traditional sampler2Ds with arbitrary names:
// uniform sampler2D _39;
// uniform sampler2D _41;
// This mapping (2+3 -> "_39", 2+4 -> "_41") needs to be exposed to the caller.
if (spvc_compiler_build_combined_image_samplers(d->glslGen) != SPVC_SUCCESS) {
d->spirvCrossErrorMsg = QString::fromUtf8(spvc_context_get_last_error_string(d->ctx));
return QByteArray();
}
if (separateToCombinedImageSamplerMappings) {
const spvc_combined_image_sampler *combinedImageSamplerMappings = nullptr;
size_t numCombinedImageSamplerMappings = 0;
if (spvc_compiler_get_combined_image_samplers(d->glslGen,
&combinedImageSamplerMappings,
&numCombinedImageSamplerMappings) == SPVC_SUCCESS)
{
for (size_t i = 0; i < numCombinedImageSamplerMappings; ++i) {
const spvc_combined_image_sampler *mapping = &combinedImageSamplerMappings[i];
QByteArray combinedName = spvc_compiler_get_name(d->glslGen, mapping->combined_id);
if (combinedName.isEmpty())
combinedName = QByteArrayLiteral("_") + QByteArray::number(mapping->combined_id);
QByteArray textureName = spvc_compiler_get_name(d->glslGen, mapping->image_id);
QByteArray samplerName = spvc_compiler_get_name(d->glslGen, mapping->sampler_id);
separateToCombinedImageSamplerMappings->append({ textureName, samplerName, combinedName });
}
}
}
const char *result = nullptr;
if (spvc_compiler_compile(d->glslGen, &result) != SPVC_SUCCESS) {
d->spirvCrossErrorMsg = QString::fromUtf8(spvc_context_get_last_error_string(d->ctx));
return QByteArray();
}
// We used to fix up the result to complement GL_ARB_shading_language_420pack
// with GL_ARB_separate_shader_objects to make Mesa happy, but the 420pack
// is never relied on now so no need to do anything here.
return result;
}
QByteArray QSpirvShader::translateToHLSL(int version, QShader::NativeResourceBindingMap *nativeBindings,
QShader::NativeShaderInfo *shaderInfo) const
{
d->spirvCrossErrorMsg.clear();
d->createCompiler(SPVC_BACKEND_HLSL);
if (!d->hlslGen)
return QByteArray();
spvc_compiler_options options = nullptr;
if (spvc_compiler_create_compiler_options(d->hlslGen, &options) != SPVC_SUCCESS)
return QByteArray();
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL,
version);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_HLSL_POINT_SIZE_COMPAT,
true);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_HLSL_POINT_COORD_COMPAT,
true);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_HLSL_FORCE_STORAGE_BUFFER_AS_UAV,
true);
spvc_compiler_install_compiler_options(d->hlslGen, options);
// D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT is 16, so we cannot have combined
// image/sampler bindings above 15. Problem is, the (SPIR-V) binding
// namespace is common with uniform buffers and other resources, and so
// having many uniform buffers and samplers can push the sampler binding to
// above 15 even when there are less than 16 samplers in total. So cannot
// just rely on SPIRV-Cross setting registers t<binding> and s<binding> for
// the SRV and sampler for each combined image/sampler. Instead, we want
// t<slot> and s<slot> where slot is 0-based, with its own namespace, and
// is then exposed in the native resource binding map so QRhi can map
// between (SPIR-V) bindings and D3D sampler slots.
const SpvExecutionModel stage = spvc_compiler_get_execution_model(d->hlslGen);
int regBinding = 0; // SRVs and samplers
const auto combinedImageSamplers = d->shaderDescription.combinedImageSamplers();
for (const QShaderDescription::InOutVariable &var : combinedImageSamplers) {
spvc_hlsl_resource_binding bindingMapping = {};
bindingMapping.stage = stage; // will be per-stage but we have a per-shader NativeResourceBindingMap so it's ok
bindingMapping.desc_set = var.descriptorSet;
bindingMapping.binding = var.binding;
bindingMapping.srv.register_space = 0;
bindingMapping.srv.register_binding = regBinding; // t0, t1, ...
bindingMapping.sampler.register_space = 0;
bindingMapping.sampler.register_binding = regBinding; // s0, s1, ...
spvc_compiler_hlsl_add_resource_binding(d->hlslGen, &bindingMapping);
nativeBindings->insert(var.binding, { regBinding, regBinding });
regBinding += var.arrayDims.isEmpty() ? 1 : var.arrayDims.first();
}
// In fact, with separate images and samplers added to the mix, the manual
// mapping specification is essential so that the HLSL nicely uses t0, t1,
// t2, ... and s0, s1, s2, ... for all the images and samplers incl. both
// combined and separate.
int firstSeparateImageReg = regBinding;
const auto separateImages = d->shaderDescription.separateImages();
for (const QShaderDescription::InOutVariable &var : separateImages) {
spvc_hlsl_resource_binding bindingMapping = {};
bindingMapping.stage = stage;
bindingMapping.desc_set = var.descriptorSet;
bindingMapping.binding = var.binding;
bindingMapping.srv.register_space = 0;
bindingMapping.srv.register_binding = regBinding; // tN, tN+1, ..., where N is the next reg after the combined image sampler ones
spvc_compiler_hlsl_add_resource_binding(d->hlslGen, &bindingMapping);
nativeBindings->insert(var.binding, { regBinding, -1 });
regBinding += var.arrayDims.isEmpty() ? 1 : var.arrayDims.first();
}
regBinding = firstSeparateImageReg;
const auto separateSamplers = d->shaderDescription.separateSamplers();
for (const QShaderDescription::InOutVariable &var : separateSamplers) {
spvc_hlsl_resource_binding bindingMapping = {};
bindingMapping.stage = stage;
bindingMapping.desc_set = var.descriptorSet;
bindingMapping.binding = var.binding;
bindingMapping.sampler.register_space = 0;
bindingMapping.sampler.register_binding = regBinding; // sN, sN+1, ..., where N is the next reg after the combined image sampler ones
spvc_compiler_hlsl_add_resource_binding(d->hlslGen, &bindingMapping);
nativeBindings->insert(var.binding, { regBinding, -1 });
regBinding += var.arrayDims.isEmpty() ? 1 : var.arrayDims.first();
}
regBinding = 0; // CBVs
// b0 is reserved for a push constant block, so that every stage agrees on
// the register regardless of how many uniform blocks it has.
const auto pushConstantBlocks = d->shaderDescription.pushConstantBlocks();
if (!pushConstantBlocks.isEmpty()) {
spvc_hlsl_resource_binding bindingMapping = {};
bindingMapping.stage = stage;
bindingMapping.desc_set = SPVC_HLSL_PUSH_CONSTANT_DESC_SET;
bindingMapping.binding = SPVC_HLSL_PUSH_CONSTANT_BINDING;
bindingMapping.cbv.register_space = 0;
bindingMapping.cbv.register_binding = regBinding;
spvc_compiler_hlsl_add_resource_binding(d->hlslGen, &bindingMapping);
shaderInfo->extraBufferBindings[QShaderPrivate::HlslPushConstantBufferBinding] = regBinding;
regBinding += 1;
}
const auto uniformBlocks = d->shaderDescription.uniformBlocks();
for (const QShaderDescription::UniformBlock &blk : uniformBlocks) {
spvc_hlsl_resource_binding bindingMapping = {};
bindingMapping.stage = stage;
bindingMapping.desc_set = blk.descriptorSet;
bindingMapping.binding = blk.binding;
bindingMapping.cbv.register_space = 0;
bindingMapping.cbv.register_binding = regBinding; // b0, b1, ...
spvc_compiler_hlsl_add_resource_binding(d->hlslGen, &bindingMapping);
nativeBindings->insert(blk.binding, { regBinding, -1 });
regBinding += 1;
}
// UAV registers live in the same name space as outputs, so they must be bound
// to at least outputVariables.size().
regBinding = d->shaderDescription.outputVariables().size();
const auto storageBlocks = d->shaderDescription.storageBlocks();
for (const QShaderDescription::StorageBlock &blk : storageBlocks) {
// readonly is also mapped to UAV due to FORCE_STORAGE_BUFFER_AS_UAV. (would be an SRV by default)
spvc_hlsl_resource_binding bindingMapping = {};
bindingMapping.stage = stage;
bindingMapping.desc_set = blk.descriptorSet;
bindingMapping.binding = blk.binding;
bindingMapping.uav.register_space = 0;
bindingMapping.uav.register_binding = regBinding; // u0, u1, ...
spvc_compiler_hlsl_add_resource_binding(d->hlslGen, &bindingMapping);
nativeBindings->insert(blk.binding, { regBinding, -1 });
regBinding += 1;
}
const auto storageImages = d->shaderDescription.storageImages();
for (const QShaderDescription::InOutVariable &var : storageImages) {
spvc_hlsl_resource_binding bindingMapping = {};
bindingMapping.stage = stage;
bindingMapping.desc_set = var.descriptorSet;
bindingMapping.binding = var.binding;
bindingMapping.uav.register_space = 0;
bindingMapping.uav.register_binding = regBinding; // u0, u1, ...
spvc_compiler_hlsl_add_resource_binding(d->hlslGen, &bindingMapping);
nativeBindings->insert(var.binding, { regBinding, -1 });
regBinding += 1;
}
const char *result = nullptr;
if (spvc_compiler_compile(d->hlslGen, &result) != SPVC_SUCCESS) {
d->spirvCrossErrorMsg = QString::fromUtf8(spvc_context_get_last_error_string(d->ctx));
return QByteArray();
}
return QByteArray(result);
}
QByteArray QSpirvShader::translateToMSL(int version,
MslFlags flags,
QShader::Stage stage,
QShader::NativeResourceBindingMap *nativeBindings,
QShader::NativeShaderInfo *shaderInfo,
const MultiViewInfo &multiViewInfo,
const TessellationInfo &tessInfo) const
{
d->spirvCrossErrorMsg.clear();
d->createCompiler(SPVC_BACKEND_MSL);
if (!d->mslGen)
return QByteArray();
spvc_compiler_options options = nullptr;
if (spvc_compiler_create_compiler_options(d->mslGen, &options) != SPVC_SUCCESS)
return QByteArray();
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_VERSION,
SPVC_MAKE_MSL_VERSION(version / 10, version % 10, 0));
if (flags.testFlag(MslFlag::VertexAsCompute)) {
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_MSL_VERTEX_FOR_TESSELLATION, 1);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_MSL_CAPTURE_OUTPUT_TO_BUFFER, 1);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_MSL_DISABLE_RASTERIZATION, 1);
spvc_msl_index_type indexType = SPVC_MSL_INDEX_TYPE_NONE;
if (flags.testFlag(MslFlag::WithUInt16Index))
indexType = SPVC_MSL_INDEX_TYPE_UINT16;
else if (flags.testFlag(MslFlag::WithUInt32Index))
indexType = SPVC_MSL_INDEX_TYPE_UINT32;
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_VERTEX_INDEX_TYPE, indexType);
}
// for tessellation; matches the defaults; not sure how to query so just set them
uint spvIndicesBufferIndex = 21;
uint spvInBufferIndex = 22;
uint spvTessLevelBufferIndex = 26;
uint spvPatchOutBufferIndex = 27;
uint spvOutBufferIndex = 28;
uint spvIndirectParamsBufferIndex = 29;
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_SHADER_INDEX_BUFFER_INDEX, spvIndicesBufferIndex);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_BUFFER_INDEX, spvInBufferIndex);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_SHADER_TESS_FACTOR_OUTPUT_BUFFER_INDEX, spvTessLevelBufferIndex);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_SHADER_PATCH_OUTPUT_BUFFER_INDEX, spvPatchOutBufferIndex);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_SHADER_OUTPUT_BUFFER_INDEX, spvOutBufferIndex);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_INDIRECT_PARAMS_BUFFER_INDEX, spvIndirectParamsBufferIndex);
// for buffer size buffer; matches defaults
uint spvBufferSizeBufferIndex = 25;
// for push constants; an automatically assigned index would land among the
// low ones, which is where the Metal backend packs the vertex buffers
uint spvPushConstantBufferIndex = 23;
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_BUFFER_SIZE_BUFFER_INDEX, spvBufferSizeBufferIndex);
if (stage == QShader::TessellationControlStage) {
// required to get the kind of tess.control inputs we need
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_MSL_MULTI_PATCH_WORKGROUP, 1);
// the execution mode needs to be known (e.g. to switch between
// MTLTriangleTessellationFactorsHalf and MTLQuadTessellationFactorsHalf)
SpvExecutionMode execMode = SpvExecutionModeTriangles;
switch (tessInfo.infoForTesc.mode) {
case QShaderDescription::QuadTessellationMode:
execMode = SpvExecutionModeQuads;
break;
case QShaderDescription::IsolineTessellationMode:
d->spirvCrossErrorMsg = QLatin1String("Isoline tessellation mode is not supported with Metal");
return QByteArray();
default:
break;
}
spvc_compiler_set_execution_mode(d->mslGen, execMode);
}
if (stage == QShader::TessellationEvaluationStage)
spvc_compiler_set_execution_mode_with_arguments(d->mslGen, SpvExecutionModeOutputVertices, uint(tessInfo.infoForTese.vertexCount), 0, 0);
uint spvViewMaskBufferIndex = 24;
const bool isMultiView = stage == QShader::VertexStage && multiViewInfo.viewCount > 1;
if (isMultiView) {
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_MSL_MULTIVIEW, 1);
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_MSL_MULTIVIEW_LAYERED_RENDERING, 1);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_VIEW_MASK_BUFFER_INDEX, spvViewMaskBufferIndex);
}
// Move images and samplers into a set of their own, make that set the
// argument buffer, and keep everything else bound individually. Pinning the
// argument buffer to index 0 matters: SPIRV-Cross starts the automatic
// buffer bindings at the argument buffer's index + 1.
const uint spvArgumentBufferSet = 1;
const uint spvArgumentBufferIndex = 0;
bool hasArgumentBuffer = false;
if (flags.testFlag(MslFlag::ArgumentBuffers)) {
spvc_resources resources;
if (spvc_compiler_create_shader_resources(d->mslGen, &resources) == SPVC_SUCCESS) {
for (spvc_resource_type type : { SPVC_RESOURCE_TYPE_SAMPLED_IMAGE,
SPVC_RESOURCE_TYPE_SEPARATE_IMAGE,
SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS,
SPVC_RESOURCE_TYPE_STORAGE_IMAGE })
{
const spvc_reflected_resource *resourceList = nullptr;
size_t resourceListCount = 0;
if (spvc_resources_get_resource_list_for_type(resources, type,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
spvc_compiler_set_decoration(d->mslGen, resourceList[i].id,
SpvDecorationDescriptorSet, spvArgumentBufferSet);
hasArgumentBuffer = true;
}
}
}
}
}
if (hasArgumentBuffer) {
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS, 1);
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS_TIER, 1); // Tier2
for (uint set = 0; set < 8; ++set) {
if (set != spvArgumentBufferSet)
spvc_compiler_msl_add_discrete_descriptor_set(d->mslGen, set);
}
spvc_msl_resource_binding argBufBinding;
spvc_msl_resource_binding_init(&argBufBinding);
argBufBinding.stage = spvc_compiler_get_execution_model(d->mslGen);
argBufBinding.desc_set = spvArgumentBufferSet;
argBufBinding.binding = SPVC_MSL_ARGUMENT_BUFFER_BINDING;
argBufBinding.msl_buffer = spvArgumentBufferIndex;
spvc_compiler_msl_add_resource_binding(d->mslGen, &argBufBinding);
}
const bool hasPushConstants = !d->shaderDescription.pushConstantBlocks().isEmpty();
if (hasPushConstants) {
spvc_msl_resource_binding pushConstantBinding;
spvc_msl_resource_binding_init(&pushConstantBinding);
pushConstantBinding.stage = spvc_compiler_get_execution_model(d->mslGen);
pushConstantBinding.desc_set = SPVC_MSL_PUSH_CONSTANT_DESC_SET;
pushConstantBinding.binding = SPVC_MSL_PUSH_CONSTANT_BINDING;
pushConstantBinding.msl_buffer = spvPushConstantBufferIndex;
spvc_compiler_msl_add_resource_binding(d->mslGen, &pushConstantBinding);
}
// leave platform set to macOS, it won't matter in practice (hopefully)
spvc_compiler_install_compiler_options(d->mslGen, options);
const char *result = nullptr;
if (spvc_compiler_compile(d->mslGen, &result) != SPVC_SUCCESS) {
d->spirvCrossErrorMsg = QString::fromUtf8(spvc_context_get_last_error_string(d->ctx));
return QByteArray();
}
if (nativeBindings) {
spvc_resources resources;
if (spvc_compiler_create_shader_resources(d->mslGen, &resources) == SPVC_SUCCESS) {
const spvc_reflected_resource *resourceList = nullptr;
size_t resourceListCount = 0;
// A nativeBinding of -1 means unused. This also fits
// *_get_automatic_resource_binding() which returns uint32_t(-1)
// when there is no binding, which can happen when the uniform
// block, sampler, etc. is not actively used in the shader. The map
// must always be complete, including a (binding -> -1) mapping for
// inactive resources as well. The second value of the pair is only
// relevant for combined image samplers, and is -1 otherwise.
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_UNIFORM_BUFFER,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
unsigned binding = spvc_compiler_get_decoration(d->mslGen, resourceList[i].id, SpvDecorationBinding);
unsigned nativeBinding = spvc_compiler_msl_get_automatic_resource_binding(d->mslGen, resourceList[i].id);
nativeBindings->insert(int(binding), { int(nativeBinding), -1 });
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STORAGE_BUFFER,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
unsigned binding = spvc_compiler_get_decoration(d->mslGen, resourceList[i].id, SpvDecorationBinding);
unsigned nativeBinding = spvc_compiler_msl_get_automatic_resource_binding(d->mslGen, resourceList[i].id);
nativeBindings->insert(int(binding), { int(nativeBinding), -1 });
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_SAMPLED_IMAGE,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
unsigned binding = spvc_compiler_get_decoration(d->mslGen, resourceList[i].id, SpvDecorationBinding);
unsigned nativeTextureBinding = spvc_compiler_msl_get_automatic_resource_binding(d->mslGen, resourceList[i].id);
unsigned nativeSamplerBinding = spvc_compiler_msl_get_automatic_resource_binding_secondary(d->mslGen, resourceList[i].id);
nativeBindings->insert(int(binding), { int(nativeTextureBinding), int(nativeSamplerBinding) });
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_SEPARATE_IMAGE,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
unsigned binding = spvc_compiler_get_decoration(d->mslGen, resourceList[i].id, SpvDecorationBinding);
unsigned nativeTextureBinding = spvc_compiler_msl_get_automatic_resource_binding(d->mslGen, resourceList[i].id);
nativeBindings->insert(int(binding), { int(nativeTextureBinding), -1 });
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
unsigned binding = spvc_compiler_get_decoration(d->mslGen, resourceList[i].id, SpvDecorationBinding);
unsigned nativeSamplerBinding = spvc_compiler_msl_get_automatic_resource_binding(d->mslGen, resourceList[i].id);
nativeBindings->insert(int(binding), { int(nativeSamplerBinding), -1 });
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_SAMPLED_IMAGE,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
unsigned binding = spvc_compiler_get_decoration(d->mslGen, resourceList[i].id, SpvDecorationBinding);
unsigned nativeTextureBinding = spvc_compiler_msl_get_automatic_resource_binding(d->mslGen, resourceList[i].id);
unsigned nativeSamplerBinding = spvc_compiler_msl_get_automatic_resource_binding_secondary(d->mslGen, resourceList[i].id);
nativeBindings->insert(int(binding), { int(nativeTextureBinding), int(nativeSamplerBinding) });
}
}
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STORAGE_IMAGE,
&resourceList, &resourceListCount) == SPVC_SUCCESS)
{
for (size_t i = 0; i < resourceListCount; ++i) {
unsigned binding = spvc_compiler_get_decoration(d->mslGen, resourceList[i].id, SpvDecorationBinding);
unsigned nativeBinding = spvc_compiler_msl_get_automatic_resource_binding(d->mslGen, resourceList[i].id);
nativeBindings->insert(int(binding), { int(nativeBinding), -1 });
}
}
}
}
if (spvc_compiler_msl_needs_swizzle_buffer(d->mslGen))
qWarning("Translated Metal shader needs swizzle buffer, this is unexpected");
if (spvc_compiler_msl_needs_buffer_size_buffer(d->mslGen))
shaderInfo->extraBufferBindings[QShaderPrivate::MslBufferSizeBufferBinding] = spvBufferSizeBufferIndex;
if (isMultiView)
shaderInfo->extraBufferBindings[QShaderPrivate::MslMultiViewMaskBufferBinding] = spvViewMaskBufferIndex;
if (hasArgumentBuffer)
shaderInfo->extraBufferBindings[QShaderPrivate::MslArgumentBufferBinding] = spvArgumentBufferIndex;
// SPIRV-Cross drops the block from the entry point when nothing reads it,
// in which case there is no buffer to report.
if (hasPushConstants
&& spvc_compiler_msl_is_resource_used(d->mslGen, spvc_compiler_get_execution_model(d->mslGen),
SPVC_MSL_PUSH_CONSTANT_DESC_SET, SPVC_MSL_PUSH_CONSTANT_BINDING))
{
shaderInfo->extraBufferBindings[QShaderPrivate::MslPushConstantBufferBinding] = spvPushConstantBufferIndex;
}
// (Aim to) only store extraBufferBindings entries for things that really
// are present, because the presence of a key can already trigger certain
// behavior during rendering. (e.g. generating and exposing the
// corresponding implicit buffer)
switch (spvc_compiler_get_execution_model(d->mslGen)) {
case SpvExecutionModelVertex:
if (flags.testFlag(MslFlag::VertexAsCompute)) {
if (spvc_compiler_msl_needs_output_buffer(d->mslGen))
shaderInfo->extraBufferBindings[QShaderPrivate::MslTessVertTescOutputBufferBinding] = spvOutBufferIndex;
if (flags.testFlag(MslFlag::WithUInt16Index) || flags.testFlag(MslFlag::WithUInt32Index)) {
// not given that this buffer is really used in the code,
// depends on e.g. the usage of gl_VertexIndex, but not sure how
// to tell that here
shaderInfo->extraBufferBindings[QShaderPrivate::MslTessVertIndicesBufferBinding] = spvIndicesBufferIndex;
}
}
break;
case SpvExecutionModelTessellationControl:
shaderInfo->extraBufferBindings[QShaderPrivate::MslTessTescInputBufferBinding] = spvInBufferIndex;
shaderInfo->extraBufferBindings[QShaderPrivate::MslTessTescTessLevelBufferBinding] = spvTessLevelBufferIndex;
shaderInfo->extraBufferBindings[QShaderPrivate::MslTessTescParamsBufferBinding] = spvIndirectParamsBufferIndex;
if (spvc_compiler_msl_needs_output_buffer(d->mslGen))
shaderInfo->extraBufferBindings[QShaderPrivate::MslTessVertTescOutputBufferBinding] = spvOutBufferIndex;
if (spvc_compiler_msl_needs_patch_output_buffer(d->mslGen))
shaderInfo->extraBufferBindings[QShaderPrivate::MslTessTescPatchOutputBufferBinding] = spvPatchOutBufferIndex;
break;
default:
break;
}
return QByteArray(result);
}
QString QSpirvShader::translationErrorMessage() const
{
return d->spirvCrossErrorMsg;
}
QT_END_NAMESPACE