zaniah 0.1.0

data/lib/zaniah/ffi/wayland.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "library"
+
+module Zaniah
+  module FFI
+    # Runtime protocol metadata replaces generated C bindings. Core interfaces
+    # are exported by libwayland-client; these extensions use protocol v1.
+    class Wayland
+      P, I, U, V = Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_UINT, Fiddle::TYPE_VOID
+      PROTOCOLS = {
+        "xdg_wm_base" => [[
+          ["destroy", ""], ["create_positioner", "n", "xdg_positioner"],
+          ["get_xdg_surface", "no", "xdg_surface", "wl_surface"], ["pong", "u"]
+        ], [["ping", "u"]]],
+        "xdg_positioner" => [[], []], "xdg_popup" => [[], []],
+        "xdg_surface" => [[
+          ["destroy", ""], ["get_toplevel", "n", "xdg_toplevel"],
+          ["get_popup", "n?oo", "xdg_popup", "xdg_surface", "xdg_positioner"],
+          ["set_window_geometry", "iiii"], ["ack_configure", "u"]
+        ], [["configure", "u"]]],
+        "xdg_toplevel" => [[
+          ["destroy", ""], ["set_parent", "?o", "xdg_toplevel"], ["set_title", "s"], ["set_app_id", "s"],
+          ["show_window_menu", "ouii", "wl_seat"], ["move", "ou", "wl_seat"], ["resize", "ouu", "wl_seat"],
+          ["set_max_size", "ii"], ["set_min_size", "ii"], ["set_maximized", ""], ["unset_maximized", ""],
+          ["set_fullscreen", "?o", "wl_output"], ["unset_fullscreen", ""], ["set_minimized", ""]
+        ], [["configure", "iia"], ["close", ""]]],
+        "zwp_text_input_manager_v3" => [[["destroy", ""], ["get_text_input", "no", "zwp_text_input_v3", "wl_seat"]], []],
+        "zwp_text_input_v3" => [[
+          ["destroy", ""], ["enable", ""], ["disable", ""], ["set_surrounding_text", "sii"],
+          ["set_text_change_cause", "u"], ["set_content_type", "uu"], ["set_cursor_rectangle", "iiii"], ["commit", ""]
+        ], [["enter", "o", "wl_surface"], ["leave", "o", "wl_surface"], ["preedit_string", "?sii"],
+            ["commit_string", "?s"], ["delete_surrounding_text", "uu"], ["done", "u"]]],
+        "zxdg_decoration_manager_v1" => [[["destroy", ""], ["get_toplevel_decoration", "no", "zxdg_toplevel_decoration_v1", "xdg_toplevel"]], []],
+        "zxdg_toplevel_decoration_v1" => [[["destroy", ""], ["set_mode", "u"], ["unset_mode", ""]], [["configure", "u"]]],
+        "zxdg_output_manager_v1" => [[["destroy", ""], ["get_xdg_output", "no", "zxdg_output_v1", "wl_output"]], []],
+        "zxdg_output_v1" => [[["destroy", ""]], [["logical_position", "ii"], ["logical_size", "ii"], ["done", ""], ["name", "2s"], ["description", "2s"]]]
+      }.freeze
+      PROTOCOL_VERSIONS = {"zxdg_output_manager_v1" => 3, "zxdg_output_v1" => 3}.freeze
+      attr_reader :library, :display
+
+      def initialize
+        @library = Library.new("libwayland-client.so.0")
+        @interfaces, @keep, @listeners, @objects = {}, [], [], []
+        PROTOCOLS.each_key { |name| @interfaces[name] = Fiddle::Pointer.malloc(40, Fiddle::RUBY_FREE) }
+        PROTOCOLS.each do |name, (requests, events)|
+          bytes = [keep_string(name), PROTOCOL_VERSIONS.fetch(name, 1), requests.length, messages(requests), events.length, messages(events)].pack("JiiJi x4J")
+          @interfaces[name][0, 40] = bytes
+        end
+        @display = @library.fn(:wl_display_connect, [P], P).call(0)
+        raise Zaniah::Error, "cannot connect to WAYLAND_DISPLAY" if @display.null?
+      end
+      def interface(name) = @interfaces[name] ||= Fiddle::Pointer.new(@library.handle["#{name}_interface"])
+      def keep_string(text)
+        string = text + "\0"
+        @keep << string
+        Fiddle::Pointer[string].to_i
+      end
+      def messages(definitions)
+        return 0 if definitions.empty?
+        data = definitions.map do |name, signature, *interfaces|
+          count = signature.delete("?0123456789").length
+          types = Array.new(count, 0)
+          interfaces.each_with_index { |type, i| types[i] = interface(type).to_i if type }
+          packed = types.pack("J*")
+          @keep << packed
+          [keep_string(name), keep_string(signature), Fiddle::Pointer[packed].to_i].pack("J3")
+        end.join
+        @keep << data
+        Fiddle::Pointer[data].to_i
+      end
+      def version(proxy) = @library.fn(:wl_proxy_get_version, [P], U).call(proxy)
+      def request(proxy, opcode, *arguments, new_interface: nil, version: nil, destroy: false)
+        strings = []
+        values = arguments.map do |value|
+          if value.is_a?(String)
+            strings << value + "\0"
+            Fiddle::Pointer[strings.last].to_i
+          else
+            value.to_i & 0xffffffffffffffff
+          end
+        end.pack("Q*")
+        object = @library.fn(:wl_proxy_marshal_array_flags, [P, U, P, U, U, P], P).call(proxy, opcode,
+          new_interface ? interface(new_interface) : 0, version || self.version(proxy), destroy ? 1 : 0, values.empty? ? 0 : values)
+        @objects << object if new_interface && !object.null?
+        @objects.delete(proxy) if destroy
+        object
+      end
+      def listen(proxy, events)
+        @objects << proxy unless @objects.include?(proxy)
+        callbacks = events.map do |types, block|
+          Fiddle::Closure::BlockCaller.new(V, [P, P, *types]) do |_data, object, *arguments|
+            begin
+              block&.call(object, *arguments)
+            rescue StandardError => error
+              @error = error
+            end
+          end
+        end
+        table = callbacks.map(&:to_i).pack("J*")
+        result = @library.fn(:wl_proxy_add_listener, [P, P, P], I).call(proxy, table, 0)
+        raise Zaniah::Error, "Wayland listener registration failed" unless result.zero?
+        @listeners << [table, callbacks]
+      end
+      def roundtrip
+        result = @library.fn(:wl_display_roundtrip, [P], I).call(@display)
+        raise @error if @error
+        raise Zaniah::Error, "Wayland compositor disconnected" if result.negative?
+      end
+      def poll(timeout: 0)
+        until @library.fn(:wl_display_prepare_read, [P], I).call(@display).zero?
+          result = @library.fn(:wl_display_dispatch_pending, [P], I).call(@display)
+          raise @error if @error
+          raise Zaniah::Error, "Wayland compositor disconnected" if result.negative?
+        end
+        @library.fn(:wl_display_flush, [P], I).call(@display)
+        fd = @library.fn(:wl_display_get_fd, [P], I).call(@display)
+        ready = IO.select([IO.for_fd(fd, autoclose: false)], nil, nil, timeout)
+        if ready
+          result = @library.fn(:wl_display_read_events, [P], I).call(@display)
+          raise Zaniah::Error, "Wayland compositor disconnected" if result.negative?
+        else
+          @library.fn(:wl_display_cancel_read, [P], V).call(@display)
+        end
+        @library.fn(:wl_display_dispatch_pending, [P], I).call(@display)
+        raise @error if @error
+      end
+      def destroy(proxy)
+        return unless proxy && !proxy.to_i.zero?
+        @library.fn(:wl_proxy_destroy, [P], V).call(proxy)
+        @objects.delete(proxy)
+      end
+      def close
+        @objects.reverse_each { |object| @library.fn(:wl_proxy_destroy, [P], V).call(object) }
+        @objects.clear
+        @library.fn(:wl_display_disconnect, [P], V).call(@display)
+      end
+    end
+  end
+end

