Hello, Triangle! (MetalKit + Swift 4)

minimal-metal.swift

import Cocoa
import MetalKit

@NSApplicationMain
class AppDelegate: NSObject, NSApplicationDelegate, MTKViewDelegate {
    weak var window: NSWindow!
    weak var metalView: MTKView!
    let device = MTLCreateSystemDefaultDevice()!
    var commandQueue: MTLCommandQueue!
    var pipelineState: MTLRenderPipelineState!
    
    func applicationDidFinishLaunching(_ aNotification: Notification) {
        metalView = MTKView(frame: NSRect(origin: CGPoint.zero, size: window.frame.size), device: device)
        metalView.delegate = self
        window.contentView = metalView
        commandQueue = device.makeCommandQueue()
        let shaders = """
        #include <metal_stdlib>
        using namespace metal;
        struct VertexIn {
            packed_float3 position;
            packed_float3 color;
        };
        struct VertexOut {
            float4 position [[position]];
            float4 color;
        };
        vertex VertexOut vertex_main(device const VertexIn *vertices [[buffer(0)]],
                                     uint vertexId [[vertex_id]]) {
            VertexOut out;
            out.position = float4(vertices[vertexId].position, 1);
            out.color = float4(vertices[vertexId].color, 1);
            return out;
        }
        fragment float4 fragment_main(VertexOut in [[stage_in]]) {
            return in.color;
        }
        """
        do {
            let library = try device.makeLibrary(source: shaders, options: nil)
            let pipelineDescriptor = MTLRenderPipelineDescriptor()
            pipelineDescriptor.colorAttachments[0].pixelFormat = metalView.colorPixelFormat
            pipelineDescriptor.vertexFunction = library.makeFunction(name: "vertex_main")
            pipelineDescriptor.fragmentFunction = library.makeFunction(name: "fragment_main")
            pipelineState = try device.makeRenderPipelineState(descriptor: pipelineDescriptor)
        } catch {}
    }
    
    func mtkView(_ view: MTKView, drawableSizeWillChange size: CGSize) {
    }
 
    func draw(in view: MTKView) {
        guard let commandBuffer = commandQueue.makeCommandBuffer() else { return }
        guard let passDescriptor = view.currentRenderPassDescriptor else { return }
        guard let encoder = commandBuffer.makeRenderCommandEncoder(descriptor: passDescriptor) else { return }
        let vertexData: [Float] = [ -0.5, -0.5, 0, 1, 0, 0,
                                     0.5, -0.5, 0, 0, 1, 0,
                                       0,  0.5, 0, 0, 0, 1 ]
        encoder.setVertexBytes(vertexData, length: vertexData.count * MemoryLayout<Float>.stride, index: 0)
        encoder.setRenderPipelineState(pipelineState)
        encoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 3)
        encoder.endEncoding()
        commandBuffer.present(view.currentDrawable!)
        commandBuffer.commit()
    }
}