Add basic Metal Shader Converter support

Author: andrejnau

CMakeLists.txt

@@ -11,6 +11,7 @@ option(VULKAN_SUPPORT "Vulkan support" ON)
 cmake_dependent_option(DIRECTX_SUPPORT "DirectX 12 support" ON "WIN32" OFF)
 option(AGILITY_SDK_REQUIRED "Use Agility SDK" OFF)
 cmake_dependent_option(METAL_SUPPORT "Metal support" ON "APPLE" OFF)
+option(USE_METAL_SHADER_CONVERTER "Use Metal Shader Converter" OFF)
 option(ENABLE_VALIDATION "Enable backend graphics api validation layer" ON)
 option(BUILD_SAMPLES "Build samples" ON)
 cmake_dependent_option(BUILD_TESTING "Build unit tests" ON "NOT IOS_OR_TVOS AND NOT ANDROID" OFF)
@@ -54,6 +55,9 @@ endif()
 if (ENABLE_VALIDATION)
     add_compile_definitions(ENABLE_VALIDATION)
 endif()
+if (USE_METAL_SHADER_CONVERTER)
+    add_compile_definitions(USE_METAL_SHADER_CONVERTER)
+endif()
 
 if (BUILD_TESTING)
     enable_testing()

src/FlyCube/CMakeLists.txt