data/lib/zaniah/frame_context.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class FrameContext
+    attr_reader :window, :scene, :dispatcher, :text_system
+
+    def initialize(window)
+      @window, @scene = window, window.scene
+      @dispatcher, @text_system = window.dispatcher, window.text_system
+    end
+
+    def state(key, &initial) = @window.element_state(key, &initial)
+  end
+end

data/lib/zaniah/geometry.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "point"
+require_relative "size"
+require_relative "edges"
+require_relative "corners"
+require_relative "bounds"
+require_relative "length"
+require_relative "device_pixels"
+require_relative "length_units"
+require_relative "color"
+require_relative "hsla"
+
+module Zaniah
+  extend LengthUnits
+end

data/lib/zaniah/gpu/buffer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module GPU
+    class Buffer
+      attr_reader :size, :usage, :data
+
+      def initialize(size, usage: :vertex, mutable: true)
+        raise ArgumentError, "invalid buffer size" unless size.is_a?(Integer) && size >= 0
+        @size, @usage, @mutable = size, usage, mutable
+        @data = "\0".b * size
+      end
+
+      def write(bytes, offset: 0)
+        raise ArgumentError, "buffer write out of bounds" if offset.negative? || offset + bytes.bytesize > @size
+        @data[offset, bytes.bytesize] = bytes
+        self
+      end
+
+      def release = @data.clear
+    end
+  end
+end

