SceneKit中用双MTLBuffer与Blit Shader逐帧更新SCNGeometrySource

刚好我之前处理过类似的场景，这就给你一套完整的解决方案，包含Blit Shader编写、双缓冲区配置以及SceneKit集成的全流程代码：

核心思路很清晰：我们需要两个MTLBuffer配合自定义Blit Shader，把GPU端变形后的顶点数据复制到CPU可访问的共享缓冲区，再用这些数据更新SCNGeometrySource，让SceneKit能正确识别变形后的几何体进行交互。

1. 编写Blit Compute Shader #

首先创建一个.metal文件，写一个简单的计算着色器，负责把GPU端的变形顶点批量复制到共享缓冲区：

#include <metal_stdlib>
using namespace metal;

// 要和你实际的顶点结构匹配，这里只包含位置属性，按需添加法线/UV等
struct Vertex {
    float3 position;
};

kernel void copyDeformedVertices(
    device Vertex* source [[buffer(0)]],
    device Vertex* destination [[buffer(1)]],
    uint index [[thread_position_in_grid]]
) {
    // 逐顶点复制数据
    destination[index] = source[index];
}

2. Swift端核心逻辑实现 #

我们封装一个DeformedGeometryUpdater类，专门管理缓冲区、Blit管线和GeometrySource更新：

import SceneKit
import Metal

class DeformedGeometryUpdater {
    private let device: MTLDevice
    private let blitPipeline: MTLComputePipelineState
    private let gpuVertexBuffer: MTLBuffer // GPU独占，存储变形后顶点
    private let sharedVertexBuffer: MTLBuffer // CPU可访问，用于同步数据
    private let vertexCount: Int
    private var targetSource: SCNGeometrySource
    
    init(device: MTLDevice, targetSource: SCNGeometrySource, vertexCount: Int) {
        self.device = device
        self.targetSource = targetSource
        self.vertexCount = vertexCount
        
        // 计算缓冲区大小（按顶点结构字节数计算）
        let vertexStride = MemoryLayout<float3>.stride
        let bufferSize = vertexStride * vertexCount
        
        // 创建两个缓冲区：GPU独占 + CPU共享
        gpuVertexBuffer = device.makeBuffer(length: bufferSize, options: .storageModePrivate)!
        sharedVertexBuffer = device.makeBuffer(length: bufferSize, options: .storageModeShared)!
        
        // 加载Blit Shader并创建管线状态
        guard let library = device.makeDefaultLibrary(),
              let copyFunc = library.makeFunction(name: "copyDeformedVertices") else {
            fatalError("Failed to load blit shader function")
        }
        do {
            blitPipeline = try device.makeComputePipelineState(function: copyFunc)
        } catch {
            fatalError("Failed to create blit pipeline: \(error)")
        }
    }
    
    // 执行GPU到CPU的顶点数据复制
    func syncDeformedVertices(from deformedBuffer: MTLBuffer) {
        guard let commandQueue = device.makeCommandQueue() else { return }
        let commandBuffer = commandQueue.makeCommandBuffer()!
        let computeEncoder = commandBuffer.makeComputeCommandEncoder()!
        
        // 设置管线和缓冲区
        computeEncoder.setComputePipelineState(blitPipeline)
        computeEncoder.setBuffer(deformedBuffer, offset: 0, index: 0) // 源：变形后的GPU缓冲区
        computeEncoder.setBuffer(sharedVertexBuffer, offset: 0, index: 1) // 目标：共享缓冲区
        
        // 配置线程组（按Metal最佳实践，用256线程每组）
        let threadGroupSize = MTLSize(width: 256, height: 1, depth: 1)
        let threadGroupCount = MTLSize(
            width: (vertexCount + threadGroupSize.width - 1) / threadGroupSize.width,
            height: 1,
            depth: 1
        )
        computeEncoder.dispatchThreadgroups(threadGroupCount, threadsPerThreadgroup: threadGroupSize)
        
        computeEncoder.endEncoding()
        commandBuffer.commit()
        commandBuffer.waitUntilCompleted() // 等待复制完成，确保CPU能读取最新数据
    }
    
