Metal Framework: iOS'ta GPU Programming ve Grafik İşleme

1Application → Command Buffer → Command Encoder → GPU
2                                     ↓
3                            Vertex Shader → Rasterizer → Fragment Shader → Framebuffer

1import Metal
2import MetalKit
3 
4class MetalRenderer: NSObject {
5    let device: MTLDevice
6    let commandQueue: MTLCommandQueue
7    var pipelineState: MTLRenderPipelineState!
8 
9    init?(metalView: MTKView) {
10        // 1. GPU device
11        guard let device = MTLCreateSystemDefaultDevice() else { return nil }
12        self.device = device
13        metalView.device = device
14 
15        // 2. Command queue
16        guard let queue = device.makeCommandQueue() else { return nil }
17        self.commandQueue = queue
18 
19        super.init()
20        setupPipeline(metalView: metalView)
21    }
22 
23    private func setupPipeline(metalView: MTKView) {
24        // 3. Shader library
25        let library = device.makeDefaultLibrary()!
26        let vertexFunction = library.makeFunction(name: "vertex_main")
27        let fragmentFunction = library.makeFunction(name: "fragment_main")
28 
29        // 4. Pipeline descriptor
30        let descriptor = MTLRenderPipelineDescriptor()
31        descriptor.vertexFunction = vertexFunction
32        descriptor.fragmentFunction = fragmentFunction
33        descriptor.colorAttachments[0].pixelFormat = metalView.colorPixelFormat
34 
35        pipelineState = try! device.makeRenderPipelineState(descriptor: descriptor)
36    }
37}

1// Vertex data
2struct Vertex {
3    var position: SIMD3<Float>
4    var color: SIMD4<Float>
5}
6 
7let vertices: [Vertex] = [
8    Vertex(position: SIMD3(0, 0.5, 0), color: SIMD4(1, 0, 0, 1)),   // Üst - kırmızı
9    Vertex(position: SIMD3(-0.5, -0.5, 0), color: SIMD4(0, 1, 0, 1)), // Sol alt - yeşil
10    Vertex(position: SIMD3(0.5, -0.5, 0), color: SIMD4(0, 0, 1, 1)),  // Sağ alt - mavi
11]
12 
13// Render
14extension MetalRenderer: MTKViewDelegate {
15    func draw(in view: MTKView) {
16        guard let drawable = view.currentDrawable,
17              let descriptor = view.currentRenderPassDescriptor,
18              let commandBuffer = commandQueue.makeCommandBuffer(),
19              let encoder = commandBuffer.makeRenderCommandEncoder(descriptor: descriptor) else { return }
20 
21        encoder.setRenderPipelineState(pipelineState)
22        encoder.setVertexBytes(vertices, length: MemoryLayout<Vertex>.stride * vertices.count, index: 0)
23        encoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 3)
24        encoder.endEncoding()
25 
26        commandBuffer.present(drawable)
27        commandBuffer.commit()
28    }
29 
30    func mtkView(_ view: MTKView, drawableSizeWillChange size: CGSize) {}
31}

1// Shaders.metal
2#include 
3using namespace metal;
4 
5struct VertexIn {
6    float3 position [[attribute(0)]];
7    float4 color [[attribute(1)]];
8};
9 
10struct VertexOut {
11    float4 position [[position]];
12    float4 color;
13};
14 
15// Vertex shader - her vertex için çalışır
16vertex VertexOut vertex_main(
17    const device VertexIn* vertices [[buffer(0)]],
18    uint vertexID [[vertex_id]]
19) {
20    VertexOut out;
21    out.position = float4(vertices[vertexID].position, 1.0);
22    out.color = vertices[vertexID].color;
23    return out;
24}
25 
26// Fragment shader - her pixel için çalışır
27fragment float4 fragment_main(VertexOut in [[stage_in]]) {
28    return in.color; // Interpolated color
29}

1// Görüntü işleme compute shader
2func applyGrayscaleFilter(to texture: MTLTexture) {
3    let library = device.makeDefaultLibrary()!
4    let function = library.makeFunction(name: "grayscale_kernel")!
5    let pipeline = try! device.makeComputePipelineState(function: function)
6 
7    let commandBuffer = commandQueue.makeCommandBuffer()!
8    let encoder = commandBuffer.makeComputeCommandEncoder()!
9 
10    encoder.setComputePipelineState(pipeline)
11    encoder.setTexture(texture, index: 0)
12 
13    let threadGroupSize = MTLSize(width: 16, height: 16, depth: 1)
14    let threadGroups = MTLSize(
15        width: (texture.width + 15) / 16,
16        height: (texture.height + 15) / 16,
17        depth: 1
18    )
19    encoder.dispatchThreadgroups(threadGroups, threadsPerThreadgroup: threadGroupSize)
20    encoder.endEncoding()
21 
22    commandBuffer.commit()
23    commandBuffer.waitUntilCompleted()
24}

1// grayscale_kernel.metal
2kernel void grayscale_kernel(
3    texture2d texture [[texture(0)]],
4    uint2 gid [[thread_position_in_grid]]
5) {
6    float4 color = texture.read(gid);
7    float gray = dot(color.rgb, float3(0.299, 0.587, 0.114));
8    texture.write(float4(gray, gray, gray, color.a), gid);
9}

1// UIImage → MTLTexture
2func makeTexture(from image: UIImage) -> MTLTexture? {
3    let loader = MTKTextureLoader(device: device)
4    return try? loader.newTexture(cgImage: image.cgImage!, options: [
5        .textureUsage: MTLTextureUsage.shaderRead.rawValue,
6        .textureStorageMode: MTLStorageMode.shared.rawValue,
7    ])
8}