data/lib/zaniah/gpu/frame_encoder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module GPU
+    class FrameEncoder
+      def initialize(device, clear)
+        @device, @clear, @scene, @textures = device, clear, Scene.new, {}
+      end
+
+      def set_pipeline(pipeline) = @pipeline = pipeline
+      def set_uniforms(**values) = @uniforms = values
+      def set_texture(slot, texture) = @textures[slot] = texture
+      def set_scissor(bounds) = @scissor = bounds
+
+      def draw_instanced(vertex_count:, instance_buffer:, instance_count:)
+        raise ArgumentError, "expected quad vertices" unless vertex_count == 4
+        raise ArgumentError, "pipeline not set" unless @pipeline
+        draw = lambda do
+          values = instance_buffer.data.unpack("f*")
+          if @pipeline.shader == :quad
+            raise ArgumentError, "instance buffer too small" if values.length < instance_count * Scene::QUAD_STRIDE
+            instance_count.times do |index|
+              quad = values.slice(index * Scene::QUAD_STRIDE, Scene::QUAD_STRIDE)
+              @scene.quad(*quad.first(4), color: quad[4, 4], radius: quad[8, 4], border_width: quad[12], border_color: quad[13, 4])
+            end
+          elsif [:mono_sprite, :poly_sprite].include?(@pipeline.shader)
+            raise ArgumentError, "instance buffer too small" if values.length < instance_count * 12
+            texture = @textures.fetch(0)
+            instance_count.times do |index|
+              sprite = values.slice(index * 12, 12)
+              @scene.sprite(*sprite.first(4), texture: texture, color: sprite[4, 4], source: Bounds.new(*sprite[8, 4]))
+            end
+          else
+            raise ArgumentError, "unsupported instanced shader #{@pipeline.shader}"
+          end
+        end
+        @scissor ? @scene.clip(@scissor, &draw) : draw.call
+      end
+
+      def present = @device.render(@scene, clear: @clear)
+    end
+  end
+end