@@ -114,8 +114,11 @@ list(APPEND GPUDescriptorPool
 )
 
 list(APPEND HLSLCompiler
-    HLSLCompiler/Compiler.h
+    $<$<BOOL:${USE_METAL_SHADER_CONVERTER}>:HLSLCompiler/MetalIrConverterImpl.mm>
+    $<$<BOOL:${USE_METAL_SHADER_CONVERTER}>:HLSLCompiler/MetalShaderConverter.cpp>
+    $<$<BOOL:${USE_METAL_SHADER_CONVERTER}>:HLSLCompiler/MetalShaderConverter.h>
     HLSLCompiler/Compiler.cpp
+    HLSLCompiler/Compiler.h
     HLSLCompiler/DXCLoader.cpp
     HLSLCompiler/DXCLoader.h
     HLSLCompiler/MSLConverter.cpp
@@ -312,13 +315,14 @@ add_library(FlyCube
 )
 
 target_link_libraries(FlyCube
-    $<$<BOOL:${APPLE}>:-framework\ Foundation>
-    $<$<BOOL:${APPLE}>:-framework\ QuartzCore>
     $<$<AND:$<BOOL:${DIRECTX_SUPPORT}>,$<PLATFORM_ID:Windows>>:d3d12>
     $<$<AND:$<BOOL:${DIRECTX_SUPPORT}>,$<PLATFORM_ID:Windows>>:dxgi>
     $<$<AND:$<BOOL:${DIRECTX_SUPPORT}>,$<PLATFORM_ID:Windows>>:dxguid>
+    $<$<BOOL:${APPLE}>:-framework\ Foundation>
+    $<$<BOOL:${APPLE}>:-framework\ QuartzCore>
     $<$<BOOL:${METAL_SUPPORT}>:-framework\ Metal>
     $<$<BOOL:${METAL_SUPPORT}>:MVKPixelFormats>
+    $<$<BOOL:${USE_METAL_SHADER_CONVERTER}>:/usr/local/lib/libmetalirconverter.dylib>
     $<$<BOOL:${VULKAN_SUPPORT}>:vulkan>
     DirectX-Headers
     dxc
@@ -332,6 +336,8 @@ target_link_libraries(FlyCube
 target_include_directories(FlyCube
     PUBLIC
         "${CMAKE_CURRENT_SOURCE_DIR}"
+        $<$<BOOL:${USE_METAL_SHADER_CONVERTER}>:/usr/local/include/metal_irconverter_runtime>
+        $<$<BOOL:${USE_METAL_SHADER_CONVERTER}>:/usr/local/include/metal_irconverter>
 )
 
 if (APPLE)

src/FlyCube/CommandList/MTCommandList.mm

@@ -11,6 +11,10 @@
 #include "Utilities/NotReached.h"
 #include "View/MTView.h"
 
+#if defined(USE_METAL_SHADER_CONVERTER)
+#include <metal_irconverter_runtime.h>
+#endif
+
 namespace {
 
 MTLIndexType ConvertIndexType(gli::format format)
@@ -472,7 +476,11 @@ MTLStages ResourceStateToMTLStages(ResourceState state)
 {
     id<MTLBuffer> vertex = CastToImpl<MTResource>(resource)->GetBuffer();
     AddAllocation(vertex);
+#if defined(USE_METAL_SHADER_CONVERTER)
+    uint32_t index = kIRVertexBufferBindPoint + slot;
+#else
     uint32_t index = device_.GetMaxPerStageBufferCount() - slot - 1;
+#endif
     [state_->argument_tables.at(ShaderType::kVertex) setAddress:vertex.gpuAddress + offset atIndex:index];
 }
 

src/FlyCube/Device/MTDevice.mm

@@ -25,6 +25,16 @@
 
 #include <type_traits>
 
+namespace {
+
+#if defined(USE_METAL_SHADER_CONVERTER)
+constexpr ShaderBlobType kShaderBlobType = ShaderBlobType::kDXIL;
+#else
+constexpr ShaderBlobType kShaderBlobType = ShaderBlobType::kSPIRV;
+#endif
+
+} // namespace
+
 MTLCompareFunction ConvertToCompareFunction(ComparisonFunc func)
 {
     switch (func) {
@@ -183,7 +193,7 @@ MTLCompareFunction ConvertToCompareFunction(ComparisonFunc func)
 
 std::shared_ptr<Shader> MTDevice::CompileShader(const ShaderDesc& desc)
 {
-    return std::make_shared<MTShader>(*this, Compile(desc, ShaderBlobType::kSPIRV), ShaderBlobType::kSPIRV, desc.type);
+    return std::make_shared<MTShader>(*this, Compile(desc, kShaderBlobType), kShaderBlobType, desc.type);
 }
 
 std::shared_ptr<Pipeline> MTDevice::CreateGraphicsPipeline(const GraphicsPipelineDesc& desc)
@@ -351,7 +361,7 @@ MTLCompareFunction ConvertToCompareFunction(ComparisonFunc func)
 
 ShaderBlobType MTDevice::GetSupportedShaderBlobType() const
 {
-    return ShaderBlobType::kSPIRV;
+    return kShaderBlobType;
 }
 
 uint64_t MTDevice::GetConstantBufferOffsetAlignment() const

src/FlyCube/HLSLCompiler/MetalIrConverterImpl.mm

@@ -0,0 +1,5 @@
+#import <Metal/Metal.h>
+
+#define IR_PRIVATE_IMPLEMENTATION
+#include <metal_irconverter.h>
+#include <metal_irconverter_runtime.h>

src/FlyCube/HLSLCompiler/MetalShaderConverter.cpp

@@ -0,0 +1,64 @@
+#include "HLSLCompiler/MetalShaderConverter.h"
+
+#include "Utilities/Logging.h"
+#include "Utilities/NotReached.h"
+
+#include <metal_irconverter.h>
+
+namespace {
+
+IRShaderStage GetShaderStage(ShaderType type)
+{
+    switch (type) {
+    case ShaderType::kVertex:
+        return IRShaderStageVertex;
+    case ShaderType::kPixel:
+        return IRShaderStageFragment;
+    case ShaderType::kGeometry:
+        return IRShaderStageGeometry;
+    case ShaderType::kCompute:
+        return IRShaderStageCompute;
+    case ShaderType::kAmplification:
+        return IRShaderStageAmplification;
+    case ShaderType::kMesh:
+        return IRShaderStageMesh;
+    default:
+        NOTREACHED();
+    }
+}
+
+} // namespace
+
+std::vector<uint8_t> ConvertToMetalLibBytecode(ShaderType shader_type, const std::vector<uint8_t>& blob)
+{
+    IRCompiler* compiler = IRCompilerCreate();
+    IRObject* dxil_obj = IRObjectCreateFromDXIL(blob.data(), blob.size(), IRBytecodeOwnershipNone);
+
+    if (shader_type == ShaderType::kVertex) {
+        IRCompilerSetStageInGenerationMode(compiler, IRStageInCodeGenerationModeUseMetalVertexFetch);
+    }
+
+    IRError* error = nullptr;
+    IRObject* metal_ir = IRCompilerAllocCompileAndLink(compiler, nullptr, dxil_obj, &error);
+    if (!metal_ir) {
+        Logging::Println("IRCompilerAllocCompileAndLink failed: {}", IRErrorGetCode(error));
+        IRErrorDestroy(error);
+        IRObjectDestroy(dxil_obj);
+        IRCompilerDestroy(compiler);
+        return {};
+    }
+
+    auto* metal_lib = IRMetalLibBinaryCreate();
+    IRObjectGetMetalLibBinary(metal_ir, GetShaderStage(shader_type), metal_lib);
+
+    size_t metal_lib_size = IRMetalLibGetBytecodeSize(metal_lib);
+    std::vector<uint8_t> metal_lib_bytecode(metal_lib_size);
+    IRMetalLibGetBytecode(metal_lib, metal_lib_bytecode.data());
+
+    IRMetalLibBinaryDestroy(metal_lib);
+    IRObjectDestroy(metal_ir);
+    IRObjectDestroy(dxil_obj);
+    IRCompilerDestroy(compiler);
+
+    return metal_lib_bytecode;
+}

src/FlyCube/HLSLCompiler/MetalShaderConverter.h

@@ -0,0 +1,4 @@
+#pragma once
+#include "Instance/BaseTypes.h"
+
+std::vector<uint8_t> ConvertToMetalLibBytecode(ShaderType shader_type, const std::vector<uint8_t>& blob);

src/FlyCube/Pipeline/MTGraphicsPipeline.mm

@@ -7,6 +7,10 @@
 #include "Utilities/Logging.h"
 #include "Utilities/NotReached.h"
 
+#if defined(USE_METAL_SHADER_CONVERTER)
+#include <metal_irconverter_runtime.h>
+#endif
+
 namespace {
 
 MTLStencilOperation ConvertStencilOperation(StencilOp op)
@@ -245,13 +249,21 @@ MTLBlendFactor ConvertBlendOp(BlendFactor factor)
             CHECK(input_layout_stride[vertex.slot] == vertex.stride);
         }
 
+#if defined(USE_METAL_SHADER_CONVERTER)
+        const uint32_t buffer_index = kIRVertexBufferBindPoint + vertex.slot;
+#else
         const uint32_t buffer_index = device_.GetMaxPerStageBufferCount() - vertex.slot - 1;
+#endif
         MTLVertexBufferLayoutDescriptor* layout = vertex_descriptor.layouts[buffer_index];
         layout.stride = vertex.stride;
         layout.stepFunction = MTLVertexStepFunctionPerVertex;
         layout.stepRate = 1;
 
+#if defined(USE_METAL_SHADER_CONVERTER)
+        const uint32_t location = kIRStageInAttributeStartIndex + shader->GetInputLayoutLocation(vertex.semantic_name);
+#else
         const uint32_t location = shader->GetInputLayoutLocation(vertex.semantic_name);
+#endif
         MTLVertexAttributeDescriptor* attribute = vertex_descriptor.attributes[location];
         attribute.offset = vertex.offset;
         attribute.bufferIndex = buffer_index;

src/FlyCube/Shader/MTShader.mm

@@ -1,12 +1,28 @@
 #include "Shader/MTShader.h"
 
 #include "Device/MTDevice.h"
-#include "HLSLCompiler/MSLConverter.h"
 #include "Utilities/Logging.h"
 
+#if defined(USE_METAL_SHADER_CONVERTER)
+#include "HLSLCompiler/MetalShaderConverter.h"
+#else
+#include "HLSLCompiler/MSLConverter.h"
+#endif
+
 MTShader::MTShader(MTDevice& device, const std::vector<uint8_t>& blob, ShaderBlobType blob_type, ShaderType shader_type)
     : ShaderBase(blob, blob_type, shader_type)
 {
+#if defined(USE_METAL_SHADER_CONVERTER)
+    std::string entry_point = "main";
+    auto metal_lib_bytecode = ConvertToMetalLibBytecode(shader_type, blob);
+    dispatch_data_t metal_lib_data = dispatch_data_create(metal_lib_bytecode.data(), metal_lib_bytecode.size(), nullptr,
+                                                          DISPATCH_DATA_DESTRUCTOR_DEFAULT);
+    NSError* error = nullptr;
+    id<MTLLibrary> library = [device.GetDevice() newLibraryWithData:metal_lib_data error:&error];
+    if (library == nullptr) {
+        Logging::Println("Failed to create MTLLibrary: {}", error);
+    }
+#else
     std::string entry_point;
     std::string msl_source = GetMSLShader(shader_type, blob_, slot_remapping_, entry_point);
 
@@ -17,6 +33,7 @@
     if (!library) {
         Logging::Println("Failed to create MTLLibrary: {}", error);
     }
+#endif
 
     function_descriptor_ = [MTL4LibraryFunctionDescriptor new];
     function_descriptor_.library = library;