    // 更新SCNGeometrySource，让SceneKit同步变形后的几何体
    func updateGeometrySource() {
        // 从共享缓冲区获取顶点数据指针
        guard let vertexPtr = sharedVertexBuffer.contents().bindMemory(to: float3.self, capacity: vertexCount) else {
            return
        }
        
        // 创建新的GeometrySource替换旧的
        let newSource = SCNGeometrySource(
            data: Data(bytes: vertexPtr, count: vertexCount * MemoryLayout<float3>.stride),
            semantic: targetSource.semantic,
            vectorCount: vertexCount,
            usesFloatComponents: true,
            componentsPerVector: 3,
            bytesPerComponent: MemoryLayout<Float>.stride,
            dataOffset: 0,
            dataStride: MemoryLayout<float3>.stride
        )
        
        // 更新几何体的Source数组
        if let geometry = targetSource.geometry {
            let updatedSources = geometry.geometrySources.map {
                $0.semantic == targetSource.semantic ? newSource : $0
            }
            geometry.geometrySources = updatedSources
        }
        
        targetSource = newSource
    }
}

3. 在SceneKit中集成使用 #

在你的ViewController里，初始化Updater并在每帧渲染后执行同步和更新：

class ViewController: UIViewController, SCNSceneRendererDelegate {
    private var scnView: SCNView!
    private var geometryUpdater: DeformedGeometryUpdater!
    // 这个是你自定义Shader输出的变形后顶点缓冲区，需要在你的SCNProgram逻辑中生成
    private var deformedGpuBuffer: MTLBuffer!

    override func viewDidLoad() {
        super.viewDidLoad()
        setupSceneKit()
        setupGeometryUpdater()
    }
    
    private func setupSceneKit() {
        scnView = SCNView(frame: view.bounds)
        scnView.delegate = self
        scnView.allowsCameraControl = true
        scnView.scene = SCNScene()
        view.addSubview(scnView)
        
        // 创建示例几何体（这里用立方体，替换成你的自定义几何体）
        let box = SCNBox(width: 1, height: 1, length: 1, chamferRadius: 0)
        let boxNode = SCNNode(geometry: box)
        scnView.scene?.rootNode.addChildNode(boxNode)
        
        // 假设你已经通过自定义SCNProgram生成了变形后的顶点缓冲区deformedGpuBuffer
        // deformedGpuBuffer = ... 你的自定义Shader逻辑
    }
    
    private func setupGeometryUpdater() {
        guard let device = scnView.device,
              let positionSource = scnView.scene?.rootNode.childNodes.first?.geometry?.geometrySources.first(where: {
                  $0.semantic == .vertex
              }),
              let vertexCount = positionSource.geometry?.geometryElements.first?.primitiveCount * 3 else {
            return
        }
        
        geometryUpdater = DeformedGeometryUpdater(
            device: device,
            targetSource: positionSource,
            vertexCount: vertexCount
        )
    }
    
    // 每帧渲染完成后执行同步更新
    func renderer(_ renderer: SCNSceneRenderer, didRenderScene scene: SCNScene, atTime time: TimeInterval) {
        guard let deformedBuffer = deformedGpuBuffer else { return }
        geometryUpdater.syncDeformedVertices(from: deformedBuffer)
        geometryUpdater.updateGeometrySource()
    }
}

关键注意事项 #

• 顶点结构一致性：确保Metal Shader中的Vertex结构体和你自定义Shader输出的顶点数据结构完全匹配，否则会出现数据错乱。
• 性能优化：commandBuffer.waitUntilCompleted()会阻塞CPU，如果你的场景对帧率要求极高，可以改用异步回调（addCompletedHandler），但要注意线程安全。
• 缓冲区复用：尽量避免每帧创建新缓冲区，复用初始化时创建的两个缓冲区可以大幅提升性能。

内容的提问来源于stack exchange，提问作者Astemir Eleev