data/lib/zaniah/gpu/instance_packing.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module GPU
+    # Consecutive commands only are batched, preserving alpha and layer order.
+    module InstancePacking
+      STRIDE = 24
+      def self.pack(scene)
+        data, batches, bytes = [], [], "".b
+        scene.each_command do |kind, offset, clip|
+          texture = nil
+          first = bytes.bytesize / (STRIDE * 4) + data.length / STRIDE
+          count = 1
+          case kind
+          when :quad
+            q, i = scene.quads, offset
+            data.push(q[i], q[i+1], q[i+2], q[i+3], q[i+4], q[i+5], q[i+6], q[i+7],
+              q[i+8], q[i+9], q[i+10], q[i+11], q[i+13], q[i+14], q[i+15], q[i+16], q[i+12], 0, 0, 0, 0, 0, 0, 0)
+          when :sprite
+            s, i = scene.sprite_data, offset
+            texture = scene.textures.fetch(s[i+8])
+            data.push(s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5], s[i+6], s[i+7],
+              0, 0, 0, 0, 0, 0, 0, 0, 0, texture.format == :r8 ? 1 : 2, 0, 0,
+              s[i+9].to_f / texture.width, s[i+10].to_f / texture.height,
+              s[i+11].to_f / texture.width, s[i+12].to_f / texture.height)
+          when :sprite_batch
+            unless data.empty?
+              bytes << data.pack("f*")
+              data.clear
+            end
+            batch = scene.sprite_batches.fetch(offset)
+            bytes << batch.bytes
+            kind, texture = :sprite, batch.texture
+            count = batch.bytes.bytesize / (STRIDE * 4)
+          when :triangle
+            p, i = scene.paths, offset
+            data.push(p[i], p[i+1], p[i+2], p[i+3], p[i+6], p[i+7], p[i+8], p[i+9],
+              p[i+4], p[i+5], 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0)
+          else raise ArgumentError, "unsupported primitive #{kind}"
+          end
+          previous = batches.last&.first
+          if previous && previous[0] == kind && previous[1].equal?(texture) && previous[2] == clip
+            batches.last[2] += count
+          else
+            batches << [[kind, texture, clip], first, count]
+          end
+        end
+        bytes << data.pack("f*") unless data.empty?
+        [bytes, batches]
+      end
+    end
+  end
+end