1import MetalPerformanceShaders
2 
3// Gaussian Blur
4let blur = MPSImageGaussianBlur(device: device, sigma: 5.0)
5blur.encode(commandBuffer: commandBuffer, sourceTexture: source, destinationTexture: destination)
6 
7// Image convolution, histogram, morphology...
8// Machine learning: MPSCNNConvolution, MPSNNGraph...

1// MetalKit view'ı SwiftUI'a sar
2struct MetalView: UIViewRepresentable {
3    func makeUIView(context: Context) -> MTKView {
4        let view = MTKView()
5        view.device = MTLCreateSystemDefaultDevice()
6        view.delegate = context.coordinator
7        return view
8    }
9 
10    func updateUIView(_ uiView: MTKView, context: Context) {}
11 
12    func makeCoordinator() -> MetalRenderer {
13        MetalRenderer()
14    }
15}
16 
17// SwiftUI'da kullan
18struct ContentView: View {
19    var body: some View {
20        MetalView()
21            .frame(height: 300)
22            .clipShape(RoundedRectangle(cornerRadius: 16))
23    }
24}

1class TripleBufferedRenderer {
2    static let maxFramesInFlight = 3
3    private let inflightSemaphore = DispatchSemaphore(value: maxFramesInFlight)
4    private var uniformBuffers: [MTLBuffer] = []
5    private var currentBufferIndex = 0
6 
7    init(device: MTLDevice) {
8        // 3 ayrı uniform buffer oluştur
9        for _ in 0..<Self.maxFramesInFlight {
10            let buffer = device.makeBuffer(
11                length: MemoryLayout<Uniforms>.stride,
12                options: .storageModeShared
13            )!
14            uniformBuffers.append(buffer)
15        }
16    }
17 
18    func draw(in view: MTKView) {
19        // Semaphore ile GPU'nun bitirmesini bekle
20        inflightSemaphore.wait()
21 
22        // Mevcut buffer'ı güncelle (CPU yazıyor)
23        let buffer = uniformBuffers[currentBufferIndex]
24        let uniforms = buffer.contents().bindMemory(to: Uniforms.self, capacity: 1)
25        uniforms.pointee.modelMatrix = calculateModelMatrix()
26        uniforms.pointee.viewProjection = camera.viewProjectionMatrix
27        uniforms.pointee.time = Float(CACurrentMediaTime())
28 
29        guard let commandBuffer = commandQueue.makeCommandBuffer() else { return }
30 
31        // GPU bitince semaphore'u serbest bırak
32        commandBuffer.addCompletedHandler { [weak self] _ in
33            self?.inflightSemaphore.signal()
34        }
35 
36        // Render pass
37        guard let descriptor = view.currentRenderPassDescriptor,
38              let encoder = commandBuffer.makeRenderCommandEncoder(descriptor: descriptor) else { return }
39 
40        encoder.setRenderPipelineState(pipelineState)
41        encoder.setVertexBuffer(buffer, offset: 0, index: 1)
42        encoder.drawIndexedPrimitives(
43            type: .triangle,
44            indexCount: mesh.indexCount,
45            indexType: .uint16,
46            indexBuffer: mesh.indexBuffer,
47            indexBufferOffset: 0
48        )
49        encoder.endEncoding()
50 
51        commandBuffer.present(view.currentDrawable!)
52        commandBuffer.commit()
53 
54        // Sonraki buffer'a geç
55        currentBufferIndex = (currentBufferIndex + 1) % Self.maxFramesInFlight
56    }
57}
58 
59struct Uniforms {
60    var modelMatrix: float4x4
61    var viewProjection: float4x4
62    var time: Float
63    var padding: Float = 0 // 16-byte alignment
64}

1// Indirect Command Buffer oluştur
2func createIndirectCommandBuffer(device: MTLDevice, maxCommands: Int) -> MTLIndirectCommandBuffer {
3    let descriptor = MTLIndirectCommandBufferDescriptor()
4    descriptor.commandTypes = [.draw, .drawIndexed]
5    descriptor.inheritPipelineState = true
6    descriptor.inheritBuffers = false
7    descriptor.maxVertexBufferBindCount = 3
8    descriptor.maxFragmentBufferBindCount = 2
9 
10    return device.makeIndirectCommandBuffer(
11        descriptor: descriptor,
12        maxCommandCount: maxCommands,
13        options: .storageModeShared
14    )!
15}
16 
17// Compute shader ile draw komutlarını GPU'da üret
18// Bu, CPU'da binlerce draw call göndermekten çok daha hızlı

1// IndirectCommands.metal - GPU'da frustum culling + draw call
2kernel void encode_draw_commands(
3    device DrawCommand* drawCommands [[buffer(0)]],
4    device MeshData* meshes [[buffer(1)]],
5    constant CameraData& camera [[buffer(2)]],
6    device command_buffer icb [[buffer(3)]],
7    uint tid [[thread_position_in_grid]]
8) {
9    MeshData mesh = meshes[tid];
10 
11    // GPU'da frustum culling yap
12    if (is_visible(mesh.boundingSphere, camera.frustumPlanes)) {
13        // Görünür mesh için draw komutu ekle
14        render_command cmd(icb, tid);
15        cmd.set_vertex_buffer(meshes, 1);
16        cmd.draw_indexed_primitives(
17            primitive_type::triangle,
18            mesh.indexCount,
19            mesh.indexBuffer,
20            mesh.indexBufferOffset
21        );
22    }
23}