Set explicit resource bindings for Metal.

Previous versions of SPIRV-Cross used the binding that was set if no
explicit mapping was added. This has since been removed and explicit
mappings are always needed.

Author: akb825

Compile/src/MetalOutput.cpp

@@ -21,8 +21,9 @@
 namespace msl
 {
 
-std::string MetalOutput::disassemble(Output& output, const Compiler::SpirV& spirv,
-	std::uint32_t version, bool ios, bool outputToBuffer, const std::string& fileName,
+std::string MetalOutput::disassemble(Output& output, const Compiler::SpirV& spirv, Stage stage,
+	std::uint32_t version, bool ios, bool outputToBuffer, bool hasPushConstant,
+	std::uint32_t bufferCount, std::uint32_t textureCount, const std::string& fileName,
 	std::size_t line, std::size_t column)
 {
 	spirv_cross::CompilerMSL::Options options;
@@ -31,8 +32,54 @@ std::string MetalOutput::disassemble(Output& output, const Compiler::SpirV& spir
 	options.msl_version = spirv_cross::CompilerMSL::Options::make_msl_version(version/10,
 		version%10);
 	options.capture_output_to_buffer = outputToBuffer;
+
 	spirv_cross::CompilerMSL compiler(spirv);
 	compiler.set_msl_options(options);
+
+	spv::ExecutionModel executionModel = spv::ExecutionModelMax;
+	switch (stage)
+	{
+		case Stage::Vertex:
+			executionModel = spv::ExecutionModelVertex;
+			break;
+		case Stage::TessellationControl:
+			executionModel = spv::ExecutionModelTessellationControl;
+			break;
+		case Stage::TessellationEvaluation:
+			executionModel = spv::ExecutionModelTessellationEvaluation;
+			break;
+		case Stage::Geometry:
+			executionModel = spv::ExecutionModelGeometry;
+			break;
+		case Stage::Fragment:
+			executionModel = spv::ExecutionModelFragment;
+			break;
+		case Stage::Compute:
+			executionModel = spv::ExecutionModelGLCompute;
+			break;
+	}
+
+	for (std::uint32_t i = hasPushConstant ? 1 : 0; i < bufferCount; ++i)
+	{
+		spirv_cross::MSLResourceBinding binding;
+		binding.stage = executionModel;
+		binding.desc_set = 0;
+		binding.binding = i;
+		binding.msl_buffer = i;
+		compiler.add_msl_resource_binding(binding);
+	}
+
+	for (std::uint32_t i = 0; i < textureCount; ++i)
+	{
+		spirv_cross::MSLResourceBinding binding;
+		binding.stage = executionModel;
+		binding.desc_set = 1;
+		binding.binding = i;
+		binding.msl_texture = i;
+		binding.msl_sampler = i;
+		compiler.add_msl_resource_binding(binding);
+	}
+
 	try
 	{
 		return compiler.compile();

Compile/src/MetalOutput.h

@@ -25,8 +25,9 @@ namespace msl
 class MetalOutput
 {
 public:
-	static std::string disassemble(Output& output, const Compiler::SpirV& spirv,
-		std::uint32_t version, bool ios, bool outputToBuffer, const std::string& fileName,
+	static std::string disassemble(Output& output, const Compiler::SpirV& spirv, Stage stage,
+		std::uint32_t version, bool ios, bool outputToBuffer, bool hasPushConstant,
+		std::uint32_t bufferCount, std::uint32_t textureCount, const std::string& fileName,
 		std::size_t line, std::size_t column);
 };
 

Compile/src/TargetMetal.cpp

@@ -39,15 +39,18 @@
 namespace msl
 {
 
-static void setBinding(std::vector<uint32_t>& spirv, std::uint32_t id, std::uint32_t index)
+static void setBinding(std::vector<uint32_t>& spirv, std::uint32_t id, std::uint32_t set,
+	std::uint32_t binding)
 {
 	const unsigned int firstInstruction = 5;
 	const std::uint32_t opCodeMask = 0xFFFF;
 	const std::uint32_t wordCountShift = 16;
 	const std::uint32_t opFunction = 54;
 	const std::uint32_t opDecorate = 71;
 	const std::uint32_t decorationBinding = 33;
+	const std::uint32_t decorationDescriptorSet = 34;
 
+	bool descriptorSet = false, bindingSet = false;
 	for (uint32_t i = firstInstruction; i < spirv.size();)
 	{
 		uint32_t op = spirv[i] & opCodeMask;
@@ -57,22 +60,34 @@ static void setBinding(std::vector<uint32_t>& spirv, std::uint32_t id, std::uint
 		if (op == opFunction)
 			break;
 
-		if (op == opDecorate && spirv[i + 1] == id && spirv[i + 2] == decorationBinding)
+		if (op == opDecorate && spirv[i + 1] == id)
 		{
-			spirv[i + 3] = index;
-			break;
+			if (spirv[i + 2] == decorationDescriptorSet)
+			{
+				spirv[i + 3] = set;
+				descriptorSet = true;
+			}
+			else if (spirv[i + 2] == decorationBinding)
+			{
+				spirv[i + 3] = binding;
+				bindingSet = true;
+			}
+
+			if (bindingSet && descriptorSet)
+				break;
 		}
 
 		i += wordCount;
 	}
 }
 
 static std::vector<std::uint32_t> setBindingIndices(const std::vector<std::uint32_t>& spirv,
-	const std::vector<compile::Uniform>& uniforms, std::vector<std::uint32_t>& uniformIds)
+	const std::vector<compile::Uniform>& uniforms, std::vector<std::uint32_t>& uniformIds,
+	bool& hasPushConstant, std::uint32_t& bufferCount, std::uint32_t& textureCount)
 {
 	std::vector<std::uint32_t> adjustedSpirv = spirv;
 
-	bool hasPushConstant = false;
+	hasPushConstant = false;
 	for (std::size_t i = 0; i < uniforms.size(); ++i)
 	{
 		if (uniformIds[i] != unknown && uniforms[i].uniformType == UniformType::PushConstant)
@@ -96,18 +111,20 @@ static std::vector<std::uint32_t> setBindingIndices(const std::vector<std::uint3
 				break;
 			case UniformType::Block:
 			case UniformType::BlockBuffer:
-				setBinding(adjustedSpirv, uniformIds[i], bufferIndex);
+				setBinding(adjustedSpirv, uniformIds[i], 0, bufferIndex);
 				uniformIds[i] = bufferIndex++;
 				break;
 			case UniformType::Image:
 			case UniformType::SampledImage:
 			case UniformType::SubpassInput:
-				setBinding(adjustedSpirv, uniformIds[i], textureIndex);
+				setBinding(adjustedSpirv, uniformIds[i], 1, textureIndex);
 				uniformIds[i] = textureIndex++;
 				break;
 		}
 	}
 
+	bufferCount = bufferIndex;
+	textureCount = textureIndex;
 	return adjustedSpirv;
 }
 
@@ -182,12 +199,17 @@ bool TargetMetal::crossCompile(std::vector<std::uint8_t>& data, Output& output,
 	const std::vector<std::uint32_t>& spirv, const std::string& entryPoint,
 	const std::vector<compile::Uniform>& uniforms, std::vector<std::uint32_t>& uniformIds)
 {
-	std::vector<std::uint32_t> adjustedSpirv = setBindingIndices(spirv, uniforms, uniformIds);
 	bool outputToBuffer = stage == compile::Stage::Vertex &&
 		(pipelineStages[static_cast<int>(compile::Stage::TessellationControl)] ||
 			pipelineStages[static_cast<int>(compile::Stage::TessellationEvaluation)]);
-	std::string metal = MetalOutput::disassemble(output, adjustedSpirv, m_version, m_ios,
-		outputToBuffer, fileName, line, column);
+
+	bool hasPushConstant;
+	std::uint32_t bufferCount, textureCount;
+	std::vector<std::uint32_t> adjustedSpirv = setBindingIndices(spirv, uniforms, uniformIds,
+		hasPushConstant, bufferCount, textureCount);
+
+	std::string metal = MetalOutput::disassemble(output, adjustedSpirv, stage, m_version, m_ios,
+		outputToBuffer, hasPushConstant, bufferCount, textureCount, fileName, line, column);
 	if (metal.empty())
 		return false;