data/lib/zaniah/gpu/metal.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require_relative "instance_packing"
+require_relative "../ffi/objc"
+
+module Zaniah
+  module GPU
+    class Metal
+      O = FFI::ObjC
+      LIB = FFI::Library.new("/System/Library/Frameworks/Metal.framework/Metal")
+      POINTER_ARGS = [:pointer].freeze
+      ULONG_ARGS = [:ulong].freeze
+      BUFFER_ARGS = [:pointer, :ulong, :ulong].freeze
+      TEXTURE_ARGS = [:pointer, :ulong].freeze
+      DRAW_ARGS = [:ulong, :ulong, :ulong, :ulong].freeze
+      CLEAR_ARGS = [:clear_color].freeze
+      attr_reader :width, :height, :draw_calls
+      SOURCE = <<~MSL.freeze
+        #include <metal_stdlib>
+        using namespace metal;
+        struct Vertex { float4 position [[position]]; float2 local; float2 size;
+          float4 color; float4 radii; float4 border; float4 info; float2 uv; };
+        vertex Vertex zaniah_vertex(uint v [[vertex_id]], uint instance [[instance_id]],
+            const device float *data [[buffer(0)]], constant float2 &viewport [[buffer(1)]]) {
+          const device float *p = data + instance * 24;
+          float2 corners[4] = {float2(0,0),float2(1,0),float2(0,1),float2(1,1)};
+          float2 corner = corners[v], size = float2(p[2],p[3]);
+          float2 position = float2(p[0],p[1]) + corner * size;
+          if (p[17] == 3) position = v == 0 ? float2(p[0],p[1]) : v == 1 ? float2(p[2],p[3]) : float2(p[8],p[9]);
+          Vertex out;
+          out.position = float4(position.x / viewport.x * 2 - 1, 1 - position.y / viewport.y * 2, 0, 1);
+          out.local = corner * size; out.size = size;
+          out.color = float4(p[4],p[5],p[6],p[7]); out.radii = float4(p[8],p[9],p[10],p[11]);
+          out.border = float4(p[12],p[13],p[14],p[15]); out.info = float4(p[16],p[17],p[18],p[19]);
+          out.uv = float2(p[20],p[21]) + corner * float2(p[22],p[23]); return out;
+        }
+        fragment float4 zaniah_fragment(Vertex in [[stage_in]], texture2d<float> atlas [[texture(0)]]) {
+          float4 color = in.color;
+          if (in.info.y == 0) {
+            float radius = in.local.y < in.size.y/2 ? (in.local.x < in.size.x/2 ? in.radii.x : in.radii.y) : (in.local.x < in.size.x/2 ? in.radii.w : in.radii.z);
+            radius = clamp(radius, 0.0f, min(in.size.x,in.size.y)/2);
+            float2 q = abs(in.local - in.size/2) - in.size/2 + radius;
+            float distance = length(max(q,0.0f)) + min(max(q.x,q.y),0.0f) - radius;
+            float coverage = clamp(0.5f - distance, 0.0f, 1.0f);
+            if (in.info.x > 0 && distance >= -in.info.x) color = in.border;
+            color.a *= coverage;
+          } else if (in.info.y == 1 || in.info.y == 2) {
+            constexpr sampler texture_sampler(coord::normalized, address::clamp_to_edge, filter::nearest);
+            float4 sample = atlas.sample(texture_sampler,in.uv);
+            if (in.info.y == 1) color.a *= sample.r; else color *= sample;
+          }
+          return float4(color.rgb * color.a, color.a);
+        }
+      MSL
+
+      def initialize(window)
+        @window, @textures = window, {}
+        @device = LIB.fn(:MTLCreateSystemDefaultDevice, [], Fiddle::TYPE_VOIDP).call.to_i
+        raise Error, "Metal device unavailable" if @device.zero?
+        @queue = O.send(@device, "newCommandQueue")
+        O.send(window.layer, "setDevice:", @device, args: [:pointer], result: :void)
+        O.send(window.layer, "setPixelFormat:", 80, args: [:ulong], result: :void)
+        O.send(window.layer, "setFramebufferOnly:", 0, args: [:bool], result: :void)
+        @pipeline = compile_pipeline(SOURCE)
+        # Metal render-pass descriptors are reusable; only the drawable target
+        # and a changed clear color need updating between encoders.
+        @render_pass = O.new("MTLRenderPassDescriptor")
+        @color_attachment = O.send(O.send(@render_pass, "colorAttachments"), "objectAtIndexedSubscript:", 0, args: ULONG_ARGS)
+        O.send(@color_attachment, "setLoadAction:", 2, args: ULONG_ARGS, result: :void)
+        O.send(@color_attachment, "setStoreAction:", 1, args: ULONG_ARGS, result: :void)
+        @clear_input = Object.new
+        @scissor = Array.new(4, 0)
+        @scissor_signature = FFI::Struct::Signature.new([:pointer, :pointer, :scissor], :void)
+        @scissor_selector = O.selector("setScissorRect:")
+        @white = create_texture(1, 1, data: "\xff".b * 4)
+        resize(window.content_size.width, window.content_size.height)
+      end
+
+      def compile_pipeline(source)
+        error = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE)
+        error[0, Fiddle::SIZEOF_VOIDP] = [0].pack("J")
+        library = O.send(@device, "newLibraryWithSource:options:error:", O.string(source), 0, error,
+                         args: [:pointer] * 3)
+        raise Error, native_error(error, "Metal shader compilation failed") if library.zero?
+        vertex = O.send(library, "newFunctionWithName:", O.string("zaniah_vertex"), args: [:pointer])
+        fragment = O.send(library, "newFunctionWithName:", O.string("zaniah_fragment"), args: [:pointer])
+        descriptor = O.new("MTLRenderPipelineDescriptor")
+        O.send(descriptor, "setVertexFunction:", vertex, args: [:pointer], result: :void)
+        O.send(descriptor, "setFragmentFunction:", fragment, args: [:pointer], result: :void)
+        attachment = O.send(O.send(descriptor, "colorAttachments"), "objectAtIndexedSubscript:", 0, args: [:ulong])
+        O.send(attachment, "setPixelFormat:", 80, args: [:ulong], result: :void)
+        O.send(attachment, "setBlendingEnabled:", 1, args: [:bool], result: :void)
+        {"setSourceRGBBlendFactor:" => 1, "setSourceAlphaBlendFactor:" => 1,
+         "setDestinationRGBBlendFactor:" => 5, "setDestinationAlphaBlendFactor:" => 5}.each do |name, value|
+          O.send(attachment, name, value, args: [:ulong], result: :void)
+        end
+        pipeline = O.send(@device, "newRenderPipelineStateWithDescriptor:error:", descriptor, error, args: [:pointer, :pointer])
+        raise Error, native_error(error, "Metal pipeline creation failed") if pipeline.zero?
+        pipeline
+      ensure
+        [descriptor, vertex, fragment, library].compact.each { |object| O.release(object) }
+      end
+
+      def resize(width, height)
+        raise ArgumentError, "invalid viewport" unless width.positive? && height.positive?
+        @width, @height = width.to_i, height.to_i
+        @scale = @window.scale_factor
+        @pixel_width, @pixel_height = (width * @scale).round, (height * @scale).round
+        @viewport_bytes = [@width, @height].pack("f2")
+        @viewport_pointer = Fiddle::Pointer[@viewport_bytes]
+        @full_scissor = [0, 0, @pixel_width, @pixel_height].freeze
+        O.send(@window.layer, "setContentsScale:", @scale, args: [:double], result: :void)
+        O.send(@window.layer, "setDrawableSize:", [@pixel_width, @pixel_height], args: [:size], result: :void)
+      end
+      def create_texture(width, height, **options) = Texture.new(width, height, **options)
+      def create_buffer(size, **options) = Buffer.new(size, **options)
+      def create_pipeline(shader:, blend: :premultiplied) = Pipeline.new(shader, blend)
+      def begin_frame(clear: "#0000") = FrameEncoder.new(self, clear)
+
+      def render(scene, clear: "#0000")
+        pool = O.new("NSAutoreleasePool")
+        @draw_calls = 0
+        drawable = O.send(@window.layer, "nextDrawable")
+        return if drawable.zero?
+        target = O.send(drawable, "texture")
+        O.release(@last_texture) if @last_texture
+        @last_texture = O.send(target, "retain")
+        command = O.send(@queue, "commandBuffer")
+        O.send(@color_attachment, "setTexture:", target, args: POINTER_ARGS, result: :void)
+        unless clear == @clear_input
+          O.send(@color_attachment, "setClearColor:", Color.parse(clear).premultiplied, args: CLEAR_ARGS, result: :void)
+          @clear_input = clear.is_a?(String) || clear.is_a?(Array) ? clear.dup.freeze : clear
+        end
+        encoder = O.send(command, "renderCommandEncoderWithDescriptor:", @render_pass, args: POINTER_ARGS)
+        O.send(encoder, "setRenderPipelineState:", @pipeline, args: POINTER_ARGS, result: :void)
+        bytes, batches = InstancePacking.pack(scene)
+        unless bytes.empty?
+          buffer = O.send(@device, "newBufferWithBytes:length:options:", Fiddle::Pointer[bytes], bytes.bytesize, 0, args: BUFFER_ARGS)
+          O.send(encoder, "setVertexBytes:length:atIndex:", @viewport_pointer, @viewport_bytes.bytesize, 1, args: BUFFER_ARGS, result: :void)
+          batches.each do |(kind, texture, clip), first, count|
+            scissor = @full_scissor
+            if clip
+              left, top = [clip.x, 0].max, [clip.y, 0].max
+              width, height = [clip.right, @width].min - left, [clip.bottom, @height].min - top
+              next unless width.positive? && height.positive?
+              scissor = @scissor
+              scissor[0], scissor[1] = (left * @scale).to_i, (top * @scale).to_i
+              scissor[2], scissor[3] = (width * @scale).to_i, (height * @scale).to_i
+            end
+            next if scissor[2].zero? || scissor[3].zero?
+            # MTLScissorRect is four NSUInteger values, the same layout as two ranges.
+            @scissor_signature.call(O::MESSAGE_SEND, encoder, @scissor_selector, scissor)
+            O.send(encoder, "setVertexBuffer:offset:atIndex:", buffer, first * InstancePacking::STRIDE * 4, 0, args: BUFFER_ARGS, result: :void)
+            O.send(encoder, "setFragmentTexture:atIndex:", native_texture(texture || @white), 0, args: TEXTURE_ARGS, result: :void)
+            O.send(encoder, "drawPrimitives:vertexStart:vertexCount:instanceCount:", kind == :triangle ? 3 : 4, 0, kind == :triangle ? 3 : 4, count, args: DRAW_ARGS, result: :void)
+            @draw_calls += 1
+          end
+        end
+        O.send(encoder, "endEncoding", result: :void)
+        O.send(command, "presentDrawable:", drawable, args: POINTER_ARGS, result: :void)
+        O.send(command, "commit", result: :void)
+        O.release(@last_command) if @last_command
+        @last_command = O.send(command, "retain")
+      ensure
+        O.release(buffer) if buffer
+        O.release(pool) if pool
+      end
+
+      def native_texture(texture)
+        entry = @textures[texture]
+        unless entry
+          descriptor = O.send(O.klass("MTLTextureDescriptor"), "texture2DDescriptorWithPixelFormat:width:height:mipmapped:", texture.format == :r8 ? 10 : 70, texture.width, texture.height, 0, args: [:ulong, :ulong, :ulong, :bool])
+          O.send(descriptor, "setStorageMode:", 0, args: [:ulong], result: :void)
+          entry = @textures[texture] = [O.send(@device, "newTextureWithDescriptor:", descriptor, args: [:pointer]), nil]
+          raise Error, "Metal texture allocation failed" if entry[0].zero?
+        end
+        digest = texture.revision
+        if entry[1] != digest
+          region = [0, 0, 0, texture.width, texture.height, 1]
+          O.send(entry[0], "replaceRegion:mipmapLevel:withBytes:bytesPerRow:", region, 0, Fiddle::Pointer[texture.data], texture.width * (texture.format == :r8 ? 1 : 4), args: [:region, :ulong, :pointer, :ulong], result: :void)
+          entry[1] = digest
+        end
+        entry[0]
+      end
+
+      def pixels
+        return "\0".b * (@pixel_width * @pixel_height * 4) unless @last_texture
+        O.send(@last_command, "waitUntilCompleted", result: :void)
+        status = O.send(@last_command, "status", result: :ulong)
+        raise Error, O.text(O.send(O.send(@last_command, "error"), "localizedDescription")) if status == 5
+        bytes = "\0".b * (@pixel_width * @pixel_height * 4)
+        O.send(@last_texture, "getBytes:bytesPerRow:fromRegion:mipmapLevel:", Fiddle::Pointer[bytes], @pixel_width * 4, [0, 0, 0, @pixel_width, @pixel_height, 1], 0, args: [:pointer, :ulong, :region, :ulong], result: :void)
+        bytes.unpack("C*").each_slice(4).flat_map { |b, g, r, a| a.zero? ? [0, 0, 0, 0] : [(r * 255 / a).clamp(0, 255), (g * 255 / a).clamp(0, 255), (b * 255 / a).clamp(0, 255), a] }.pack("C*")
+      end
+      def write_png(path) = PNG.write(path, @pixel_width, @pixel_height, pixels)
+      def release
+        O.send(@last_command, "waitUntilCompleted", result: :void) if @last_command
+        @textures.each_value { |entry| O.release(entry[0]) }
+        @textures.clear
+        [@last_command, @last_texture, @render_pass, @pipeline, @queue, @device].compact.each { |object| O.release(object) }
+        @last_command = @last_texture = @render_pass = nil
+      end
+      def native_error(pointer, fallback)
+        object = pointer[0, Fiddle::SIZEOF_VOIDP].unpack1("J")
+        object.zero? ? fallback : O.text(O.send(object, "localizedDescription"))
+      end
+    end
+  end
+end