aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/renderer/metal
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-04-04 19:22:04 +0300
committerCan Celik <ogulcancelik@gmail.com>2026-04-05 01:23:06 +0300
commit41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch)
tree3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/src/renderer/metal
parent55c138263e190a1e79d4b997bfb9397306c0ec1f (diff)
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/src/renderer/metal')
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/Frame.zig131
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/IOSurfaceLayer.zig183
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/Pipeline.zig204
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/RenderPass.zig229
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/Sampler.zig64
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/Target.zig108
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/Texture.zig202
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/api.zig452
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/buffer.zig185
-rw-r--r--vendor/libghostty-vt/src/renderer/metal/shaders.zig454
10 files changed, 2212 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/renderer/metal/Frame.zig b/vendor/libghostty-vt/src/renderer/metal/Frame.zig
new file mode 100644
index 00000000..388b4f9e
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/Frame.zig
@@ -0,0 +1,131 @@
+//! Wrapper for handling render passes.
+const Self = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const objc = @import("objc");
+
+const mtl = @import("api.zig");
+const Renderer = @import("../generic.zig").Renderer(Metal);
+const Metal = @import("../Metal.zig");
+const Target = @import("Target.zig");
+const RenderPass = @import("RenderPass.zig");
+
+const Health = @import("../../renderer.zig").Health;
+
+const log = std.log.scoped(.metal);
+
+/// Options for beginning a frame.
+pub const Options = struct {
+ /// MTLCommandQueue
+ queue: objc.Object,
+};
+
+/// MTLCommandBuffer
+buffer: objc.Object,
+
+block: CompletionBlock.Context,
+
+/// Begin encoding a frame.
+pub fn begin(
+ opts: Options,
+ /// Once the frame has been completed, the `frameCompleted` method
+ /// on the renderer is called with the health status of the frame.
+ renderer: *Renderer,
+ /// The target is presented via the provided renderer's API when completed.
+ target: *Target,
+) !Self {
+ const buffer = opts.queue.msgSend(
+ objc.Object,
+ objc.sel("commandBuffer"),
+ .{},
+ );
+
+ // Create our block to register for completion updates.
+ // The block is deallocated by the objC runtime on success.
+ const block = CompletionBlock.init(
+ .{
+ .renderer = renderer,
+ .target = target,
+ .sync = false,
+ },
+ &bufferCompleted,
+ );
+
+ return .{ .buffer = buffer, .block = block };
+}
+
+/// This is the block type used for the addCompletedHandler callback.
+const CompletionBlock = objc.Block(struct {
+ renderer: *Renderer,
+ target: *Target,
+ sync: bool,
+}, .{
+ objc.c.id, // MTLCommandBuffer
+}, void);
+
+fn bufferCompleted(
+ block: *const CompletionBlock.Context,
+ buffer_id: objc.c.id,
+) callconv(.c) void {
+ const buffer = objc.Object.fromId(buffer_id);
+
+ // Get our command buffer status to pass back to the generic renderer.
+ const status = buffer.getProperty(mtl.MTLCommandBufferStatus, "status");
+ const health: Health = switch (status) {
+ .@"error" => .unhealthy,
+ else => .healthy,
+ };
+
+ // If the frame is healthy, present it.
+ if (health == .healthy) {
+ block.renderer.api.present(
+ block.target.*,
+ block.sync,
+ ) catch |err| {
+ log.err("Failed to present render target: err={}", .{err});
+ };
+ }
+
+ block.renderer.frameCompleted(health);
+}
+
+/// Add a render pass to this frame with the provided attachments.
+/// Returns a RenderPass which allows render steps to be added.
+pub inline fn renderPass(
+ self: *const Self,
+ attachments: []const RenderPass.Options.Attachment,
+) RenderPass {
+ return RenderPass.begin(.{
+ .attachments = attachments,
+ .command_buffer = self.buffer,
+ });
+}
+
+/// Complete this frame and present the target.
+///
+/// If `sync` is true, this will block until the frame is presented.
+pub inline fn complete(self: *Self, sync: bool) void {
+ // If we don't need to complete synchronously,
+ // we add our block as a completion handler.
+ //
+ // It will be copied when we add the handler, and then the
+ // copy will be deallocated by the objc runtime on success.
+ if (!sync) {
+ self.buffer.msgSend(
+ void,
+ objc.sel("addCompletedHandler:"),
+ .{&self.block},
+ );
+ }
+
+ self.buffer.msgSend(void, objc.sel("commit"), .{});
+
+ // If we need to complete synchronously, we wait until
+ // the buffer is completed and invoke the block directly.
+ if (sync) {
+ self.buffer.msgSend(void, "waitUntilCompleted", .{});
+ self.block.sync = true;
+ CompletionBlock.invoke(&self.block, .{self.buffer.value});
+ }
+}
diff --git a/vendor/libghostty-vt/src/renderer/metal/IOSurfaceLayer.zig b/vendor/libghostty-vt/src/renderer/metal/IOSurfaceLayer.zig
new file mode 100644
index 00000000..34fbfbed
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/IOSurfaceLayer.zig
@@ -0,0 +1,183 @@
+//! A wrapper around a CALayer with a utility method
+//! for settings its `contents` to an IOSurface.
+const IOSurfaceLayer = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const objc = @import("objc");
+const macos = @import("macos");
+
+const IOSurface = macos.iosurface.IOSurface;
+
+const log = std.log.scoped(.IOSurfaceLayer);
+
+/// We subclass CALayer with a custom display handler, we only need
+/// to make the subclass once, and then we can use it as a singleton.
+var Subclass: ?objc.Class = null;
+
+/// The underlying CALayer
+layer: objc.Object,
+
+pub fn init() !IOSurfaceLayer {
+ // The layer returned by `[CALayer layer]` is autoreleased, which means
+ // that at the end of the current autorelease pool it will be deallocated
+ // if it isn't retained, so we retain it here manually an extra time.
+ const layer = (try getSubclass()).msgSend(
+ objc.Object,
+ objc.sel("layer"),
+ .{},
+ ).retain();
+ errdefer layer.release();
+
+ // The layer gravity is set to top-left so that the contents aren't
+ // stretched during resize operations before a new frame has been drawn.
+ layer.setProperty("contentsGravity", macos.animation.kCAGravityTopLeft);
+
+ layer.setInstanceVariable("display_cb", .{ .value = null });
+ layer.setInstanceVariable("display_ctx", .{ .value = null });
+
+ return .{ .layer = layer };
+}
+
+pub fn release(self: *IOSurfaceLayer) void {
+ self.layer.release();
+}
+
+/// Sets the layer's `contents` to the provided IOSurface.
+///
+/// Makes sure to do so on the main thread to avoid visual artifacts.
+pub inline fn setSurface(self: *IOSurfaceLayer, surface: *IOSurface) !void {
+ // We retain the surface to make sure it's not GC'd
+ // before we can set it as the contents of the layer.
+ //
+ // We release in the callback after setting the contents.
+ surface.retain();
+ // NOTE: Since `self.layer` is passed as an `objc.c.id`, it's
+ // automatically retained when the block is copied, so we
+ // don't need to retain it ourselves like with the surface.
+
+ var block = SetSurfaceBlock.init(.{
+ .layer = self.layer.value,
+ .surface = surface,
+ }, &setSurfaceCallback);
+
+ // We check if we're on the main thread and run the block directly if so.
+ const NSThread = objc.getClass("NSThread").?;
+ if (NSThread.msgSend(bool, "isMainThread", .{})) {
+ setSurfaceCallback(&block);
+ } else {
+ // NOTE: The block will be copied when we pass it to dispatch_async,
+ // and then automatically be deallocated by the objc runtime
+ // once it's executed.
+
+ macos.dispatch.dispatch_async(
+ @ptrCast(macos.dispatch.queue.getMain()),
+ @ptrCast(&block),
+ );
+ }
+}
+
+/// Sets the layer's `contents` to the provided IOSurface.
+///
+/// Does not ensure this happens on the main thread.
+pub inline fn setSurfaceSync(self: *IOSurfaceLayer, surface: *IOSurface) void {
+ self.layer.setProperty("contents", surface);
+}
+
+const SetSurfaceBlock = objc.Block(struct {
+ layer: objc.c.id,
+ surface: *IOSurface,
+}, .{}, void);
+
+fn setSurfaceCallback(
+ block: *const SetSurfaceBlock.Context,
+) callconv(.c) void {
+ const layer = objc.Object.fromId(block.layer);
+ const surface: *IOSurface = block.surface;
+
+ // See explanation of why we retain and release in `setSurface`.
+ defer surface.release();
+
+ // We check to see if the surface is the appropriate size for
+ // the layer, if it's not then we discard it. This is because
+ // asynchronously drawn frames can sometimes finish just after
+ // a synchronously drawn frame during a resize, and if we don't
+ // discard the improperly sized surface it creates jank.
+ const bounds = layer.getProperty(macos.graphics.Rect, "bounds");
+ const scale = layer.getProperty(f64, "contentsScale");
+ const width: usize = @intFromFloat(bounds.size.width * scale);
+ const height: usize = @intFromFloat(bounds.size.height * scale);
+ if (width != surface.getWidth() or height != surface.getHeight()) {
+ log.debug(
+ "setSurfaceCallback(): surface is wrong size for layer, discarding. surface = {d}x{d}, layer = {d}x{d}",
+ .{ surface.getWidth(), surface.getHeight(), width, height },
+ );
+ return;
+ }
+
+ layer.setProperty("contents", surface);
+}
+
+pub const DisplayCallback = ?*align(8) const fn (?*anyopaque) void;
+
+pub fn setDisplayCallback(
+ self: *IOSurfaceLayer,
+ display_cb: DisplayCallback,
+ display_ctx: ?*anyopaque,
+) void {
+ self.layer.setInstanceVariable(
+ "display_cb",
+ objc.Object.fromId(@constCast(display_cb)),
+ );
+ self.layer.setInstanceVariable(
+ "display_ctx",
+ objc.Object.fromId(display_ctx),
+ );
+}
+
+fn getSubclass() error{ObjCFailed}!objc.Class {
+ if (Subclass) |c| return c;
+
+ const CALayer =
+ objc.getClass("CALayer") orelse return error.ObjCFailed;
+
+ var subclass =
+ objc.allocateClassPair(CALayer, "IOSurfaceLayer") orelse return error.ObjCFailed;
+ errdefer objc.disposeClassPair(subclass);
+
+ if (!subclass.addIvar("display_cb")) return error.ObjCFailed;
+ if (!subclass.addIvar("display_ctx")) return error.ObjCFailed;
+
+ subclass.replaceMethod("display", struct {
+ fn display(target: objc.c.id, sel: objc.c.SEL) callconv(.c) void {
+ _ = sel;
+ const self = objc.Object.fromId(target);
+ const display_cb: DisplayCallback = @ptrFromInt(@intFromPtr(
+ self.getInstanceVariable("display_cb").value,
+ ));
+ if (display_cb) |cb| cb(
+ @ptrCast(self.getInstanceVariable("display_ctx").value),
+ );
+ }
+ }.display);
+
+ // Disable all animations for this layer by returning null for all actions.
+ subclass.replaceMethod("actionForKey:", struct {
+ fn actionForKey(
+ target: objc.c.id,
+ sel: objc.c.SEL,
+ key: objc.c.id,
+ ) callconv(.c) objc.c.id {
+ _ = target;
+ _ = sel;
+ _ = key;
+ return objc.getClass("NSNull").?.msgSend(objc.c.id, "null", .{});
+ }
+ }.actionForKey);
+
+ objc.registerClassPair(subclass);
+
+ Subclass = subclass;
+
+ return subclass;
+}
diff --git a/vendor/libghostty-vt/src/renderer/metal/Pipeline.zig b/vendor/libghostty-vt/src/renderer/metal/Pipeline.zig
new file mode 100644
index 00000000..9ba25c35
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/Pipeline.zig
@@ -0,0 +1,204 @@
+//! Wrapper for handling render pipelines.
+const Self = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const macos = @import("macos");
+const objc = @import("objc");
+
+const mtl = @import("api.zig");
+
+const log = std.log.scoped(.metal);
+
+/// Options for initializing a render pipeline.
+pub const Options = struct {
+ /// MTLDevice
+ device: objc.Object,
+
+ /// Name of the vertex function
+ vertex_fn: []const u8,
+ /// Name of the fragment function
+ fragment_fn: []const u8,
+
+ /// MTLLibrary to get the vertex function from
+ vertex_library: objc.Object,
+ /// MTLLibrary to get the fragment function from
+ fragment_library: objc.Object,
+
+ /// Vertex step function
+ step_fn: mtl.MTLVertexStepFunction = .per_vertex,
+
+ /// Info about the color attachments used by this render pipeline.
+ attachments: []const Attachment,
+
+ /// Describes a color attachment.
+ pub const Attachment = struct {
+ pixel_format: mtl.MTLPixelFormat,
+ blending_enabled: bool = true,
+ };
+};
+
+/// MTLRenderPipelineState
+state: objc.Object,
+
+pub fn init(comptime VertexAttributes: ?type, opts: Options) !Self {
+ // Create our descriptor
+ const desc = init: {
+ const Class = objc.getClass("MTLRenderPipelineDescriptor").?;
+ const id_alloc = Class.msgSend(objc.Object, objc.sel("alloc"), .{});
+ const id_init = id_alloc.msgSend(objc.Object, objc.sel("init"), .{});
+ break :init id_init;
+ };
+ defer desc.msgSend(void, objc.sel("release"), .{});
+
+ // Get our vertex and fragment functions and add them to the descriptor.
+ {
+ const str = try macos.foundation.String.createWithBytes(
+ opts.vertex_fn,
+ .utf8,
+ false,
+ );
+ defer str.release();
+
+ const ptr = opts.vertex_library.msgSend(?*anyopaque, objc.sel("newFunctionWithName:"), .{str});
+ const func_vert = objc.Object.fromId(ptr.?);
+ defer func_vert.msgSend(void, objc.sel("release"), .{});
+
+ desc.setProperty("vertexFunction", func_vert);
+ }
+ {
+ const str = try macos.foundation.String.createWithBytes(
+ opts.fragment_fn,
+ .utf8,
+ false,
+ );
+ defer str.release();
+
+ const ptr = opts.fragment_library.msgSend(?*anyopaque, objc.sel("newFunctionWithName:"), .{str});
+ const func_frag = objc.Object.fromId(ptr.?);
+ defer func_frag.msgSend(void, objc.sel("release"), .{});
+
+ desc.setProperty("fragmentFunction", func_frag);
+ }
+
+ // If we have vertex attributes, create and add a vertex descriptor.
+ if (VertexAttributes) |V| {
+ const vertex_desc = init: {
+ const Class = objc.getClass("MTLVertexDescriptor").?;
+ const id_alloc = Class.msgSend(objc.Object, objc.sel("alloc"), .{});
+ const id_init = id_alloc.msgSend(objc.Object, objc.sel("init"), .{});
+ break :init id_init;
+ };
+ defer vertex_desc.msgSend(void, objc.sel("release"), .{});
+
+ // Our attributes are the fields of the input
+ const attrs = objc.Object.fromId(vertex_desc.getProperty(?*anyopaque, "attributes"));
+ autoAttribute(V, attrs);
+
+ // The layout describes how and when we fetch the next vertex input.
+ const layouts = objc.Object.fromId(vertex_desc.getProperty(?*anyopaque, "layouts"));
+ {
+ const layout = layouts.msgSend(
+ objc.Object,
+ objc.sel("objectAtIndexedSubscript:"),
+ .{@as(c_ulong, 0)},
+ );
+
+ layout.setProperty("stepFunction", @intFromEnum(opts.step_fn));
+ layout.setProperty("stride", @as(c_ulong, @sizeOf(V)));
+ }
+
+ desc.setProperty("vertexDescriptor", vertex_desc);
+ }
+
+ // Set our color attachment
+ const attachments = objc.Object.fromId(desc.getProperty(?*anyopaque, "colorAttachments"));
+ for (opts.attachments, 0..) |at, i| {
+ const attachment = attachments.msgSend(
+ objc.Object,
+ objc.sel("objectAtIndexedSubscript:"),
+ .{@as(c_ulong, i)},
+ );
+
+ attachment.setProperty("pixelFormat", @intFromEnum(at.pixel_format));
+
+ attachment.setProperty("blendingEnabled", at.blending_enabled);
+ // We always use premultiplied alpha blending for now.
+ if (at.blending_enabled) {
+ attachment.setProperty("rgbBlendOperation", @intFromEnum(mtl.MTLBlendOperation.add));
+ attachment.setProperty("alphaBlendOperation", @intFromEnum(mtl.MTLBlendOperation.add));
+ attachment.setProperty("sourceRGBBlendFactor", @intFromEnum(mtl.MTLBlendFactor.one));
+ attachment.setProperty("sourceAlphaBlendFactor", @intFromEnum(mtl.MTLBlendFactor.one));
+ attachment.setProperty("destinationRGBBlendFactor", @intFromEnum(mtl.MTLBlendFactor.one_minus_source_alpha));
+ attachment.setProperty("destinationAlphaBlendFactor", @intFromEnum(mtl.MTLBlendFactor.one_minus_source_alpha));
+ }
+ }
+
+ // Make our state
+ var err: ?*anyopaque = null;
+ const pipeline_state = opts.device.msgSend(
+ objc.Object,
+ objc.sel("newRenderPipelineStateWithDescriptor:error:"),
+ .{ desc, &err },
+ );
+ try checkError(err);
+ errdefer pipeline_state.release();
+
+ return .{ .state = pipeline_state };
+}
+
+pub fn deinit(self: *const Self) void {
+ self.state.release();
+}
+
+fn autoAttribute(T: type, attrs: objc.Object) void {
+ inline for (@typeInfo(T).@"struct".fields, 0..) |field, i| {
+ const offset = @offsetOf(T, field.name);
+
+ const FT = switch (@typeInfo(field.type)) {
+ .@"struct" => |e| e.backing_integer.?,
+ .@"enum" => |e| e.tag_type,
+ else => field.type,
+ };
+
+ // Very incomplete list, expand as necessary.
+ const format = switch (FT) {
+ [4]u8 => mtl.MTLVertexFormat.uchar4,
+ [2]u16 => mtl.MTLVertexFormat.ushort2,
+ [2]i16 => mtl.MTLVertexFormat.short2,
+ f32 => mtl.MTLVertexFormat.float,
+ [2]f32 => mtl.MTLVertexFormat.float2,
+ [4]f32 => mtl.MTLVertexFormat.float4,
+ i32 => mtl.MTLVertexFormat.int,
+ [2]i32 => mtl.MTLVertexFormat.int2,
+ [4]i32 => mtl.MTLVertexFormat.int2,
+ u32 => mtl.MTLVertexFormat.uint,
+ [2]u32 => mtl.MTLVertexFormat.uint2,
+ [4]u32 => mtl.MTLVertexFormat.uint4,
+ u8 => mtl.MTLVertexFormat.uchar,
+ i8 => mtl.MTLVertexFormat.char,
+ else => comptime unreachable,
+ };
+
+ const attr = attrs.msgSend(
+ objc.Object,
+ objc.sel("objectAtIndexedSubscript:"),
+ .{@as(c_ulong, i)},
+ );
+
+ attr.setProperty("format", @intFromEnum(format));
+ attr.setProperty("offset", @as(c_ulong, offset));
+ attr.setProperty("bufferIndex", @as(c_ulong, 0));
+ }
+}
+
+fn checkError(err_: ?*anyopaque) !void {
+ const nserr = objc.Object.fromId(err_ orelse return);
+ const str = @as(
+ *macos.foundation.String,
+ @ptrCast(nserr.getProperty(?*anyopaque, "localizedDescription").?),
+ );
+
+ log.err("metal error={s}", .{str.cstringPtr(.ascii).?});
+ return error.MetalFailed;
+}
diff --git a/vendor/libghostty-vt/src/renderer/metal/RenderPass.zig b/vendor/libghostty-vt/src/renderer/metal/RenderPass.zig
new file mode 100644
index 00000000..f204e177
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/RenderPass.zig
@@ -0,0 +1,229 @@
+//! Wrapper for handling render passes.
+const Self = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const objc = @import("objc");
+
+const mtl = @import("api.zig");
+const Pipeline = @import("Pipeline.zig");
+const Sampler = @import("Sampler.zig");
+const Texture = @import("Texture.zig");
+const Target = @import("Target.zig");
+
+const log = std.log.scoped(.metal);
+
+/// Options for beginning a render pass.
+pub const Options = struct {
+ /// MTLCommandBuffer
+ command_buffer: objc.Object,
+ /// Color attachments for this render pass.
+ attachments: []const Attachment,
+
+ /// Describes a color attachment.
+ pub const Attachment = struct {
+ target: union(enum) {
+ texture: Texture,
+ target: Target,
+ },
+ clear_color: ?[4]f64 = null,
+ };
+};
+
+/// Describes a step in a render pass.
+pub const Step = struct {
+ pipeline: Pipeline,
+ /// MTLBuffer
+ uniforms: ?objc.Object = null,
+ /// MTLBuffer
+ buffers: []const ?objc.Object = &.{},
+ textures: []const ?Texture = &.{},
+ /// Set of samplers to use for this step. The index maps to an index
+ /// of a fragment texture, set via setFragmentSamplerState(_:index:).
+ samplers: []const ?Sampler = &.{},
+ draw: Draw,
+
+ /// Describes the draw call for this step.
+ pub const Draw = struct {
+ type: mtl.MTLPrimitiveType,
+ vertex_count: usize,
+ instance_count: usize = 1,
+ };
+};
+
+/// MTLRenderCommandEncoder
+encoder: objc.Object,
+
+/// Begin a render pass.
+pub fn begin(
+ opts: Options,
+) Self {
+ // Create a pass descriptor
+ const desc = desc: {
+ const MTLRenderPassDescriptor = objc.getClass("MTLRenderPassDescriptor").?;
+ const desc = MTLRenderPassDescriptor.msgSend(
+ objc.Object,
+ objc.sel("renderPassDescriptor"),
+ .{},
+ );
+
+ // Set our color attachment to be our drawable surface.
+ const attachments = objc.Object.fromId(
+ desc.getProperty(?*anyopaque, "colorAttachments"),
+ );
+ for (opts.attachments, 0..) |at, i| {
+ const attachment = attachments.msgSend(
+ objc.Object,
+ objc.sel("objectAtIndexedSubscript:"),
+ .{@as(c_ulong, i)},
+ );
+
+ attachment.setProperty(
+ "loadAction",
+ @intFromEnum(@as(
+ mtl.MTLLoadAction,
+ if (at.clear_color != null)
+ .clear
+ else
+ .load,
+ )),
+ );
+ attachment.setProperty(
+ "storeAction",
+ @intFromEnum(mtl.MTLStoreAction.store),
+ );
+ attachment.setProperty("texture", switch (at.target) {
+ .texture => |t| t.texture.value,
+ .target => |t| t.texture.value,
+ });
+ if (at.clear_color) |c| attachment.setProperty(
+ "clearColor",
+ mtl.MTLClearColor{
+ .red = c[0],
+ .green = c[1],
+ .blue = c[2],
+ .alpha = c[3],
+ },
+ );
+ }
+
+ break :desc desc;
+ };
+
+ // MTLRenderCommandEncoder
+ const encoder = opts.command_buffer.msgSend(
+ objc.Object,
+ objc.sel("renderCommandEncoderWithDescriptor:"),
+ .{desc.value},
+ );
+
+ return .{ .encoder = encoder };
+}
+
+/// Add a step to this render pass.
+pub fn step(self: *const Self, s: Step) void {
+ if (s.draw.instance_count == 0) return;
+
+ // Set pipeline state
+ self.encoder.msgSend(
+ void,
+ objc.sel("setRenderPipelineState:"),
+ .{s.pipeline.state.value},
+ );
+
+ if (s.buffers.len > 0) {
+ // We reserve index 0 for the vertex buffer, this isn't very
+ // flexible but it lines up with the API we have for OpenGL.
+ if (s.buffers[0]) |buf| {
+ self.encoder.msgSend(
+ void,
+ objc.sel("setVertexBuffer:offset:atIndex:"),
+ .{ buf.value, @as(c_ulong, 0), @as(c_ulong, 0) },
+ );
+ self.encoder.msgSend(
+ void,
+ objc.sel("setFragmentBuffer:offset:atIndex:"),
+ .{ buf.value, @as(c_ulong, 0), @as(c_ulong, 0) },
+ );
+ }
+
+ // Set the rest of the buffers starting at index 2, this is
+ // so that we can use index 1 for the uniforms if present.
+ //
+ // Also, we set buffers (and textures) for both stages.
+ //
+ // Again, not very flexible, but it's consistent and predictable,
+ // and we need to treat the uniforms as special because of OpenGL.
+ //
+ // TODO: Maybe in the future add info to the pipeline struct which
+ // allows it to define a mapping between provided buffers and
+ // what index they get set at for the vertex / fragment stage.
+ for (s.buffers[1..], 2..) |b, i| if (b) |buf| {
+ self.encoder.msgSend(
+ void,
+ objc.sel("setVertexBuffer:offset:atIndex:"),
+ .{ buf.value, @as(c_ulong, 0), @as(c_ulong, i) },
+ );
+ self.encoder.msgSend(
+ void,
+ objc.sel("setFragmentBuffer:offset:atIndex:"),
+ .{ buf.value, @as(c_ulong, 0), @as(c_ulong, i) },
+ );
+ };
+ }
+
+ // Set the uniforms as buffer index 1 if present.
+ if (s.uniforms) |buf| {
+ self.encoder.msgSend(
+ void,
+ objc.sel("setVertexBuffer:offset:atIndex:"),
+ .{ buf.value, @as(c_ulong, 0), @as(c_ulong, 1) },
+ );
+ self.encoder.msgSend(
+ void,
+ objc.sel("setFragmentBuffer:offset:atIndex:"),
+ .{ buf.value, @as(c_ulong, 0), @as(c_ulong, 1) },
+ );
+ }
+
+ // Set textures.
+ for (s.textures, 0..) |t, i| if (t) |tex| {
+ self.encoder.msgSend(
+ void,
+ objc.sel("setVertexTexture:atIndex:"),
+ .{ tex.texture.value, @as(c_ulong, i) },
+ );
+ self.encoder.msgSend(
+ void,
+ objc.sel("setFragmentTexture:atIndex:"),
+ .{ tex.texture.value, @as(c_ulong, i) },
+ );
+ };
+
+ // Set samplers.
+ for (s.samplers, 0..) |samp, i| if (samp) |sampler| {
+ self.encoder.msgSend(
+ void,
+ objc.sel("setFragmentSamplerState:atIndex:"),
+ .{ sampler.sampler.value, @as(c_ulong, i) },
+ );
+ };
+
+ // Draw!
+ self.encoder.msgSend(
+ void,
+ objc.sel("drawPrimitives:vertexStart:vertexCount:instanceCount:"),
+ .{
+ @intFromEnum(s.draw.type),
+ @as(c_ulong, 0),
+ @as(c_ulong, s.draw.vertex_count),
+ @as(c_ulong, s.draw.instance_count),
+ },
+ );
+}
+
+/// Complete this render pass.
+/// This struct can no longer be used after calling this.
+pub fn complete(self: *const Self) void {
+ self.encoder.msgSend(void, objc.sel("endEncoding"), .{});
+}
diff --git a/vendor/libghostty-vt/src/renderer/metal/Sampler.zig b/vendor/libghostty-vt/src/renderer/metal/Sampler.zig
new file mode 100644
index 00000000..593f9a86
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/Sampler.zig
@@ -0,0 +1,64 @@
+//! Wrapper for handling samplers.
+const Self = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const objc = @import("objc");
+
+const mtl = @import("api.zig");
+const Metal = @import("../Metal.zig");
+
+const log = std.log.scoped(.metal);
+
+/// Options for initializing a sampler.
+pub const Options = struct {
+ /// MTLDevice
+ device: objc.Object,
+ min_filter: mtl.MTLSamplerMinMagFilter,
+ mag_filter: mtl.MTLSamplerMinMagFilter,
+ s_address_mode: mtl.MTLSamplerAddressMode,
+ t_address_mode: mtl.MTLSamplerAddressMode,
+};
+
+/// The underlying MTLSamplerState Object.
+sampler: objc.Object,
+
+pub const Error = error{
+ /// A Metal API call failed.
+ MetalFailed,
+};
+
+/// Initialize a sampler
+pub fn init(
+ opts: Options,
+) Error!Self {
+ // Create our descriptor
+ const desc = init: {
+ const Class = objc.getClass("MTLSamplerDescriptor").?;
+ const id_alloc = Class.msgSend(objc.Object, objc.sel("alloc"), .{});
+ const id_init = id_alloc.msgSend(objc.Object, objc.sel("init"), .{});
+ break :init id_init;
+ };
+ defer desc.release();
+
+ // Properties
+ desc.setProperty("minFilter", opts.min_filter);
+ desc.setProperty("magFilter", opts.mag_filter);
+ desc.setProperty("sAddressMode", opts.s_address_mode);
+ desc.setProperty("tAddressMode", opts.t_address_mode);
+
+ // Create the sampler state
+ const id = opts.device.msgSend(
+ ?*anyopaque,
+ objc.sel("newSamplerStateWithDescriptor:"),
+ .{desc},
+ ) orelse return error.MetalFailed;
+
+ return .{
+ .sampler = objc.Object.fromId(id),
+ };
+}
+
+pub fn deinit(self: Self) void {
+ self.sampler.release();
+}
diff --git a/vendor/libghostty-vt/src/renderer/metal/Target.zig b/vendor/libghostty-vt/src/renderer/metal/Target.zig
new file mode 100644
index 00000000..f20bb0b7
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/Target.zig
@@ -0,0 +1,108 @@
+//! Represents a render target.
+//!
+//! In this case, an IOSurface-backed MTLTexture.
+const Self = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const objc = @import("objc");
+const macos = @import("macos");
+const graphics = macos.graphics;
+const IOSurface = macos.iosurface.IOSurface;
+
+const mtl = @import("api.zig");
+
+const log = std.log.scoped(.metal);
+
+/// Options for initializing a Target
+pub const Options = struct {
+ /// MTLDevice
+ device: objc.Object,
+
+ /// Desired width
+ width: usize,
+ /// Desired height
+ height: usize,
+
+ /// Pixel format for the MTLTexture
+ pixel_format: mtl.MTLPixelFormat,
+ /// Storage mode for the MTLTexture
+ storage_mode: mtl.MTLResourceOptions.StorageMode,
+};
+
+/// The underlying IOSurface.
+surface: *IOSurface,
+
+/// The underlying MTLTexture.
+texture: objc.Object,
+
+/// Current width of this target.
+width: usize,
+/// Current height of this target.
+height: usize,
+
+pub fn init(opts: Options) !Self {
+ // We set our surface's color space to Display P3.
+ // This allows us to have "Apple-style" alpha blending,
+ // since it seems to be the case that Apple apps like
+ // Terminal and TextEdit render text in the display's
+ // color space using converted colors, which reduces,
+ // but does not fully eliminate blending artifacts.
+ const colorspace = try graphics.ColorSpace.createNamed(.displayP3);
+ defer colorspace.release();
+
+ const surface = try IOSurface.init(.{
+ .width = @intCast(opts.width),
+ .height = @intCast(opts.height),
+ .pixel_format = .@"32BGRA",
+ .bytes_per_element = 4,
+ .colorspace = colorspace,
+ });
+
+ // Create our descriptor
+ const desc = init: {
+ const Class = objc.getClass("MTLTextureDescriptor").?;
+ const id_alloc = Class.msgSend(objc.Object, objc.sel("alloc"), .{});
+ const id_init = id_alloc.msgSend(objc.Object, objc.sel("init"), .{});
+ break :init id_init;
+ };
+ defer desc.release();
+
+ // Set our properties
+ desc.setProperty("width", @as(c_ulong, @intCast(opts.width)));
+ desc.setProperty("height", @as(c_ulong, @intCast(opts.height)));
+ desc.setProperty("pixelFormat", @intFromEnum(opts.pixel_format));
+ desc.setProperty("usage", mtl.MTLTextureUsage{ .render_target = true });
+ desc.setProperty(
+ "resourceOptions",
+ mtl.MTLResourceOptions{
+ // Indicate that the CPU writes to this resource but never reads it.
+ .cpu_cache_mode = .write_combined,
+ .storage_mode = opts.storage_mode,
+ },
+ );
+
+ const id = opts.device.msgSend(
+ ?*anyopaque,
+ objc.sel("newTextureWithDescriptor:iosurface:plane:"),
+ .{
+ desc,
+ surface,
+ @as(c_ulong, 0),
+ },
+ ) orelse return error.MetalFailed;
+
+ const texture = objc.Object.fromId(id);
+
+ return .{
+ .surface = surface,
+ .texture = texture,
+ .width = opts.width,
+ .height = opts.height,
+ };
+}
+
+pub fn deinit(self: *Self) void {
+ self.surface.deinit();
+ self.texture.release();
+}
diff --git a/vendor/libghostty-vt/src/renderer/metal/Texture.zig b/vendor/libghostty-vt/src/renderer/metal/Texture.zig
new file mode 100644
index 00000000..5042919a
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/Texture.zig
@@ -0,0 +1,202 @@
+//! Wrapper for handling textures.
+const Self = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const assert = @import("../../quirks.zig").inlineAssert;
+const objc = @import("objc");
+
+const mtl = @import("api.zig");
+const Metal = @import("../Metal.zig");
+
+const log = std.log.scoped(.metal);
+
+/// Options for initializing a texture.
+pub const Options = struct {
+ /// MTLDevice
+ device: objc.Object,
+ pixel_format: mtl.MTLPixelFormat,
+ resource_options: mtl.MTLResourceOptions,
+ usage: mtl.MTLTextureUsage,
+};
+
+/// The underlying MTLTexture Object.
+texture: objc.Object,
+
+/// The width of this texture.
+width: usize,
+/// The height of this texture.
+height: usize,
+
+/// Bytes per pixel for this texture.
+bpp: usize,
+
+pub const Error = error{
+ /// A Metal API call failed.
+ MetalFailed,
+};
+
+/// Initialize a texture
+pub fn init(
+ opts: Options,
+ width: usize,
+ height: usize,
+ data: ?[]const u8,
+) Error!Self {
+ // Create our descriptor
+ const desc = init: {
+ const Class = objc.getClass("MTLTextureDescriptor").?;
+ const id_alloc = Class.msgSend(objc.Object, objc.sel("alloc"), .{});
+ const id_init = id_alloc.msgSend(objc.Object, objc.sel("init"), .{});
+ break :init id_init;
+ };
+ defer desc.release();
+
+ // Set our properties
+ desc.setProperty("pixelFormat", @intFromEnum(opts.pixel_format));
+ desc.setProperty("width", @as(c_ulong, width));
+ desc.setProperty("height", @as(c_ulong, height));
+ desc.setProperty("resourceOptions", opts.resource_options);
+ desc.setProperty("usage", opts.usage);
+
+ // Initialize
+ const id = opts.device.msgSend(
+ ?*anyopaque,
+ objc.sel("newTextureWithDescriptor:"),
+ .{desc},
+ ) orelse return error.MetalFailed;
+
+ const self: Self = .{
+ .texture = objc.Object.fromId(id),
+ .width = width,
+ .height = height,
+ .bpp = bppOf(opts.pixel_format),
+ };
+
+ // If we have data, we set it here.
+ if (data) |d| {
+ assert(d.len == width * height * self.bpp);
+ try self.replaceRegion(0, 0, width, height, d);
+ }
+
+ return self;
+}
+
+pub fn deinit(self: Self) void {
+ self.texture.release();
+}
+
+/// Replace a region of the texture with the provided data.
+///
+/// Does NOT check the dimensions of the data to ensure correctness.
+pub fn replaceRegion(
+ self: Self,
+ x: usize,
+ y: usize,
+ width: usize,
+ height: usize,
+ data: []const u8,
+) error{}!void {
+ self.texture.msgSend(
+ void,
+ objc.sel("replaceRegion:mipmapLevel:withBytes:bytesPerRow:"),
+ .{
+ mtl.MTLRegion{
+ .origin = .{ .x = x, .y = y, .z = 0 },
+ .size = .{
+ .width = @intCast(width),
+ .height = @intCast(height),
+ .depth = 1,
+ },
+ },
+ @as(c_ulong, 0),
+ @as(*const anyopaque, data.ptr),
+ @as(c_ulong, self.bpp * width),
+ },
+ );
+}
+
+/// Returns the bytes per pixel for the provided pixel format
+fn bppOf(pixel_format: mtl.MTLPixelFormat) usize {
+ return switch (pixel_format) {
+ // Invalid
+ .invalid => @panic("invalid pixel format"),
+
+ // Weird formats I was too lazy to get the sizes of
+ else => @panic("pixel format size unknown (unlikely that this format was actually used, could be memory corruption)"),
+
+ // 8-bit pixel formats
+ .a8unorm,
+ .r8unorm,
+ .r8unorm_srgb,
+ .r8snorm,
+ .r8uint,
+ .r8sint,
+ .rg8unorm,
+ .rg8unorm_srgb,
+ .rg8snorm,
+ .rg8uint,
+ .rg8sint,
+ .stencil8,
+ => 1,
+
+ // 16-bit pixel formats
+ .r16unorm,
+ .r16snorm,
+ .r16uint,
+ .r16sint,
+ .r16float,
+ .rg16unorm,
+ .rg16snorm,
+ .rg16uint,
+ .rg16sint,
+ .rg16float,
+ .b5g6r5unorm,
+ .a1bgr5unorm,
+ .abgr4unorm,
+ .bgr5a1unorm,
+ .depth16unorm,
+ => 2,
+
+ // 32-bit pixel formats
+ .rgba8unorm,
+ .rgba8unorm_srgb,
+ .rgba8snorm,
+ .rgba8uint,
+ .rgba8sint,
+ .bgra8unorm,
+ .bgra8unorm_srgb,
+ .rgb10a2unorm,
+ .rgb10a2uint,
+ .rg11b10float,
+ .rgb9e5float,
+ .bgr10a2unorm,
+ .bgr10_xr,
+ .bgr10_xr_srgb,
+ .r32uint,
+ .r32sint,
+ .r32float,
+ .depth32float,
+ .depth24unorm_stencil8,
+ => 4,
+
+ // 64-bit pixel formats
+ .rg32uint,
+ .rg32sint,
+ .rg32float,
+ .rgba16unorm,
+ .rgba16snorm,
+ .rgba16uint,
+ .rgba16sint,
+ .rgba16float,
+ .bgra10_xr,
+ .bgra10_xr_srgb,
+ => 8,
+
+ // 128-bit pixel formats,
+ .rgba32uint,
+ .rgba32sint,
+ .rgba32float,
+ => 128,
+ };
+}
diff --git a/vendor/libghostty-vt/src/renderer/metal/api.zig b/vendor/libghostty-vt/src/renderer/metal/api.zig
new file mode 100644
index 00000000..a2d8a135
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/api.zig
@@ -0,0 +1,452 @@
+//! This file contains the definitions of the Metal API that we use.
+//!
+//! Because the online Apple developer docs have recently (as of January 2025)
+//! been changed to hide enum values, `Metal-cpp` has been used as a reference
+//! source instead.
+//!
+//! Ref: https://developer.apple.com/metal/cpp/
+
+/// https://developer.apple.com/documentation/metal/mtlcommandbufferstatus?language=objc
+pub const MTLCommandBufferStatus = enum(c_ulong) {
+ not_enqueued = 0,
+ enqueued = 1,
+ committed = 2,
+ scheduled = 3,
+ completed = 4,
+ @"error" = 5,
+ _,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlloadaction?language=objc
+pub const MTLLoadAction = enum(c_ulong) {
+ dont_care = 0,
+ load = 1,
+ clear = 2,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlstoreaction?language=objc
+pub const MTLStoreAction = enum(c_ulong) {
+ dont_care = 0,
+ store = 1,
+ multisample_resolve = 2,
+ store_and_multisample_resolve = 3,
+ unknown = 4,
+ custom_sample_depth_store = 5,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlresourceoptions?language=objc
+pub const MTLResourceOptions = packed struct(c_ulong) {
+ /// https://developer.apple.com/documentation/metal/mtlcpucachemode?language=objc
+ cpu_cache_mode: CPUCacheMode = .default,
+ /// https://developer.apple.com/documentation/metal/mtlstoragemode?language=objc
+ storage_mode: StorageMode,
+ /// https://developer.apple.com/documentation/metal/mtlhazardtrackingmode?language=objc
+ hazard_tracking_mode: HazardTrackingMode = .default,
+
+ _pad: @Type(.{
+ .int = .{ .signedness = .unsigned, .bits = @bitSizeOf(c_ulong) - 10 },
+ }) = 0,
+
+ pub const CPUCacheMode = enum(u4) {
+ default = 0,
+ write_combined = 1,
+ };
+
+ pub const StorageMode = enum(u4) {
+ shared = 0,
+ managed = 1,
+ private = 2,
+ memoryless = 3,
+ };
+
+ pub const HazardTrackingMode = enum(u2) {
+ default = 0,
+ untracked = 1,
+ tracked = 2,
+ };
+};
+
+/// https://developer.apple.com/documentation/metal/mtlprimitivetype?language=objc
+pub const MTLPrimitiveType = enum(c_ulong) {
+ point = 0,
+ line = 1,
+ line_strip = 2,
+ triangle = 3,
+ triangle_strip = 4,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlindextype?language=objc
+pub const MTLIndexType = enum(c_ulong) {
+ uint16 = 0,
+ uint32 = 1,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlvertexformat?language=objc
+pub const MTLVertexFormat = enum(c_ulong) {
+ invalid = 0,
+ uchar2 = 1,
+ uchar3 = 2,
+ uchar4 = 3,
+ char2 = 4,
+ char3 = 5,
+ char4 = 6,
+ uchar2normalized = 7,
+ uchar3normalized = 8,
+ uchar4normalized = 9,
+ char2normalized = 10,
+ char3normalized = 11,
+ char4normalized = 12,
+ ushort2 = 13,
+ ushort3 = 14,
+ ushort4 = 15,
+ short2 = 16,
+ short3 = 17,
+ short4 = 18,
+ ushort2normalized = 19,
+ ushort3normalized = 20,
+ ushort4normalized = 21,
+ short2normalized = 22,
+ short3normalized = 23,
+ short4normalized = 24,
+ half2 = 25,
+ half3 = 26,
+ half4 = 27,
+ float = 28,
+ float2 = 29,
+ float3 = 30,
+ float4 = 31,
+ int = 32,
+ int2 = 33,
+ int3 = 34,
+ int4 = 35,
+ uint = 36,
+ uint2 = 37,
+ uint3 = 38,
+ uint4 = 39,
+ int1010102normalized = 40,
+ uint1010102normalized = 41,
+ uchar4normalized_bgra = 42,
+ uchar = 45,
+ char = 46,
+ ucharnormalized = 47,
+ charnormalized = 48,
+ ushort = 49,
+ short = 50,
+ ushortnormalized = 51,
+ shortnormalized = 52,
+ half = 53,
+ floatrg11b10 = 54,
+ floatrgb9e5 = 55,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlvertexstepfunction?language=objc
+pub const MTLVertexStepFunction = enum(c_ulong) {
+ constant = 0,
+ per_vertex = 1,
+ per_instance = 2,
+ per_patch = 3,
+ per_patch_control_point = 4,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlpixelformat?language=objc
+pub const MTLPixelFormat = enum(c_ulong) {
+ invalid = 0,
+ a8unorm = 1,
+ r8unorm = 10,
+ r8unorm_srgb = 11,
+ r8snorm = 12,
+ r8uint = 13,
+ r8sint = 14,
+ r16unorm = 20,
+ r16snorm = 22,
+ r16uint = 23,
+ r16sint = 24,
+ r16float = 25,
+ rg8unorm = 30,
+ rg8unorm_srgb = 31,
+ rg8snorm = 32,
+ rg8uint = 33,
+ rg8sint = 34,
+ b5g6r5unorm = 40,
+ a1bgr5unorm = 41,
+ abgr4unorm = 42,
+ bgr5a1unorm = 43,
+ r32uint = 53,
+ r32sint = 54,
+ r32float = 55,
+ rg16unorm = 60,
+ rg16snorm = 62,
+ rg16uint = 63,
+ rg16sint = 64,
+ rg16float = 65,
+ rgba8unorm = 70,
+ rgba8unorm_srgb = 71,
+ rgba8snorm = 72,
+ rgba8uint = 73,
+ rgba8sint = 74,
+ bgra8unorm = 80,
+ bgra8unorm_srgb = 81,
+ rgb10a2unorm = 90,
+ rgb10a2uint = 91,
+ rg11b10float = 92,
+ rgb9e5float = 93,
+ bgr10a2unorm = 94,
+ bgr10_xr = 554,
+ bgr10_xr_srgb = 555,
+ rg32uint = 103,
+ rg32sint = 104,
+ rg32float = 105,
+ rgba16unorm = 110,
+ rgba16snorm = 112,
+ rgba16uint = 113,
+ rgba16sint = 114,
+ rgba16float = 115,
+ bgra10_xr = 552,
+ bgra10_xr_srgb = 553,
+ rgba32uint = 123,
+ rgba32sint = 124,
+ rgba32float = 125,
+ bc1_rgba = 130,
+ bc1_rgba_srgb = 131,
+ bc2_rgba = 132,
+ bc2_rgba_srgb = 133,
+ bc3_rgba = 134,
+ bc3_rgba_srgb = 135,
+ bc4_runorm = 140,
+ bc4_rsnorm = 141,
+ bc5_rgunorm = 142,
+ bc5_rgsnorm = 143,
+ bc6h_rgbfloat = 150,
+ bc6h_rgbufloat = 151,
+ bc7_rgbaunorm = 152,
+ bc7_rgbaunorm_srgb = 153,
+ pvrtc_rgb_2bpp = 160,
+ pvrtc_rgb_2bpp_srgb = 161,
+ pvrtc_rgb_4bpp = 162,
+ pvrtc_rgb_4bpp_srgb = 163,
+ pvrtc_rgba_2bpp = 164,
+ pvrtc_rgba_2bpp_srgb = 165,
+ pvrtc_rgba_4bpp = 166,
+ pvrtc_rgba_4bpp_srgb = 167,
+ eac_r11unorm = 170,
+ eac_r11snorm = 172,
+ eac_rg11unorm = 174,
+ eac_rg11snorm = 176,
+ eac_rgba8 = 178,
+ eac_rgba8_srgb = 179,
+ etc2_rgb8 = 180,
+ etc2_rgb8_srgb = 181,
+ etc2_rgb8a1 = 182,
+ etc2_rgb8a1_srgb = 183,
+ astc_4x4_srgb = 186,
+ astc_5x4_srgb = 187,
+ astc_5x5_srgb = 188,
+ astc_6x5_srgb = 189,
+ astc_6x6_srgb = 190,
+ astc_8x5_srgb = 192,
+ astc_8x6_srgb = 193,
+ astc_8x8_srgb = 194,
+ astc_10x5_srgb = 195,
+ astc_10x6_srgb = 196,
+ astc_10x8_srgb = 197,
+ astc_10x10_srgb = 198,
+ astc_12x10_srgb = 199,
+ astc_12x12_srgb = 200,
+ astc_4x4_ldr = 204,
+ astc_5x4_ldr = 205,
+ astc_5x5_ldr = 206,
+ astc_6x5_ldr = 207,
+ astc_6x6_ldr = 208,
+ astc_8x5_ldr = 210,
+ astc_8x6_ldr = 211,
+ astc_8x8_ldr = 212,
+ astc_10x5_ldr = 213,
+ astc_10x6_ldr = 214,
+ astc_10x8_ldr = 215,
+ astc_10x10_ldr = 216,
+ astc_12x10_ldr = 217,
+ astc_12x12_ldr = 218,
+ astc_4x4_hdr = 222,
+ astc_5x4_hdr = 223,
+ astc_5x5_hdr = 224,
+ astc_6x5_hdr = 225,
+ astc_6x6_hdr = 226,
+ astc_8x5_hdr = 228,
+ astc_8x6_hdr = 229,
+ astc_8x8_hdr = 230,
+ astc_10x5_hdr = 231,
+ astc_10x6_hdr = 232,
+ astc_10x8_hdr = 233,
+ astc_10x10_hdr = 234,
+ astc_12x10_hdr = 235,
+ astc_12x12_hdr = 236,
+ gbgr422 = 240,
+ bgrg422 = 241,
+ depth16unorm = 250,
+ depth32float = 252,
+ stencil8 = 253,
+ depth24unorm_stencil8 = 255,
+ depth32float_stencil8 = 260,
+ x32_stencil8 = 261,
+ x24_stencil8 = 262,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlpurgeablestate?language=objc
+pub const MTLPurgeableState = enum(c_ulong) {
+ keep_current = 1,
+ non_volatile = 2,
+ @"volatile" = 3,
+ empty = 4,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlsamplerminmagfilter?language=objc
+pub const MTLSamplerMinMagFilter = enum(c_ulong) {
+ nearest = 0,
+ linear = 1,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlsampleraddressmode?language=objc
+pub const MTLSamplerAddressMode = enum(c_ulong) {
+ clamp_to_edge = 0,
+ mirror_clamp_to_edge = 1,
+ repeat = 2,
+ mirror_repeat = 3,
+ clamp_to_zero = 4,
+ clamp_to_border_color = 5,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlblendfactor?language=objc
+pub const MTLBlendFactor = enum(c_ulong) {
+ zero = 0,
+ one = 1,
+ source_color = 2,
+ one_minus_source_color = 3,
+ source_alpha = 4,
+ one_minus_source_alpha = 5,
+ dest_color = 6,
+ one_minus_dest_color = 7,
+ dest_alpha = 8,
+ one_minus_dest_alpha = 9,
+ source_alpha_saturated = 10,
+ blend_color = 11,
+ one_minus_blend_color = 12,
+ blend_alpha = 13,
+ one_minus_blend_alpha = 14,
+ source_1_color = 15,
+ one_minus_source_1_color = 16,
+ source_1_alpha = 17,
+ one_minus_source_1_alpha = 18,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlblendoperation?language=objc
+pub const MTLBlendOperation = enum(c_ulong) {
+ add = 0,
+ subtract = 1,
+ reverse_subtract = 2,
+ min = 3,
+ max = 4,
+};
+
+/// https://developer.apple.com/documentation/metal/mtltextureusage?language=objc
+pub const MTLTextureUsage = packed struct(c_ulong) {
+ /// https://developer.apple.com/documentation/metal/mtltextureusage/shaderread?language=objc
+ shader_read: bool = false, // TextureUsageShaderRead = 1,
+
+ /// https://developer.apple.com/documentation/metal/mtltextureusage/shaderwrite?language=objc
+ shader_write: bool = false, // TextureUsageShaderWrite = 2,
+
+ /// https://developer.apple.com/documentation/metal/mtltextureusage/rendertarget?language=objc
+ render_target: bool = false, // TextureUsageRenderTarget = 4,
+
+ _reserved: u1 = 0, // The enum skips from 4 to 16, 8 has no documented use.
+
+ /// https://developer.apple.com/documentation/metal/mtltextureusage/pixelformatview?language=objc
+ pixel_format_view: bool = false, // TextureUsagePixelFormatView = 16,
+
+ /// https://developer.apple.com/documentation/metal/mtltextureusage/shaderatomic?language=objc
+ shader_atomic: bool = false, // TextureUsageShaderAtomic = 32,
+
+ __reserved: @Type(.{ .int = .{
+ .signedness = .unsigned,
+ .bits = @bitSizeOf(c_ulong) - 6,
+ } }) = 0,
+
+ /// https://developer.apple.com/documentation/metal/mtltextureusage/unknown?language=objc
+ const unknown: MTLTextureUsage = @bitCast(0); // TextureUsageUnknown = 0,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlbarrierscope?language=objc
+pub const MTLBarrierScope = enum(c_ulong) {
+ buffers = 1,
+ textures = 2,
+ render_targets = 4,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlrenderstages?language=objc
+pub const MTLRenderStage = enum(c_ulong) {
+ vertex = 1,
+ fragment = 2,
+ tile = 4,
+ object = 8,
+ mesh = 16,
+};
+
+/// https://developer.apple.com/documentation/metal/mtlgpufamily?language=objc
+pub const MTLGPUFamily = enum(c_long) {
+ apple1 = 1001,
+ apple2 = 1002,
+ apple3 = 1003,
+ apple4 = 1004,
+ apple5 = 1005,
+ apple6 = 1006,
+ apple7 = 1007,
+ apple8 = 1008,
+ apple9 = 1009,
+ apple10 = 1010,
+
+ common1 = 3001,
+ common2 = 3002,
+ common3 = 3003,
+
+ metal3 = 5001,
+ metal4 = 5002,
+};
+
+pub const MTLClearColor = extern struct {
+ red: f64,
+ green: f64,
+ blue: f64,
+ alpha: f64,
+};
+
+pub const MTLViewport = extern struct {
+ x: f64,
+ y: f64,
+ width: f64,
+ height: f64,
+ znear: f64,
+ zfar: f64,
+};
+
+pub const MTLRegion = extern struct {
+ origin: MTLOrigin,
+ size: MTLSize,
+};
+
+pub const MTLOrigin = extern struct {
+ x: c_ulong,
+ y: c_ulong,
+ z: c_ulong,
+};
+
+pub const MTLSize = extern struct {
+ width: c_ulong,
+ height: c_ulong,
+ depth: c_ulong,
+};
+
+/// https://developer.apple.com/documentation/metal/1433367-mtlcopyalldevices
+pub extern "c" fn MTLCopyAllDevices() ?*anyopaque;
+
+/// https://developer.apple.com/documentation/metal/1433401-mtlcreatesystemdefaultdevice
+pub extern "c" fn MTLCreateSystemDefaultDevice() ?*anyopaque;
diff --git a/vendor/libghostty-vt/src/renderer/metal/buffer.zig b/vendor/libghostty-vt/src/renderer/metal/buffer.zig
new file mode 100644
index 00000000..f91f89e9
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/buffer.zig
@@ -0,0 +1,185 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const objc = @import("objc");
+const macos = @import("macos");
+
+const mtl = @import("api.zig");
+const Metal = @import("../Metal.zig");
+
+const log = std.log.scoped(.metal);
+
+/// Options for initializing a buffer.
+pub const Options = struct {
+ /// MTLDevice
+ device: objc.Object,
+ resource_options: mtl.MTLResourceOptions,
+};
+
+/// Metal data storage for a certain set of equal types. This is usually
+/// used for vertex buffers, etc. This helpful wrapper makes it easy to
+/// prealloc, shrink, grow, sync, buffers with Metal.
+pub fn Buffer(comptime T: type) type {
+ return struct {
+ const Self = @This();
+
+ /// The options this buffer was initialized with.
+ opts: Options,
+
+ /// The underlying MTLBuffer object.
+ buffer: objc.Object,
+
+ /// The allocated length of the buffer.
+ /// Note that this is the number
+ /// of `T`s not the size in bytes.
+ len: usize,
+
+ /// Initialize a buffer with the given length pre-allocated.
+ pub fn init(opts: Options, len: usize) !Self {
+ const buffer = opts.device.msgSend(
+ objc.Object,
+ objc.sel("newBufferWithLength:options:"),
+ .{
+ @as(c_ulong, @intCast(len * @sizeOf(T))),
+ opts.resource_options,
+ },
+ );
+
+ return .{ .buffer = buffer, .opts = opts, .len = len };
+ }
+
+ /// Init the buffer filled with the given data.
+ pub fn initFill(opts: Options, data: []const T) !Self {
+ const buffer = opts.device.msgSend(
+ objc.Object,
+ objc.sel("newBufferWithBytes:length:options:"),
+ .{
+ @as(*const anyopaque, @ptrCast(data.ptr)),
+ @as(c_ulong, @intCast(data.len * @sizeOf(T))),
+ opts.resource_options,
+ },
+ );
+
+ return .{ .buffer = buffer, .opts = opts, .len = data.len };
+ }
+
+ pub fn deinit(self: *const Self) void {
+ self.buffer.msgSend(void, objc.sel("release"), .{});
+ }
+
+ /// Sync new contents to the buffer. The data is expected to be the
+ /// complete contents of the buffer. If the amount of data is larger
+ /// than the buffer length, the buffer will be reallocated.
+ ///
+ /// If the amount of data is smaller than the buffer length, the
+ /// remaining data in the buffer is left untouched.
+ pub fn sync(self: *Self, data: []const T) !void {
+ // If we need more bytes than our buffer has, we need to reallocate.
+ const req_bytes = data.len * @sizeOf(T);
+ const avail_bytes = self.buffer.getProperty(c_ulong, "length");
+ if (req_bytes > avail_bytes) {
+ // Deallocate previous buffer
+ self.buffer.msgSend(void, objc.sel("release"), .{});
+
+ // Allocate a new buffer with enough to hold double what we require.
+ const size = req_bytes * 2;
+ self.buffer = self.opts.device.msgSend(
+ objc.Object,
+ objc.sel("newBufferWithLength:options:"),
+ .{
+ @as(c_ulong, @intCast(size * @sizeOf(T))),
+ self.opts.resource_options,
+ },
+ );
+ }
+
+ // We can fit within the buffer so we can just replace bytes.
+ const dst = dst: {
+ const ptr = self.buffer.msgSend(?[*]u8, objc.sel("contents"), .{}) orelse {
+ log.warn("buffer contents ptr is null", .{});
+ return error.MetalFailed;
+ };
+
+ break :dst ptr[0..req_bytes];
+ };
+
+ const src = src: {
+ const ptr = @as([*]const u8, @ptrCast(data.ptr));
+ break :src ptr[0..req_bytes];
+ };
+
+ @memcpy(dst, src);
+
+ // If we're using the managed resource storage mode, then
+ // we need to signal Metal to synchronize the buffer data.
+ //
+ // Ref: https://developer.apple.com/documentation/metal/synchronizing-a-managed-resource-in-macos?language=objc
+ if (self.opts.resource_options.storage_mode == .managed) {
+ self.buffer.msgSend(
+ void,
+ "didModifyRange:",
+ .{macos.foundation.Range.init(0, req_bytes)},
+ );
+ }
+ }
+
+ /// Like Buffer.sync but takes data from an array of ArrayLists,
+ /// rather than a single array. Returns the number of items synced.
+ pub fn syncFromArrayLists(self: *Self, lists: []const std.ArrayListUnmanaged(T)) !usize {
+ var total_len: usize = 0;
+ for (lists) |list| {
+ total_len += list.items.len;
+ }
+
+ // If we need more bytes than our buffer has, we need to reallocate.
+ const req_bytes = total_len * @sizeOf(T);
+ const avail_bytes = self.buffer.getProperty(c_ulong, "length");
+ if (req_bytes > avail_bytes) {
+ // Deallocate previous buffer
+ self.buffer.msgSend(void, objc.sel("release"), .{});
+
+ // Allocate a new buffer with enough to hold double what we require.
+ const size = req_bytes * 2;
+ self.buffer = self.opts.device.msgSend(
+ objc.Object,
+ objc.sel("newBufferWithLength:options:"),
+ .{
+ @as(c_ulong, @intCast(size * @sizeOf(T))),
+ self.opts.resource_options,
+ },
+ );
+ }
+
+ // We can fit within the buffer so we can just replace bytes.
+ const dst = dst: {
+ const ptr = self.buffer.msgSend(?[*]u8, objc.sel("contents"), .{}) orelse {
+ log.warn("buffer contents ptr is null", .{});
+ return error.MetalFailed;
+ };
+
+ break :dst ptr[0..req_bytes];
+ };
+
+ var i: usize = 0;
+
+ for (lists) |list| {
+ const ptr = @as([*]const u8, @ptrCast(list.items.ptr));
+ @memcpy(dst[i..][0 .. list.items.len * @sizeOf(T)], ptr);
+ i += list.items.len * @sizeOf(T);
+ }
+
+ // If we're using the managed resource storage mode, then
+ // we need to signal Metal to synchronize the buffer data.
+ //
+ // Ref: https://developer.apple.com/documentation/metal/synchronizing-a-managed-resource-in-macos?language=objc
+ if (self.opts.resource_options.storage_mode == .managed) {
+ self.buffer.msgSend(
+ void,
+ "didModifyRange:",
+ .{macos.foundation.Range.init(0, req_bytes)},
+ );
+ }
+
+ return total_len;
+ }
+ };
+}
diff --git a/vendor/libghostty-vt/src/renderer/metal/shaders.zig b/vendor/libghostty-vt/src/renderer/metal/shaders.zig
new file mode 100644
index 00000000..0be02357
--- /dev/null
+++ b/vendor/libghostty-vt/src/renderer/metal/shaders.zig
@@ -0,0 +1,454 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const macos = @import("macos");
+const objc = @import("objc");
+const math = @import("../../math.zig");
+
+const mtl = @import("api.zig");
+const Pipeline = @import("Pipeline.zig");
+
+const log = std.log.scoped(.metal);
+
+const pipeline_descs: []const struct { [:0]const u8, PipelineDescription } =
+ &.{
+ .{ "bg_color", .{
+ .vertex_fn = "full_screen_vertex",
+ .fragment_fn = "bg_color_fragment",
+ .blending_enabled = false,
+ } },
+ .{ "cell_bg", .{
+ .vertex_fn = "full_screen_vertex",
+ .fragment_fn = "cell_bg_fragment",
+ .blending_enabled = true,
+ } },
+ .{ "cell_text", .{
+ .vertex_attributes = CellText,
+ .vertex_fn = "cell_text_vertex",
+ .fragment_fn = "cell_text_fragment",
+ .step_fn = .per_instance,
+ .blending_enabled = true,
+ } },
+ .{ "image", .{
+ .vertex_attributes = Image,
+ .vertex_fn = "image_vertex",
+ .fragment_fn = "image_fragment",
+ .step_fn = .per_instance,
+ .blending_enabled = true,
+ } },
+ .{ "bg_image", .{
+ .vertex_attributes = BgImage,
+ .vertex_fn = "bg_image_vertex",
+ .fragment_fn = "bg_image_fragment",
+ .step_fn = .per_instance,
+ .blending_enabled = true,
+ } },
+ };
+
+/// All the comptime-known info about a pipeline, so that
+/// we can define them ahead-of-time in an ergonomic way.
+const PipelineDescription = struct {
+ vertex_attributes: ?type = null,
+ vertex_fn: []const u8,
+ fragment_fn: []const u8,
+ step_fn: mtl.MTLVertexStepFunction = .per_vertex,
+ blending_enabled: bool,
+
+ fn initPipeline(
+ self: PipelineDescription,
+ device: objc.Object,
+ library: objc.Object,
+ pixel_format: mtl.MTLPixelFormat,
+ ) !Pipeline {
+ return try .init(self.vertex_attributes, .{
+ .device = device,
+ .vertex_fn = self.vertex_fn,
+ .fragment_fn = self.fragment_fn,
+ .vertex_library = library,
+ .fragment_library = library,
+ .step_fn = self.step_fn,
+ .attachments = &.{.{
+ .pixel_format = pixel_format,
+ .blending_enabled = self.blending_enabled,
+ }},
+ });
+ }
+};
+
+/// We create a type for the pipeline collection based on our desc array.
+const PipelineCollection = t: {
+ var fields: [pipeline_descs.len]std.builtin.Type.StructField = undefined;
+ for (pipeline_descs, 0..) |pipeline, i| {
+ fields[i] = .{
+ .name = pipeline[0],
+ .type = Pipeline,
+ .default_value_ptr = null,
+ .is_comptime = false,
+ .alignment = @alignOf(Pipeline),
+ };
+ }
+ break :t @Type(.{ .@"struct" = .{
+ .layout = .auto,
+ .fields = &fields,
+ .decls = &.{},
+ .is_tuple = false,
+ } });
+};
+
+/// This contains the state for the shaders used by the Metal renderer.
+pub const Shaders = struct {
+ library: objc.Object,
+
+ /// Collection of available render pipelines.
+ pipelines: PipelineCollection,
+
+ /// Custom shaders to run against the final drawable texture. This
+ /// can be used to apply a lot of effects. Each shader is run in sequence
+ /// against the output of the previous shader.
+ post_pipelines: []const Pipeline,
+
+ /// Set to true when deinited, if you try to deinit a defunct set
+ /// of shaders it will just be ignored, to prevent double-free.
+ defunct: bool = false,
+
+ /// Initialize our shader set.
+ ///
+ /// "post_shaders" is an optional list of postprocess shaders to run
+ /// against the final drawable texture. This is an array of shader source
+ /// code, not file paths.
+ pub fn init(
+ alloc: Allocator,
+ device: objc.Object,
+ post_shaders: []const [:0]const u8,
+ pixel_format: mtl.MTLPixelFormat,
+ ) !Shaders {
+ const library = try initLibrary(device);
+ errdefer library.msgSend(void, objc.sel("release"), .{});
+
+ var pipelines: PipelineCollection = undefined;
+
+ var initialized_pipelines: usize = 0;
+
+ errdefer inline for (pipeline_descs, 0..) |pipeline, i| {
+ if (i < initialized_pipelines) {
+ @field(pipelines, pipeline[0]).deinit();
+ }
+ };
+
+ inline for (pipeline_descs) |pipeline| {
+ @field(pipelines, pipeline[0]) = try pipeline[1].initPipeline(
+ device,
+ library,
+ pixel_format,
+ );
+ initialized_pipelines += 1;
+ }
+
+ const post_pipelines: []const Pipeline = initPostPipelines(
+ alloc,
+ device,
+ library,
+ post_shaders,
+ pixel_format,
+ ) catch |err| err: {
+ // If an error happens while building postprocess shaders we
+ // want to just not use any postprocess shaders since we don't
+ // want to block Ghostty from working.
+ log.warn("error initializing postprocess shaders err={}", .{err});
+ break :err &.{};
+ };
+ errdefer if (post_pipelines.len > 0) {
+ for (post_pipelines) |pipeline| pipeline.deinit();
+ alloc.free(post_pipelines);
+ };
+
+ return .{
+ .library = library,
+ .pipelines = pipelines,
+ .post_pipelines = post_pipelines,
+ };
+ }
+
+ pub fn deinit(self: *Shaders, alloc: Allocator) void {
+ if (self.defunct) return;
+ self.defunct = true;
+
+ // Release our primary shaders
+ inline for (pipeline_descs) |pipeline| {
+ @field(self.pipelines, pipeline[0]).deinit();
+ }
+ self.library.msgSend(void, objc.sel("release"), .{});
+
+ // Release our postprocess shaders
+ if (self.post_pipelines.len > 0) {
+ for (self.post_pipelines) |pipeline| {
+ pipeline.deinit();
+ }
+ alloc.free(self.post_pipelines);
+ }
+ }
+};
+
+/// The uniforms that are passed to our shaders.
+pub const Uniforms = extern struct {
+ // Note: all of the explicit alignments are copied from the
+ // MSL developer reference just so that we can be sure that we got
+ // it all exactly right.
+
+ /// The projection matrix for turning world coordinates to normalized.
+ /// This is calculated based on the size of the screen.
+ projection_matrix: math.Mat align(16),
+
+ /// Size of the screen (render target) in pixels.
+ screen_size: [2]f32 align(8),
+
+ /// Size of a single cell in pixels, unscaled.
+ cell_size: [2]f32 align(8),
+
+ /// Size of the grid in columns and rows.
+ grid_size: [2]u16 align(4),
+
+ /// The padding around the terminal grid in pixels. In order:
+ /// top, right, bottom, left.
+ grid_padding: [4]f32 align(16),
+
+ /// Bit mask defining which directions to
+ /// extend cell colors in to the padding.
+ /// Order, LSB first: left, right, up, down
+ padding_extend: PaddingExtend align(1),
+
+ /// The minimum contrast ratio for text. The contrast ratio is calculated
+ /// according to the WCAG 2.0 spec.
+ min_contrast: f32 align(4),
+
+ /// The cursor position and color.
+ cursor_pos: [2]u16 align(4),
+ cursor_color: [4]u8 align(4),
+
+ /// The background color for the whole surface.
+ bg_color: [4]u8 align(4),
+
+ /// Various booleans.
+ ///
+ /// TODO: Maybe put these in a packed struct, like for OpenGL.
+ bools: extern struct {
+ /// Whether the cursor is 2 cells wide.
+ cursor_wide: bool align(1),
+
+ /// Indicates that colors provided to the shader are already in
+ /// the P3 color space, so they don't need to be converted from
+ /// sRGB.
+ use_display_p3: bool align(1),
+
+ /// Indicates that the color attachments for the shaders have
+ /// an `*_srgb` pixel format, which means the shaders need to
+ /// output linear RGB colors rather than gamma encoded colors,
+ /// since blending will be performed in linear space and then
+ /// Metal itself will re-encode the colors for storage.
+ use_linear_blending: bool align(1),
+
+ /// Enables a weight correction step that makes text rendered
+ /// with linear alpha blending have a similar apparent weight
+ /// (thickness) to gamma-incorrect blending.
+ use_linear_correction: bool align(1) = false,
+ },
+
+ const PaddingExtend = packed struct(u8) {
+ left: bool = false,
+ right: bool = false,
+ up: bool = false,
+ down: bool = false,
+ _padding: u4 = 0,
+ };
+};
+
+/// This is a single parameter for the terminal cell shader.
+pub const CellText = extern struct {
+ glyph_pos: [2]u32 align(8) = .{ 0, 0 },
+ glyph_size: [2]u32 align(8) = .{ 0, 0 },
+ bearings: [2]i16 align(4) = .{ 0, 0 },
+ grid_pos: [2]u16 align(4),
+ color: [4]u8 align(4),
+ atlas: Atlas align(1),
+ bools: packed struct(u8) {
+ no_min_contrast: bool = false,
+ is_cursor_glyph: bool = false,
+ _padding: u6 = 0,
+ } align(1) = .{},
+
+ pub const Atlas = enum(u8) {
+ grayscale = 0,
+ color = 1,
+ };
+
+ test {
+ // Minimizing the size of this struct is important,
+ // so we test it in order to be aware of any changes.
+ try std.testing.expectEqual(32, @sizeOf(CellText));
+ }
+};
+
+/// This is a single parameter for the cell bg shader.
+pub const CellBg = [4]u8;
+
+/// Single parameter for the image shader. See shader for field details.
+pub const Image = extern struct {
+ grid_pos: [2]f32,
+ cell_offset: [2]f32,
+ source_rect: [4]f32,
+ dest_size: [2]f32,
+};
+
+/// Single parameter for the bg image shader.
+pub const BgImage = extern struct {
+ opacity: f32 align(4),
+ info: Info align(1),
+
+ pub const Info = packed struct(u8) {
+ position: Position,
+ fit: Fit,
+ repeat: bool,
+ _padding: u1 = 0,
+
+ pub const Position = enum(u4) {
+ tl = 0,
+ tc = 1,
+ tr = 2,
+ ml = 3,
+ mc = 4,
+ mr = 5,
+ bl = 6,
+ bc = 7,
+ br = 8,
+ };
+
+ pub const Fit = enum(u2) {
+ contain = 0,
+ cover = 1,
+ stretch = 2,
+ none = 3,
+ };
+ };
+};
+
+/// Initialize the MTLLibrary. A MTLLibrary is a collection of shaders.
+fn initLibrary(device: objc.Object) !objc.Object {
+ const start = try std.time.Instant.now();
+
+ const data = try macos.dispatch.Data.create(
+ @embedFile("ghostty_metallib"),
+ macos.dispatch.queue.getMain(),
+ macos.dispatch.Data.DESTRUCTOR_DEFAULT,
+ );
+ defer data.release();
+
+ var err: ?*anyopaque = null;
+ const library = device.msgSend(
+ objc.Object,
+ objc.sel("newLibraryWithData:error:"),
+ .{
+ data,
+ &err,
+ },
+ );
+ try checkError(err);
+
+ const end = try std.time.Instant.now();
+ log.debug("shader library loaded time={}us", .{end.since(start) / std.time.ns_per_us});
+
+ return library;
+}
+
+/// Initialize our custom shader pipelines.
+///
+/// The shaders argument is a set of shader source code, not file paths.
+fn initPostPipelines(
+ alloc: Allocator,
+ device: objc.Object,
+ library: objc.Object,
+ shaders: []const [:0]const u8,
+ pixel_format: mtl.MTLPixelFormat,
+) ![]const Pipeline {
+ // If we have no shaders, do nothing.
+ if (shaders.len == 0) return &.{};
+
+ // Keeps track of how many shaders we successfully wrote.
+ var i: usize = 0;
+
+ // Initialize our result set. If any error happens, we undo everything.
+ var pipelines = try alloc.alloc(Pipeline, shaders.len);
+ errdefer {
+ for (pipelines[0..i]) |pipeline| {
+ pipeline.deinit();
+ }
+ alloc.free(pipelines);
+ }
+
+ // Build each shader. Note we don't use "0.." to build our index
+ // because we need to keep track of our length to clean up above.
+ for (shaders) |source| {
+ pipelines[i] = try initPostPipeline(
+ device,
+ library,
+ source,
+ pixel_format,
+ );
+ i += 1;
+ }
+
+ return pipelines;
+}
+
+/// Initialize a single custom shader pipeline from shader source.
+fn initPostPipeline(
+ device: objc.Object,
+ library: objc.Object,
+ data: [:0]const u8,
+ pixel_format: mtl.MTLPixelFormat,
+) !Pipeline {
+ // Create our library which has the shader source
+ const post_library = library: {
+ const source = try macos.foundation.String.createWithBytes(
+ data,
+ .utf8,
+ false,
+ );
+ defer source.release();
+
+ var err: ?*anyopaque = null;
+ const post_library = device.msgSend(
+ objc.Object,
+ objc.sel("newLibraryWithSource:options:error:"),
+ .{ source, @as(?*anyopaque, null), &err },
+ );
+ try checkError(err);
+ errdefer post_library.msgSend(void, objc.sel("release"), .{});
+
+ break :library post_library;
+ };
+ defer post_library.msgSend(void, objc.sel("release"), .{});
+
+ return try Pipeline.init(null, .{
+ .device = device,
+ .vertex_fn = "full_screen_vertex",
+ .fragment_fn = "main0",
+ .vertex_library = library,
+ .fragment_library = post_library,
+ .attachments = &.{
+ .{
+ .pixel_format = pixel_format,
+ .blending_enabled = false,
+ },
+ },
+ });
+}
+
+fn checkError(err_: ?*anyopaque) !void {
+ const nserr = objc.Object.fromId(err_ orelse return);
+ const str = @as(
+ *macos.foundation.String,
+ @ptrCast(nserr.getProperty(?*anyopaque, "localizedDescription").?),
+ );
+
+ log.err("metal error={s}", .{str.cstringPtr(.ascii).?});
+ return error.MetalFailed;
+}