SwiftUI macOS应用中，能否为ShaderLibrary创建运行时编译的ShaderFunction？

首先明确：SwiftUI的ShaderLibrary确实只支持编译阶段嵌入的着色器，没有官方途径直接将运行时创建的MTLLibrary或其中的MTLFunction转换为SwiftUI的Shader类型。不过有两种可行的折中方案：

方案一：封装自定义SwiftUI视图（替代Canvas） #

如果必须保留运行时加载任意着色器源码的灵活性，还是得回到MTKView封装的思路，但可以把封装做得更贴合SwiftUI的使用习惯：

• 创建遵循NSViewRepresentable的MetalShaderView，内部管理MTKView、渲染管线状态、命令队列等核心组件
• 暴露接口接收运行时加载的MTLFunction，在视图内部动态更新渲染管线
• 可以封装成类似Canvas的链式调用API，降低使用复杂度

示例核心代码：

struct MetalShaderView: NSViewRepresentable {
    var fragmentShader: MTLFunction?
    
    func makeNSView(context: Context) -> MTKView {
        let view = MTKView()
        view.device = MTLCreateSystemDefaultDevice()
        view.delegate = context.coordinator
        return view
    }
    
    func updateNSView(_ nsView: MTKView, context: Context) {
        context.coordinator.fragmentShader = fragmentShader
        context.coordinator.rebuildPipeline()
        nsView.setNeedsDisplay()
    }
    
    func makeCoordinator() -> Coordinator {
        Coordinator()
    }
    
    class Coordinator: NSObject, MTKViewDelegate {
        var fragmentShader: MTLFunction?
        var pipelineState: MTLRenderPipelineState?
        let commandQueue = MTLCreateSystemDefaultDevice()?.makeCommandQueue()
        
        func mtkView(_ view: MTKView, drawableSizeWillChange size: CGSize) {}
        
        func draw(in view: MTKView) {
            guard let device = view.device,
                  let commandQueue = commandQueue,
                  let pipelineState = pipelineState,
                  let drawable = view.currentDrawable else { return }
            
            let commandBuffer = commandQueue.makeCommandBuffer()!
            let renderPassDescriptor = view.currentRenderPassDescriptor!
            renderPassDescriptor.colorAttachments[0].clearColor = MTLClearColor(red: 0, green: 0, blue: 0, alpha: 1)
            
            let renderEncoder = commandBuffer.makeRenderCommandEncoder(descriptor: renderPassDescriptor)!
            renderEncoder.setRenderPipelineState(pipelineState)
            renderEncoder.drawPrimitives(type: .triangleStrip, vertexStart: 0, vertexCount: 4)
            renderEncoder.endEncoding()
            
            commandBuffer.present(drawable)
            commandBuffer.commit()
        }
        
        func rebuildPipeline() {
            guard let device = MTLCreateSystemDefaultDevice(), let fragmentShader = fragmentShader else { return }
            let pipelineDescriptor = MTLRenderPipelineDescriptor()
            pipelineDescriptor.fragmentFunction = fragmentShader
            
            // 内置全屏四边形顶点着色器
            let vertexShaderSource = """
            #include <metal_stdlib>
            using namespace metal;
            struct VertexOut {
                float4 position [[position]];
                float2 uv;
            };
            vertex VertexOut vertexFunc(uint vertexID [[vertex_id]]) {
                VertexOut out;
                out.position = float4(float2(vertexID * 2 - 1, 1 - vertexID * 2), 0, 1);
                out.uv = float2(vertexID * 2, 1 - vertexID * 2);
                return out;
            }
            """
            do {
                let vertexLibrary = try device.makeLibrary(source: vertexShaderSource, options: nil)
                let vertexShader = vertexLibrary.makeFunction(name: "vertexFunc")!
                pipelineDescriptor.vertexFunction = vertexShader
                pipelineDescriptor.colorAttachments[0].pixelFormat = .bgra8Unorm
                pipelineState = try device.makeRenderPipelineState(descriptor: pipelineDescriptor)
            } catch {
                print("管线重建失败: \(error)")
            }
        }
    }
}

使用示例：

struct ContentView: View {
    @State private var fragmentShader: MTLFunction?
    
    var body: some View {
        VStack {
            MetalShaderView(fragmentShader: fragmentShader)
                .frame(width: 600, height: 400)
            Button("加载运行时着色器") {
                guard let device = MTLCreateSystemDefaultDevice() else { return }
                let shaderSource = """
                #include <metal_stdlib>
                using namespace metal;
                fragment float4 fragmentFunc(VertexOut in [[stage_in]]) {
                    return float4(in.uv, 0.5, 1.0);
                }
                """
                do {
                    let library = try device.makeLibrary(source: shaderSource, options: nil)
                    fragmentShader = library.makeFunction(name: "fragmentFunc")
                } catch {
                    print("着色器加载失败: \(error)")
                }
            }
        }
    }
}

方案二：利用Shader.custom实现参数动态调整（有限场景） #

如果你的需求只是动态调整着色器参数，而非完全替换源码，SwiftUI的Shader.custom(_:arguments:)是更轻量的选择——它依赖编译时嵌入的着色器，但支持动态传入参数：

// 编译时嵌入的.metal文件内容
#include <metal_stdlib>
using namespace metal;
fragment float4 dynamicShader(float2 uv [[texturecoord(0)]], float3 color [[color(0)]]) {
    return float4(color, 1.0);
}

// SwiftUI视图中使用
struct ContentView: View {
    @State private var color: Color = .red
    
    var body: some View {
        Canvas { context, size in
            let shader = Shader.custom(
                "dynamicShader",
                arguments: [Shader.Argument.color(color)]
            )
            context.fill(Rectangle(), with: .shader(shader))
        }
        .frame(width: 600, height: 400)
        .colorPicker("选择颜色", selection: $color)
    }
}

结论 #

如果必须运行时加载任意着色器源码，目前只能通过封装MTKView的NSViewRepresentable方案实现，没有官方途径将运行时的MTLLibrary与SwiftUI的ShaderLibrary/Shader进行转换。如果只是需要动态调整着色器参数，Shader.custom是更简洁的选择。

内容的提问来源于stack exchange，提问作者g i i k