Files
MobileGL/MobileGL/MG_Util/ShaderTranspiler/SpvcSession.cpp
T

1022 lines
58 KiB
C++

// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpvcSession.cpp
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#include "SpvcSession.h"
#include <algorithm>
namespace MobileGL {
namespace MG_Util {
namespace ShaderTranspiler {
static spvc_basetype MapReflectToSpvcBasetype(const SpvReflectBlockVariable& member) {
if (!member.type_description) return SPVC_BASETYPE_UNKNOWN;
auto flags = member.type_description->type_flags;
auto width = member.numeric.scalar.width;
auto signedness = member.numeric.scalar.signedness;
if (flags & SPV_REFLECT_TYPE_FLAG_FLOAT) {
switch (width) {
case 16: return SPVC_BASETYPE_FP16;
case 32: return SPVC_BASETYPE_FP32;
case 64: return SPVC_BASETYPE_FP64;
default: return SPVC_BASETYPE_UNKNOWN;
}
} else if (flags & SPV_REFLECT_TYPE_FLAG_INT) {
if (signedness) {
switch (width) {
case 8: return SPVC_BASETYPE_INT8;
case 16: return SPVC_BASETYPE_INT16;
case 32: return SPVC_BASETYPE_INT32;
case 64: return SPVC_BASETYPE_INT64;
default: return SPVC_BASETYPE_UNKNOWN;
}
} else {
switch (width) {
case 8: return SPVC_BASETYPE_UINT8;
case 16: return SPVC_BASETYPE_UINT16;
case 32: return SPVC_BASETYPE_UINT32;
case 64: return SPVC_BASETYPE_UINT64;
default: return SPVC_BASETYPE_UNKNOWN;
}
}
} else if (flags & SPV_REFLECT_TYPE_FLAG_BOOL) {
return SPVC_BASETYPE_BOOLEAN;
}
return SPVC_BASETYPE_UNKNOWN;
}
// Write one metadata entry. `name` is already the glslang-reflection spelling the
// GL uniform locations are keyed on, and `arrayStride`/`sizeInBytes` describe the
// entry rather than the whole declaration (they differ for a sub-array of an
// array-of-arrays - see RecordGlobalUboLeaf).
static void RecordGlobalUboLeafEntry(const SpvReflectBlockVariable& member, const String& name,
Uint32 offsetInUBO, Uint32 arrayStride, SizeT sizeInBytes,
SpvcMetadata& metadata) {
metadata.plainUniformOffsetsInUBO[name] = offsetInUBO;
metadata.plainUniformMemberSizesInBytes[name] = sizeInBytes;
metadata.plainUniformArrayStridesInUBO[name] = arrayStride;
Uint32 vectorSize = member.numeric.vector.component_count;
if (vectorSize == 0) vectorSize = 1;
Uint32 matCol = member.numeric.matrix.column_count;
if (matCol == 0) matCol = 1;
metadata.plainUniformMemberTypes[name] = {
.basetype = MapReflectToSpvcBasetype(member),
.vectorSize = vectorSize,
.matCol = matCol,
};
}
// Record one flattened leaf uniform of the global UBO into the metadata maps.
//
// SPIRV-Reflect keeps `float u[2][3]` as ONE leaf carrying every dimension in
// array.dims[] and the INNERMOST element stride in array.stride (the outer
// ArrayStride decoration is overwritten as ParseType recurses into the element
// type, which is also why array.size == product(dims) * stride). glslang's
// reflection - which owns the names GL uniform locations are keyed on - stops at
// "reflection granularity" instead (reflection.cpp: !type.isArrayOfArrays()), so
// the same declaration arrives on the GL side as "u[0]" and "u[1]", each a
// `float[3]` holding its own three locations.
//
// Emitting a single "u" leaf here therefore only ever routes the FIRST sub-array:
// the routing loop stops as soon as a location belongs to a different uniform, and
// every element from "u[1][0]" on finds no offset and falls through to the fallback
// scratch storage at the tail of the shadow - bytes the GPU never reads, so those
// glUniform writes are silently lost
// (KHR-GLES31.explicit_uniform_location.uniform-loc-arrays-of-arrays). Expand every
// dimension but the last, exactly as glslang does, and give each sub-array its own
// byte offset.
static void RecordGlobalUboLeaf(const SpvReflectBlockVariable& member, const String& name,
Uint32 offsetInUBO, SpvcMetadata& metadata) {
const Uint32 arrayStride = member.array.dims_count > 0 ? member.array.stride : 0;
const Bool isArrayOfArrays = member.array.dims_count > 1 && arrayStride > 0;
if (!isArrayOfArrays) {
RecordGlobalUboLeafEntry(member, name, offsetInUBO, arrayStride, member.size, metadata);
return;
}
// Extent 0 is SPIRV-Reflect's OpTypeRuntimeArray marker, which a plain uniform
// cannot be - but it must not be expanded (or divided by) if it ever appears.
Uint32 subArrayCount = 1;
for (Uint32 dim = 0; dim + 1 < member.array.dims_count; ++dim) {
const Uint32 extent = member.array.dims[dim];
if (extent == 0) {
MGLOG_W_ONCE("RecordGlobalUboLeaf: multi-dimensional uniform '%s' has a non-constant "
"dimension, recording the base entry only",
name.c_str());
RecordGlobalUboLeafEntry(member, name, offsetInUBO, arrayStride, member.size, metadata);
return;
}
subArrayCount *= extent;
}
const Uint32 innerExtent = member.array.dims[member.array.dims_count - 1] > 0
? member.array.dims[member.array.dims_count - 1]
: 1;
const Uint32 subArrayStride = innerExtent * arrayStride;
// Row-major odometer over dims[0 .. dims_count-2]: the last dimension varies
// fastest, so `subArray` counts sub-arrays in exactly memory order.
Vector<Uint32> indices(member.array.dims_count - 1, 0);
for (Uint32 subArray = 0; subArray < subArrayCount; ++subArray) {
String elementName = name;
for (const Uint32 index : indices) {
elementName += "[" + std::to_string(index) + "]";
}
RecordGlobalUboLeafEntry(member, elementName, offsetInUBO + subArray * subArrayStride,
arrayStride, subArrayStride, metadata);
for (SizeT dim = indices.size(); dim-- > 0;) {
if (++indices[dim] < member.array.dims[dim]) break;
indices[dim] = 0;
}
}
}
// Flatten a (possibly nested struct / struct array) member of the global UBO
// into leaf entries named the way glslang reflection names plain uniforms:
// "s[0].b[1].b" for `uniform S s[2]` with `struct T { vec2 b[2]; }` members.
// glUniform* writes are routed per leaf location, so the state layer needs a
// byte offset for every leaf, not just for the top-level block members.
// `baseOffset` accumulates parent offsets; member.offset is relative to the
// enclosing struct (top-level members: relative to the block start).
static void FlattenGlobalUboMember(const SpvReflectBlockVariable& member, const String& prefix,
Uint32 baseOffset, SpvcMetadata& metadata) {
const String name = prefix + (member.name != nullptr ? member.name : "");
const Uint32 selfOffset = baseOffset + member.offset;
if (member.member_count == 0 || member.members == nullptr) {
RecordGlobalUboLeaf(member, name, selfOffset, metadata);
return;
}
if (member.array.dims_count == 0) {
// Plain nested struct.
for (Uint32 j = 0; j < member.member_count; ++j) {
FlattenGlobalUboMember(member.members[j], name + ".", selfOffset, metadata);
}
return;
}
if (member.array.dims_count > 1) {
// Arrays of arrays of structs cannot be declared in the GL 3.3-era GLSL
// MobileGL ingests; record the base so at least element 0 resolves.
MGLOG_W_ONCE("FlattenGlobalUboMember: multi-dimensional struct array '%s' is not supported, "
"flattening element 0 only",
name.c_str());
}
const Uint32 elementCount = member.array.dims[0] > 0 ? member.array.dims[0] : 1;
const Uint32 elementStride = member.array.stride;
for (Uint32 element = 0; element < elementCount; ++element) {
const String elementPrefix = name + "[" + std::to_string(element) + "].";
const Uint32 elementOffset = selfOffset + element * elementStride;
for (Uint32 j = 0; j < member.member_count; ++j) {
FlattenGlobalUboMember(member.members[j], elementPrefix, elementOffset, metadata);
}
}
}
SpvcSession::SpvcSession(const Vector<unsigned int>& spirv, Flags<SessionUsageBit> usage)
: usage(usage) {
if (usage & SessionUsageBit::Transpile) {
const SpvId* p_spirv = spirv.data();
size_t word_count = spirv.size();
// Every step is checked, and each guards the next: the C API writes its
// out-param only on success, so passing a failed step's null handle to the
// step after it is a raw dereference (spvc_context_create_compiler does
// `parsed_ir->parsed`, spvc_compiler_create_shader_resources does
// `compiler->context`). IsTranspileReady() is how a caller asks whether this
// sequence got all the way through.
if (spvc_context_create(&context) != SPVC_SUCCESS) {
context = nullptr;
return;
}
if (spvc_context_parse_spirv(context, p_spirv, word_count, &ir) != SPVC_SUCCESS) {
ir = nullptr;
return;
}
if (spvc_context_create_compiler(context, SPVC_BACKEND_GLSL, ir,
SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler) != SPVC_SUCCESS) {
compiler = nullptr;
return;
}
if (spvc_compiler_create_shader_resources(compiler, &resources) != SPVC_SUCCESS) {
resources = nullptr;
return;
}
} else if (usage & SessionUsageBit::Reflection) {
SpvReflectResult result = spvReflectCreateShaderModule(
spirv.size() * sizeof(uint32_t), spirv.data(), &reflectModule);
reflectModuleValid = (result == SPV_REFLECT_RESULT_SUCCESS);
}
}
SpvcSession::SpvcSession(SpvcSession&& that) {
std::swap(this->usage, that.usage);
std::swap(this->context, that.context);
std::swap(this->compiler, that.compiler);
std::swap(this->ir, that.ir);
std::swap(this->compiler_options, that.compiler_options);
std::swap(this->resources, that.resources);
std::swap(this->reflectModule, that.reflectModule);
std::swap(this->reflectModuleValid, that.reflectModuleValid);
// ParseMetaData() fills `metadata`, and GetMetadata() is read through the
// moved-to session: leaving it behind silently returns an empty reflection.
std::swap(this->metadata, that.metadata);
}
SpvcSession& SpvcSession::operator=(SpvcSession&& that) {
std::swap(this->usage, that.usage);
std::swap(this->context, that.context);
std::swap(this->compiler, that.compiler);
std::swap(this->ir, that.ir);
std::swap(this->compiler_options, that.compiler_options);
std::swap(this->resources, that.resources);
std::swap(this->reflectModule, that.reflectModule);
std::swap(this->reflectModuleValid, that.reflectModuleValid);
std::swap(this->metadata, that.metadata);
return *this;
}
spvc_result SpvcSession::CreateOptions(spvc_compiler_options* options) {
if (!(usage & SessionUsageBit::Transpile)) return SPVC_ERROR_INVALID_ARGUMENT;
return spvc_compiler_create_compiler_options(compiler, options);
}
spvc_result SpvcSession::SetOptions(spvc_compiler_options options) {
if (!(usage & SessionUsageBit::Transpile)) return SPVC_ERROR_INVALID_ARGUMENT;
compiler_options = options;
return spvc_compiler_install_compiler_options(compiler, options);
}
Vector<InterfaceVariable> SpvcSession::GetShaderInterface(spvc_resource_type resource_type) const {
if (usage & SessionUsageBit::Transpile) {
// SPIRV-Cross path
const spvc_reflected_resource* list = nullptr;
size_t count = 0;
spvc_resources_get_resource_list_for_type(resources, resource_type, &list, &count);
Vector<InterfaceVariable> variables;
for (size_t i = 0; i < count; ++i) {
if (spvc_compiler_has_decoration(compiler, list[i].id, SpvDecorationBuiltIn)) {
continue;
}
InterfaceVariable var;
var.name = list[i].name;
var.location = spvc_compiler_get_decoration(compiler, list[i].id, SpvDecorationLocation);
variables.push_back(var);
}
std::sort(variables.begin(), variables.end());
return variables;
}
// SPIRV-Reflect path (Reflection only, no Transpile)
if (!reflectModuleValid) return {};
Vector<InterfaceVariable> variables;
switch (resource_type) {
case SPVC_RESOURCE_TYPE_STAGE_INPUT: {
uint32_t count = 0;
spvReflectEnumerateInputVariables(&reflectModule, &count, nullptr);
Vector<SpvReflectInterfaceVariable*> vars(count);
spvReflectEnumerateInputVariables(&reflectModule, &count, vars.data());
for (uint32_t i = 0; i < count; ++i) {
if (vars[i]->decoration_flags & SPV_REFLECT_DECORATION_BUILT_IN) continue;
InterfaceVariable var;
var.name = vars[i]->name;
var.location = vars[i]->location;
variables.push_back(var);
}
break;
}
case SPVC_RESOURCE_TYPE_STAGE_OUTPUT: {
uint32_t count = 0;
spvReflectEnumerateOutputVariables(&reflectModule, &count, nullptr);
Vector<SpvReflectInterfaceVariable*> vars(count);
spvReflectEnumerateOutputVariables(&reflectModule, &count, vars.data());
for (uint32_t i = 0; i < count; ++i) {
if (vars[i]->decoration_flags & SPV_REFLECT_DECORATION_BUILT_IN) continue;
InterfaceVariable var;
var.name = vars[i]->name;
var.location = vars[i]->location;
variables.push_back(var);
}
break;
}
case SPVC_RESOURCE_TYPE_SAMPLED_IMAGE: {
uint32_t count = 0;
spvReflectEnumerateDescriptorBindings(&reflectModule, &count, nullptr);
Vector<SpvReflectDescriptorBinding*> bindings(count);
spvReflectEnumerateDescriptorBindings(&reflectModule, &count, bindings.data());
for (uint32_t i = 0; i < count; ++i) {
if (bindings[i]->descriptor_type == SPV_REFLECT_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ||
bindings[i]->descriptor_type == SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE) {
InterfaceVariable var;
var.name = bindings[i]->name;
var.location = bindings[i]->binding;
variables.push_back(var);
}
}
break;
}
case SPVC_RESOURCE_TYPE_UNIFORM_BUFFER: {
uint32_t count = 0;
spvReflectEnumerateDescriptorBindings(&reflectModule, &count, nullptr);
Vector<SpvReflectDescriptorBinding*> bindings(count);
spvReflectEnumerateDescriptorBindings(&reflectModule, &count, bindings.data());
for (uint32_t i = 0; i < count; ++i) {
if (bindings[i]->descriptor_type == SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER) {
InterfaceVariable var;
// Use the block/type name (e.g. "MGL_GLOBAL_UBO") rather than
// the variable name, which may be empty or meaningless for UBOs.
// This is consistent with ParseMetaData() which uses type_description->type_name.
if (bindings[i]->type_description && bindings[i]->type_description->type_name) {
var.name = bindings[i]->type_description->type_name;
} else {
var.name = bindings[i]->name;
}
var.location = bindings[i]->binding;
variables.push_back(var);
}
}
break;
}
case SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM:
// GL plain uniforms are a SPIRV-Cross-specific concept.
// In reflection-only mode, not available.
break;
default:
break;
}
std::sort(variables.begin(), variables.end());
return variables;
}
spvc_result SpvcSession::SetVertexAttribLocation(const UnorderedMap<String, Uint>& location) {
if (!(usage & SessionUsageBit::Transpile)) return SPVC_ERROR_INVALID_ARGUMENT;
SPVC_CHK_INIT
const spvc_reflected_resource* list = nullptr;
size_t count = 0;
SPVC_CHK_RESULT(spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STAGE_INPUT,
&list, &count));
for (size_t i = 0; i < count; ++i) {
auto& resource = list[i];
auto it = location.find(resource.name);
if (it != location.end()) {
spvc_compiler_set_decoration(compiler, resource.id, SpvDecorationLocation, it->second);
}
}
SPVC_CHK_RETURN
}
spvc_result SpvcSession::SetShaderStorageBlockBinding(const UnorderedMap<String, Int>& bindings) {
if (!(usage & SessionUsageBit::Transpile)) return SPVC_ERROR_INVALID_ARGUMENT;
SPVC_CHK_INIT
const spvc_reflected_resource* list = nullptr;
size_t count = 0;
SPVC_CHK_RESULT(spvc_resources_get_resource_list_for_type(
resources, SPVC_RESOURCE_TYPE_STORAGE_BUFFER, &list, &count));
for (size_t i = 0; i < count; ++i) {
auto& resource = list[i];
// Two spellings, because neither one alone identifies the block the GL
// interface query named. `resource.name` is the block's instance name when
// the declaration has one; the block TYPE name (which is what the GL query
// reports for a block) lives on base_type_id. An arrayed block collapses to
// a single SPIR-V resource while GL enumerates it per element, so the bare
// name is also tried with element zero's subscript - the same convention
// ProgramObject::GetShaderStorageBlockBindingOverride documents.
const char* blockTypeName = spvc_compiler_get_name(compiler, resource.base_type_id);
const String candidates[] = {
blockTypeName != nullptr ? String(blockTypeName) : String(),
resource.name != nullptr ? String(resource.name) : String(),
};
for (const auto& candidate : candidates) {
if (candidate.empty()) continue;
auto it = bindings.find(candidate);
if (it == bindings.end()) it = bindings.find(candidate + "[0]");
if (it == bindings.end()) continue;
// Negative is "never rebound" - the declared qualifier still stands.
if (it->second < 0) break;
spvc_compiler_set_decoration(compiler, resource.id, SpvDecorationBinding,
static_cast<unsigned>(it->second));
break;
}
}
SPVC_CHK_RETURN
}
// "gl_AtomicCounterBlock_5" -> 5, -1 for anything that is not one of those blocks.
// The suffix is the GL atomic-counter binding the application declared, and after
// the relaxed lowering it is the only place that number still exists.
static Int AtomicCounterBlockBinding(const char* blockName) {
if (blockName == nullptr) return -1;
const SizeT prefixLength = std::strlen(ATOMIC_COUNTER_BLOCK_PREFIX);
const String name = blockName;
if (name.length() <= prefixLength + 1) return -1;
if (name.compare(0, prefixLength, ATOMIC_COUNTER_BLOCK_PREFIX) != 0) return -1;
if (name[prefixLength] != '_') return -1;
Int binding = 0;
for (SizeT i = prefixLength + 1; i < name.length(); ++i) {
if (name[i] < '0' || name[i] > '9') return -1;
binding = binding * 10 + (name[i] - '0');
if (binding > 0x0FFFFFFF) return -1;
}
return binding;
}
spvc_result SpvcSession::SetAtomicCounterBlockBindings(Int topBinding, Vector<Int>& outGlBindings) {
if (!(usage & SessionUsageBit::Transpile)) return SPVC_ERROR_INVALID_ARGUMENT;
SPVC_CHK_INIT
const spvc_reflected_resource* list = nullptr;
size_t count = 0;
SPVC_CHK_RESULT(spvc_resources_get_resource_list_for_type(
resources, SPVC_RESOURCE_TYPE_STORAGE_BUFFER, &list, &count));
for (size_t i = 0; i < count; ++i) {
auto& resource = list[i];
// The block TYPE name: glslang gives the synthesized block an EMPTY instance
// name, so resource.name carries nothing to match on. Read before Compile(),
// which is where SPIRV-Cross renames the reserved "gl_" prefix away.
const Int glBinding = AtomicCounterBlockBinding(
spvc_compiler_get_name(compiler, resource.base_type_id));
if (glBinding < 0) continue;
const Int esslBinding = topBinding - glBinding;
if (esslBinding < 0) {
MGLOG_E_ONCE("Atomic counter binding %d needs more shader storage binding points than this "
"driver has; its counters will not be updated.",
glBinding);
continue;
}
spvc_compiler_set_decoration(compiler, resource.id, SpvDecorationBinding,
static_cast<unsigned>(esslBinding));
outGlBindings.push_back(glBinding);
}
SPVC_CHK_RETURN
}
spvc_result SpvcSession::DropDefaultFragmentOutputColorIndex() {
if (!(usage & SessionUsageBit::Transpile)) return SPVC_ERROR_INVALID_ARGUMENT;
SPVC_CHK_INIT
const spvc_reflected_resource* list = nullptr;
size_t count = 0;
SPVC_CHK_RESULT(spvc_resources_get_resource_list_for_type(
resources, SPVC_RESOURCE_TYPE_STAGE_OUTPUT, &list, &count));
Bool dualSourceIndex = false;
for (size_t i = 0; i < count; ++i) {
const spvc_reflected_resource& resource = list[i];
if (!spvc_compiler_has_decoration(compiler, resource.id, SpvDecorationIndex)) continue;
if (spvc_compiler_get_decoration(compiler, resource.id, SpvDecorationIndex) != 0u) {
dualSourceIndex = true;
continue;
}
spvc_compiler_unset_decoration(compiler, resource.id, SpvDecorationIndex);
}
// The index that stays is printed as `layout(index = 1)`, which ESSL accepts only
// with the extension enabled in the shader itself: the driver having it is not
// enough, and without the directive the stage is refused exactly as above.
if (dualSourceIndex) {
SPVC_CHK_RESULT(spvc_compiler_require_extension(compiler, "GL_EXT_blend_func_extended"));
}
SPVC_CHK_RETURN
}
spvc_result SpvcSession::RelaxReadWriteExclusiveStorageBuffers() {
if (!(usage & SessionUsageBit::Transpile)) return SPVC_ERROR_INVALID_ARGUMENT;
SPVC_CHK_INIT
const spvc_reflected_resource* list = nullptr;
size_t count = 0;
SPVC_CHK_RESULT(spvc_resources_get_resource_list_for_type(
resources, SPVC_RESOURCE_TYPE_STORAGE_BUFFER, &list, &count));
for (size_t i = 0; i < count; ++i) {
const spvc_reflected_resource& resource = list[i];
// The variable itself, for a block the application qualified as a whole.
if (spvc_compiler_has_decoration(compiler, resource.id, SpvDecorationNonReadable) &&
spvc_compiler_has_decoration(compiler, resource.id, SpvDecorationNonWritable)) {
spvc_compiler_unset_decoration(compiler, resource.id, SpvDecorationNonReadable);
spvc_compiler_unset_decoration(compiler, resource.id, SpvDecorationNonWritable);
}
// ...and each member, which is where the qualifiers usually sit and where
// SPIRV-Cross reads them from before hoisting the ones every member shares.
const spvc_type blockType = spvc_compiler_get_type_handle(compiler, resource.base_type_id);
if (blockType == nullptr) continue;
const unsigned memberCount = spvc_type_get_num_member_types(blockType);
for (unsigned member = 0; member < memberCount; ++member) {
if (!spvc_compiler_has_member_decoration(compiler, resource.base_type_id, member,
SpvDecorationNonReadable) ||
!spvc_compiler_has_member_decoration(compiler, resource.base_type_id, member,
SpvDecorationNonWritable)) {
continue;
}
spvc_compiler_unset_member_decoration(compiler, resource.base_type_id, member,
SpvDecorationNonReadable);
spvc_compiler_unset_member_decoration(compiler, resource.base_type_id, member,
SpvDecorationNonWritable);
}
}
SPVC_CHK_RETURN
}
namespace {
// How many 32-bit components a captured variable occupies, which is what the
// gl_SkipComponentsN padding below is counted in. Matrices and arrays multiply.
Uint32 XfbComponentCount(spvc_compiler compiler, spvc_type_id typeId) {
const spvc_type type = spvc_compiler_get_type_handle(compiler, typeId);
if (type == nullptr) return 0;
Uint32 components = spvc_type_get_vector_size(type) * spvc_type_get_columns(type);
const unsigned dimensions = spvc_type_get_num_array_dimensions(type);
for (unsigned d = 0; d < dimensions; ++d) {
const unsigned length = spvc_type_get_array_dimension(type, d);
if (length != 0) components *= length;
}
// A double occupies two component slots per scalar (GL 4.6 core 11.1.2.1).
const spvc_basetype base = spvc_type_get_basetype(type);
if (base == SPVC_BASETYPE_FP64 || base == SPVC_BASETYPE_INT64 ||
base == SPVC_BASETYPE_UINT64) {
components *= 2;
}
return components;
}
} // namespace
namespace {
// The four gl_PerVertex members, by their GL interface names. These are the only
// built-ins GL lets transform feedback capture, and a SPIR-V module names them by
// BuiltIn decoration rather than by string - so the mapping has to live somewhere.
const char* XfbBuiltInName(SpvBuiltIn builtin) {
switch (builtin) {
case SpvBuiltInPosition:
return "gl_Position";
case SpvBuiltInPointSize:
return "gl_PointSize";
case SpvBuiltInClipDistance:
return "gl_ClipDistance";
case SpvBuiltInCullDistance:
return "gl_CullDistance";
default:
return nullptr;
}
}
} // namespace
Vector<SpirvXfbCapture> SpvcSession::ReflectTransformFeedbackCaptures() const {
Vector<SpirvXfbCapture> captures;
if (compiler == nullptr || resources == nullptr) return captures;
// XfbBuffer/XfbStride sit on the declaring VARIABLE; Offset sits on the variable
// for a plain output and on each MEMBER for a block.
auto readVariableDecorations = [this](SpvId id, Uint32& outBuffer, Uint32& outStride) {
outBuffer = spvc_compiler_has_decoration(compiler, id, SpvDecorationXfbBuffer) == SPVC_TRUE
? spvc_compiler_get_decoration(compiler, id, SpvDecorationXfbBuffer)
: 0u;
outStride = spvc_compiler_has_decoration(compiler, id, SpvDecorationXfbStride) == SPVC_TRUE
? spvc_compiler_get_decoration(compiler, id, SpvDecorationXfbStride)
: 0u;
};
// ---- application outputs: plain variables and application blocks ----
const spvc_reflected_resource* outputs = nullptr;
SizeT outputCount = 0;
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STAGE_OUTPUT, &outputs,
&outputCount) == SPVC_SUCCESS) {
for (SizeT i = 0; i < outputCount; ++i) {
const spvc_reflected_resource& output = outputs[i];
Uint32 buffer = 0;
Uint32 stride = 0;
readVariableDecorations(output.id, buffer, stride);
const spvc_type type = spvc_compiler_get_type_handle(compiler, output.base_type_id);
const unsigned memberCount =
type != nullptr && spvc_type_get_basetype(type) == SPVC_BASETYPE_STRUCT
? spvc_type_get_num_member_types(type)
: 0u;
if (memberCount == 0) {
if (spvc_compiler_has_decoration(compiler, output.id, SpvDecorationOffset) != SPVC_TRUE) {
continue;
}
SpirvXfbCapture capture;
capture.name = output.name ? output.name : "";
capture.buffer = buffer;
capture.stride = stride;
capture.offset = spvc_compiler_get_decoration(compiler, output.id, SpvDecorationOffset);
capture.componentCount = XfbComponentCount(compiler, output.type_id);
if (!capture.name.empty()) captures.push_back(Move(capture));
continue;
}
for (unsigned member = 0; member < memberCount; ++member) {
if (spvc_compiler_has_member_decoration(compiler, output.base_type_id, member,
SpvDecorationOffset) != SPVC_TRUE) {
continue;
}
const char* memberName =
spvc_compiler_get_member_name(compiler, output.base_type_id, member);
if (memberName == nullptr || *memberName == '\0') continue;
SpirvXfbCapture capture;
const String blockName = output.name ? String(output.name) : String{};
// GL's capture interface spells an application block's member
// "Block.member"; a redeclared built-in block contributes its members
// by their own names, which the built-in walk below handles.
capture.name = blockName.empty() ? String(memberName)
: blockName + "." + String(memberName);
capture.buffer = buffer;
capture.stride = stride;
capture.offset = spvc_compiler_get_member_decoration(compiler, output.base_type_id,
member, SpvDecorationOffset);
capture.componentCount =
XfbComponentCount(compiler, spvc_type_get_member_type(type, member));
captures.push_back(Move(capture));
}
}
}
// ---- the redeclared built-in block ----
// SPIRV-Cross keeps gl_PerVertex out of the STAGE_OUTPUT list and reports it here
// instead, one entry per built-in member. That is the shape the conformance suite
// feeds in first (`layout(xfb_buffer = 0, xfb_offset = 16) out gl_PerVertex { vec4
// gl_Position; }`), so walking only the list above would have found nothing at all.
const spvc_reflected_builtin_resource* builtins = nullptr;
SizeT builtinCount = 0;
if (spvc_resources_get_builtin_resource_list_for_type(
resources, SPVC_BUILTIN_RESOURCE_TYPE_STAGE_OUTPUT, &builtins, &builtinCount) ==
SPVC_SUCCESS) {
for (SizeT i = 0; i < builtinCount; ++i) {
const spvc_reflected_builtin_resource& entry = builtins[i];
const char* name = XfbBuiltInName(entry.builtin);
if (name == nullptr) continue;
Uint32 buffer = 0;
Uint32 stride = 0;
readVariableDecorations(entry.resource.id, buffer, stride);
const spvc_type blockType =
spvc_compiler_get_type_handle(compiler, entry.resource.base_type_id);
if (blockType == nullptr ||
spvc_type_get_basetype(blockType) != SPVC_BASETYPE_STRUCT) {
continue;
}
// The member index is not in the reflection entry, so it is recovered by
// matching the BuiltIn decoration - the same key the entry is keyed on.
const unsigned memberCount = spvc_type_get_num_member_types(blockType);
for (unsigned member = 0; member < memberCount; ++member) {
if (spvc_compiler_has_member_decoration(compiler, entry.resource.base_type_id, member,
SpvDecorationBuiltIn) != SPVC_TRUE) {
continue;
}
if (spvc_compiler_get_member_decoration(compiler, entry.resource.base_type_id, member,
SpvDecorationBuiltIn) !=
static_cast<unsigned>(entry.builtin)) {
continue;
}
if (spvc_compiler_has_member_decoration(compiler, entry.resource.base_type_id, member,
SpvDecorationOffset) != SPVC_TRUE) {
break; // this built-in is present but not captured
}
SpirvXfbCapture capture;
capture.name = name;
capture.buffer = buffer;
capture.stride = stride;
capture.offset = spvc_compiler_get_member_decoration(
compiler, entry.resource.base_type_id, member, SpvDecorationOffset);
capture.componentCount =
XfbComponentCount(compiler, spvc_type_get_member_type(blockType, member));
captures.push_back(Move(capture));
break;
}
}
}
// Capture order IS buffer-then-offset order: that is the order the equivalent
// glTransformFeedbackVaryings request has to name them in for the frontend's
// packer to reproduce the declared layout.
std::stable_sort(captures.begin(), captures.end(),
[](const SpirvXfbCapture& a, const SpirvXfbCapture& b) {
if (a.buffer != b.buffer) return a.buffer < b.buffer;
return a.offset < b.offset;
});
return captures;
}
void SpvcSession::StripTransformFeedbackDecorations() {
if (compiler == nullptr || resources == nullptr) return;
auto stripVariable = [this](SpvId variableId, spvc_type_id baseTypeId) {
spvc_compiler_unset_decoration(compiler, variableId, SpvDecorationXfbBuffer);
spvc_compiler_unset_decoration(compiler, variableId, SpvDecorationXfbStride);
spvc_compiler_unset_decoration(compiler, variableId, SpvDecorationOffset);
const spvc_type type = spvc_compiler_get_type_handle(compiler, baseTypeId);
if (type == nullptr || spvc_type_get_basetype(type) != SPVC_BASETYPE_STRUCT) return;
const unsigned memberCount = spvc_type_get_num_member_types(type);
for (unsigned member = 0; member < memberCount; ++member) {
spvc_compiler_unset_member_decoration(compiler, baseTypeId, member, SpvDecorationOffset);
spvc_compiler_unset_member_decoration(compiler, baseTypeId, member, SpvDecorationXfbBuffer);
spvc_compiler_unset_member_decoration(compiler, baseTypeId, member, SpvDecorationXfbStride);
}
};
const spvc_reflected_resource* outputs = nullptr;
SizeT outputCount = 0;
if (spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_STAGE_OUTPUT, &outputs,
&outputCount) == SPVC_SUCCESS) {
for (SizeT i = 0; i < outputCount; ++i) {
stripVariable(outputs[i].id, outputs[i].base_type_id);
}
}
const spvc_reflected_builtin_resource* builtins = nullptr;
SizeT builtinCount = 0;
if (spvc_resources_get_builtin_resource_list_for_type(
resources, SPVC_BUILTIN_RESOURCE_TYPE_STAGE_OUTPUT, &builtins, &builtinCount) ==
SPVC_SUCCESS) {
for (SizeT i = 0; i < builtinCount; ++i) {
stripVariable(builtins[i].resource.id, builtins[i].resource.base_type_id);
}
}
}
spvc_result SpvcSession::SetEntryPoint(const char* name, SpvExecutionModel model) {
// A null compiler or a null/empty name is a FAILURE, not a silent success: the
// caller is asking for a specific entry point and there is none to give it.
if (compiler == nullptr || name == nullptr || *name == '\0') return SPVC_ERROR_INVALID_ARGUMENT;
return spvc_compiler_set_entry_point(compiler, name, model);
}
Bool SpvcSession::SetSpecializationConstants(const Vector<Uint32>& constantIds,
const Vector<Uint32>& constantValues,
Uint32& outUnknownConstantId) {
if (constantIds.empty()) return true;
if (compiler == nullptr) return false;
const spvc_specialization_constant* declared = nullptr;
SizeT declaredCount = 0;
if (spvc_compiler_get_specialization_constants(compiler, &declared, &declaredCount) != SPVC_SUCCESS) {
outUnknownConstantId = constantIds.front();
return false;
}
for (SizeT i = 0; i < constantIds.size(); ++i) {
const Uint32 wantedId = constantIds[i];
spvc_constant handle = nullptr;
for (SizeT j = 0; j < declaredCount; ++j) {
if (declared[j].constant_id != wantedId) continue;
handle = spvc_compiler_get_constant_handle(compiler, declared[j].id);
break;
}
if (handle == nullptr) {
// ARB_gl_spirv: "INVALID_VALUE is generated if any value in pConstantIndex
// refers to a specialization constant that does not exist in the shader
// module". Reported rather than skipped - a silently ignored id would let
// the shader specialize to something the application never asked for.
outUnknownConstantId = wantedId;
return false;
}
// The GL side hands over a flat GLuint per constant and ARB_gl_spirv says it
// is "interpreted according to the type of the specialization constant", so
// the 32-bit PATTERN is what has to be stored, not a converted number.
// spvc_constant_set_scalar_u32 writes exactly that pattern into the constant's
// scalar union, which SPIRV-Cross then reads back as whatever the constant's
// declared type is - the reinterpretation the extension asks for, for free.
spvc_constant_set_scalar_u32(handle, 0, 0, constantValues[i]);
}
return true;
}
namespace {
struct ShadingRateBuiltinSpelling {
SpvBuiltIn builtin;
const char* sentinel;
const char* essl;
};
// The sentinels only have to survive SPIRV-Cross's renaming untouched (no "gl_"
// prefix, no double underscore) and be names no application spells.
constexpr ShadingRateBuiltinSpelling kShadingRateBuiltins[] = {
{SpvBuiltInShadingRateKHR, "mgl_sentinel_ShadingRateEXT", "gl_ShadingRateEXT"},
{SpvBuiltInPrimitiveShadingRateKHR, "mgl_sentinel_PrimitiveShadingRateEXT",
"gl_PrimitiveShadingRateEXT"},
};
Bool IsIdentifierChar(char c) {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
}
// Whether `line` declares `name` as a plain interface variable - the one statement
// SPIRV-Cross prints for an undecorated in/out: optional layout(...), interpolation
// and precision qualifiers, `in`/`out`, a type, the name and the semicolon. No '=',
// no call, nothing after the name: every USE of the variable is an expression.
Bool IsInterfaceDeclarationOf(const String& line, const String& name) {
const SizeT end = line.find_last_not_of(" \t\r");
if (end == String::npos || end == 0 || line[end] != ';') return false;
SizeT nameEnd = line.find_last_not_of(" \t", end - 1);
if (nameEnd == String::npos || nameEnd + 1 < name.size()) return false;
const SizeT nameBegin = nameEnd + 1 - name.size();
if (line.compare(nameBegin, name.size(), name) != 0) return false;
if (nameBegin > 0 && IsIdentifierChar(line[nameBegin - 1])) return false;
String head = line.substr(0, nameBegin);
// Drop a leading layout(...) block, then require the storage keyword as a word.
const SizeT layout = head.find("layout");
if (layout != String::npos) {
const SizeT close = head.find(')', layout);
if (close == String::npos) return false;
head.erase(layout, close + 1 - layout);
}
if (head.find('(') != String::npos || head.find('=') != String::npos) return false;
for (const char* keyword : {"in", "out"}) {
const String word(keyword);
for (SizeT at = head.find(word); at != String::npos; at = head.find(word, at + 1)) {
const Bool startOk = at == 0 || !IsIdentifierChar(head[at - 1]);
const Bool endOk = at + word.size() >= head.size() || !IsIdentifierChar(head[at + word.size()]);
if (startOk && endOk) return true;
}
}
return false;
}
} // namespace
Bool SpvcSession::PrepareShadingRateBuiltinsForEssl() {
if (!(usage & SessionUsageBit::Transpile) || !IsTranspileReady()) return false;
Bool renamed = false;
for (const spvc_builtin_resource_type type :
{SPVC_BUILTIN_RESOURCE_TYPE_STAGE_INPUT, SPVC_BUILTIN_RESOURCE_TYPE_STAGE_OUTPUT}) {
const spvc_reflected_builtin_resource* list = nullptr;
size_t count = 0;
if (spvc_resources_get_builtin_resource_list_for_type(resources, type, &list, &count) !=
SPVC_SUCCESS) {
continue;
}
for (size_t i = 0; i < count; ++i) {
const SpvId variable = list[i].resource.id;
// A member of a built-in block is reported here too; only a standalone
// variable carries the decoration itself, and that is how both of these
// are declared in every stage that has them.
if (!spvc_compiler_has_decoration(compiler, variable, SpvDecorationBuiltIn)) continue;
for (const auto& spelling : kShadingRateBuiltins) {
if (list[i].builtin != spelling.builtin) continue;
spvc_compiler_unset_decoration(compiler, variable, SpvDecorationBuiltIn);
spvc_compiler_set_name(compiler, variable, spelling.sentinel);
renamed = true;
}
}
}
if (renamed) {
spvc_compiler_require_extension(compiler, "GL_EXT_fragment_shading_rate");
}
return renamed;
}
void SpvcSession::FinishShadingRateBuiltinsForEssl(String& essl) {
for (const auto& spelling : kShadingRateBuiltins) {
const String sentinel = spelling.sentinel;
if (essl.find(sentinel) == String::npos) continue;
String rewritten;
rewritten.reserve(essl.size());
SizeT lineBegin = 0;
while (lineBegin < essl.size()) {
SizeT lineEnd = essl.find('\n', lineBegin);
const SizeT next = lineEnd == String::npos ? essl.size() : lineEnd + 1;
const String line = essl.substr(lineBegin, (lineEnd == String::npos ? essl.size() : lineEnd) -
lineBegin);
if (!IsInterfaceDeclarationOf(line, sentinel)) {
rewritten.append(essl, lineBegin, next - lineBegin);
}
lineBegin = next;
}
// Every remaining occurrence is a use; rename it, as a whole identifier only.
String result;
result.reserve(rewritten.size());
SizeT cursor = 0;
for (SizeT at = rewritten.find(sentinel); at != String::npos;
at = rewritten.find(sentinel, at + sentinel.size())) {
const Bool startOk = at == 0 || !IsIdentifierChar(rewritten[at - 1]);
const SizeT after = at + sentinel.size();
const Bool endOk = after >= rewritten.size() || !IsIdentifierChar(rewritten[after]);
if (!startOk || !endOk) continue;
result.append(rewritten, cursor, at - cursor);
result.append(spelling.essl);
cursor = after;
}
result.append(rewritten, cursor, String::npos);
essl = Move(result);
}
}
spvc_result SpvcSession::Compile(const char** result) {
if (!(usage & SessionUsageBit::Transpile)) return SPVC_ERROR_INVALID_ARGUMENT;
SPVC_CHK_INIT
SPVC_CHK_RESULT(spvc_compiler_compile(compiler, result));
SPVC_CHK_RETURN
}
spvc_result SpvcSession::ParseMetaData() {
if (usage & SessionUsageBit::Transpile) {
// SPIRV-Cross path
SPVC_CHK_INIT
metadata = SpvcMetadata();
const spvc_reflected_resource* list = nullptr;
size_t count = 0;
SPVC_CHK_RESULT(spvc_resources_get_resource_list_for_type(
resources, SPVC_RESOURCE_TYPE_UNIFORM_BUFFER, &list, &count);)
for (size_t i = 0; i < count; ++i) {
if (spvc_compiler_has_decoration(compiler, list[i].id, SpvDecorationBuiltIn)) {
continue;
}
if (strcmp(list[i].name, GLOBAL_UBO_NAME) == 0) {
spvc_type type = spvc_compiler_get_type_handle(compiler, list[i].base_type_id);
spvc_compiler_get_declared_struct_size(compiler, type, &metadata.globalUboSize);
size_t num_members = spvc_type_get_num_member_types(type);
for (size_t j = 0; j < num_members; ++j) {
const char* memberName =
spvc_compiler_get_member_name(compiler, list[i].base_type_id, j);
unsigned memberOffset = 0;
SPVC_CHK_RESULT(
spvc_compiler_type_struct_member_offset(compiler, type, j, &memberOffset);)
metadata.plainUniformOffsetsInUBO[memberName] = memberOffset;
SizeT memberSize = 0;
SPVC_CHK_RESULT(
spvc_compiler_get_declared_struct_member_size(compiler, type, j, &memberSize);)
metadata.plainUniformMemberSizesInBytes[memberName] = memberSize;
auto memberTypeId = spvc_type_get_member_type(type, j);
spvc_type memberType = spvc_compiler_get_type_handle(compiler, memberTypeId);
spvc_basetype basetype = spvc_type_get_basetype(memberType);
auto vectorSize = spvc_type_get_vector_size(memberType);
auto matCol = spvc_type_get_columns(memberType);
metadata.plainUniformMemberTypes[memberName] = {
.basetype = basetype,
.vectorSize = vectorSize,
.matCol = matCol,
};
}
SPVC_CHK_RETURN
}
}
return SPVC_ERROR_INVALID_SPIRV;
}
// SPIRV-Reflect path (Reflection only)
if (!reflectModuleValid) return SPVC_ERROR_INVALID_SPIRV;
metadata = SpvcMetadata();
uint32_t bindingCount = 0;
spvReflectEnumerateDescriptorBindings(&reflectModule, &bindingCount, nullptr);
Vector<SpvReflectDescriptorBinding*> bindings(bindingCount);
spvReflectEnumerateDescriptorBindings(&reflectModule, &bindingCount, bindings.data());
for (uint32_t i = 0; i < bindingCount; ++i) {
auto* binding = bindings[i];
if (binding->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER) continue;
if (strcmp(binding->type_description->type_name, GLOBAL_UBO_NAME) != 0) continue;
auto& block = binding->block;
metadata.globalUboSize = block.size;
for (uint32_t j = 0; j < block.member_count; ++j) {
// Recurse into nested structs / struct arrays so every leaf
// uniform ("s[0].b[1].b") gets its real byte offset; top-level
// scalars/vectors/matrices flatten to themselves.
FlattenGlobalUboMember(block.members[j], "", 0, metadata);
}
return SPVC_SUCCESS;
}
return SPVC_ERROR_INVALID_SPIRV;
}
const SpvcMetadata& SpvcSession::GetMetadata() const {
return metadata;
}
const char* SpvcSession::GetLastErrorString() const {
if (context) {
return spvc_context_get_last_error_string(context);
}
return "";
}
SpvcSession::~SpvcSession() {
spvc_context_destroy(context);
if (reflectModuleValid) {
spvReflectDestroyShaderModule(&reflectModule);
}
}
} // namespace ShaderTranspiler
} // namespace MG_Util
} // namespace MobileGL