zaniah 0.1.0

data/lib/zaniah/gpu/open_gl.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require_relative "instance_packing"
+require_relative "../ffi/library"
+
+module Zaniah
+  module GPU
+    class OpenGL
+      I, P, V, F = Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOID, Fiddle::TYPE_FLOAT
+      attr_reader :width, :height, :draw_calls
+      VERTEX = <<~GLSL.freeze
+        #version 330 core
+        layout(location=0) in vec4 rect;
+        layout(location=1) in vec4 tint;
+        layout(location=2) in vec4 corners;
+        layout(location=3) in vec4 border_color;
+        layout(location=4) in vec4 extra;
+        layout(location=5) in vec4 source;
+        uniform vec2 viewport;
+        out vec2 local_position; out vec2 size; out vec4 color; out vec4 radii;
+        out vec4 border; out vec4 info; out vec2 uv;
+        void main() {
+          vec2 vertices[4] = vec2[4](vec2(0,0),vec2(1,0),vec2(0,1),vec2(1,1));
+          vec2 corner = vertices[gl_VertexID];
+          vec2 position = rect.xy + corner * rect.zw;
+          if (extra.y == 3) position = gl_VertexID == 0 ? rect.xy : gl_VertexID == 1 ? rect.zw : corners.xy;
+          gl_Position = vec4(position.x / viewport.x * 2 - 1, 1 - position.y / viewport.y * 2, 0, 1);
+          local_position = corner * rect.zw; size = rect.zw; color = tint;
+          radii = corners; border = border_color; info = extra; uv = source.xy + corner * source.zw;
+        }
+      GLSL
+      FRAGMENT = <<~GLSL.freeze
+        #version 330 core
+        in vec2 local_position; in vec2 size; in vec4 color; in vec4 radii;
+        in vec4 border; in vec4 info; in vec2 uv;
+        uniform sampler2D atlas;
+        out vec4 output_color;
+        void main() {
+          vec4 result = color;
+          if (info.y == 0) {
+            float radius = local_position.y < size.y/2 ? (local_position.x < size.x/2 ? radii.x : radii.y) : (local_position.x < size.x/2 ? radii.w : radii.z);
+            radius = clamp(radius, 0, min(size.x,size.y)/2);
+            vec2 q = abs(local_position - size/2) - size/2 + radius;
+            float distance = length(max(q,0)) + min(max(q.x,q.y),0) - radius;
+            float coverage = clamp(0.5 - distance, 0, 1);
+            if (info.x > 0 && distance >= -info.x) result = border;
+            result.a *= coverage;
+          } else if (info.y == 1 || info.y == 2) {
+            vec4 sample_color = texture(atlas,uv);
+            if (info.y == 1) result.a *= sample_color.r; else result *= sample_color;
+          }
+          output_color = vec4(result.rgb * result.a, result.a);
+        }
+      GLSL
+
+      def initialize(window, library:, resolver: nil)
+        @window, @library, @resolver, @functions, @textures = window, library, resolver, {}, {}
+        window.make_current
+        version = gl(:glGetString, [I], P, 0x1F02).to_s
+        raise Error, "OpenGL 3.3 required (#{version})" if version.to_f < 3.3
+        @program = compile_program(VERTEX, FRAGMENT)
+        @vao, @buffer = generate(:glGenVertexArrays), generate(:glGenBuffers)
+        gl(:glBindVertexArray, [I], V, @vao)
+        gl(:glBindBuffer, [I, I], V, 0x8892, @buffer)
+        6.times do |location|
+          gl(:glEnableVertexAttribArray, [I], V, location)
+          gl(:glVertexAttribDivisor, [I, I], V, location, 1)
+        end
+        gl(:glEnable, [I], V, 0x0BE2)
+        gl(:glBlendFunc, [I, I], V, 1, 0x0303)
+        @viewport_location = gl(:glGetUniformLocation, [I, P], I, @program, "viewport")
+        @white = create_texture(1, 1, data: "\xff".b * 4)
+        resize(window.content_size.width, window.content_size.height)
+      end
+      def gl(name, args, result, *values)
+        function = @functions[name] ||= begin
+          address = @resolver&.call(name.to_s)
+          address = @library.handle[name.to_s] if !address || address.to_i <= 3 || address.to_i == -1
+          Fiddle::Function.new(address, args, result, name: name.to_s, need_gvl: false)
+        end
+        function.call(*values)
+      end
+      def generate(name)
+        bytes = [0].pack("I")
+        gl(name, [I, P], V, 1, bytes)
+        bytes.unpack1("I")
+      end
+      def compile_program(vertex, fragment)
+        shaders = []
+        [[0x8B31, vertex], [0x8B30, fragment]].each do |kind, source|
+          shader = gl(:glCreateShader, [I], I, kind)
+          pointer = [Fiddle::Pointer[source].to_i].pack("J")
+          length = [source.bytesize].pack("i")
+          gl(:glShaderSource, [I, I, P, P], V, shader, 1, pointer, length)
+          gl(:glCompileShader, [I], V, shader)
+          status = [0].pack("i")
+          gl(:glGetShaderiv, [I, I, P], V, shader, 0x8B81, status)
+          if status.unpack1("i").zero?
+            log = "\0" * 8192
+            gl(:glGetShaderInfoLog, [I, I, P, P], V, shader, log.bytesize, 0, log)
+            gl(:glDeleteShader, [I], V, shader)
+            raise Error, "OpenGL shader: #{log.delete("\0") }"
+          end
+          shaders << shader
+        end
+        program = gl(:glCreateProgram, [], I)
+        shaders.each { |shader| gl(:glAttachShader, [I, I], V, program, shader) }
+        gl(:glLinkProgram, [I], V, program)
+        status = [0].pack("i")
+        gl(:glGetProgramiv, [I, I, P], V, program, 0x8B82, status)
+        if status.unpack1("i").zero?
+          log = "\0" * 8192
+          gl(:glGetProgramInfoLog, [I, I, P, P], V, program, log.bytesize, 0, log)
+          gl(:glDeleteProgram, [I], V, program)
+          raise Error, "OpenGL program: #{log.delete("\0") }"
+        end
+        program
+      ensure
+        shaders&.each { |shader| gl(:glDeleteShader, [I], V, shader) }
+      end
+      def resize(width, height)
+        raise ArgumentError, "invalid viewport" unless width.positive? && height.positive?
+        @width, @height, @scale = width.to_i, height.to_i, @window.scale_factor
+        @pixel_width, @pixel_height = (width * @scale).round, (height * @scale).round
+      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", capture: false)
+        @window.make_current
+        @draw_calls = 0
+        gl(:glViewport, [I] * 4, V, 0, 0, @pixel_width, @pixel_height)
+        gl(:glDisable, [I], V, 0x0C11)
+        gl(:glClearColor, [F] * 4, V, *Color.parse(clear).premultiplied)
+        gl(:glClear, [I], V, 0x4000)
+        gl(:glEnable, [I], V, 0x0C11)
+        gl(:glUseProgram, [I], V, @program)
+        gl(:glUniform2f, [I, F, F], V, @viewport_location, @width, @height)
+        gl(:glBindVertexArray, [I], V, @vao)
+        gl(:glBindBuffer, [I, I], V, 0x8892, @buffer)
+        bytes, batches = InstancePacking.pack(scene)
+        unless bytes.empty?
+          gl(:glBufferData, [I, Fiddle::TYPE_SIZE_T, P, I], V, 0x8892, bytes.bytesize, 0, 0x88E0)
+          gl(:glBufferSubData, [I, Fiddle::TYPE_SIZE_T, Fiddle::TYPE_SIZE_T, P], V, 0x8892, 0, bytes.bytesize, bytes)
+          batches.each do |(kind, texture, clip), first, count|
+            clip = clip ? Bounds.new(0, 0, @width, @height).intersect(clip) : Bounds.new(0, 0, @width, @height)
+            next unless clip.width.positive? && clip.height.positive?
+            gl(:glScissor, [I] * 4, V, (clip.x * @scale).to_i, ((@height - clip.bottom) * @scale).to_i, (clip.width * @scale).to_i, (clip.height * @scale).to_i)
+            6.times do |location|
+              gl(:glVertexAttribPointer, [I, I, I, I, I, P], V, location, 4, 0x1406, 0, InstancePacking::STRIDE * 4, (first * InstancePacking::STRIDE + location * 4) * 4)
+            end
+            native_texture(texture || @white)
+            gl(:glDrawArraysInstanced, [I] * 4, V, kind == :triangle ? 4 : 5, 0, kind == :triangle ? 3 : 4, count)
+            @draw_calls += 1
+          end
+        end
+        # Capture only when requested; glReadPixels is otherwise an avoidable stall.
+        @last_scene, @last_clear = scene, clear
+        @captured_pixels = read_pixels if capture
+        @window.swap_buffers
+      end
+
+      def native_texture(texture)
+        entry = @textures[texture]
+        unless entry
+          entry = @textures[texture] = [generate(:glGenTextures), nil]
+          gl(:glBindTexture, [I, I], V, 0x0DE1, entry[0])
+          gl(:glTexParameteri, [I] * 3, V, 0x0DE1, 0x2801, 0x2600)
+          gl(:glTexParameteri, [I] * 3, V, 0x0DE1, 0x2800, 0x2600)
+          gl(:glTexParameteri, [I] * 3, V, 0x0DE1, 0x2802, 0x812F)
+          gl(:glTexParameteri, [I] * 3, V, 0x0DE1, 0x2803, 0x812F)
+          gl(:glPixelStorei, [I, I], V, 0x0CF5, 1)
+          gl(:glTexImage2D, [I] * 8 + [P], V, 0x0DE1, 0, texture.format == :r8 ? 0x8229 : 0x8058, texture.width, texture.height, 0, texture.format == :r8 ? 0x1903 : 0x1908, 0x1401, 0)
+        else
+          gl(:glBindTexture, [I, I], V, 0x0DE1, entry[0])
+        end
+        digest = texture.revision
+        if entry[1] != digest
+          gl(:glTexSubImage2D, [I] * 8 + [P], V, 0x0DE1, 0, 0, 0, texture.width, texture.height, texture.format == :r8 ? 0x1903 : 0x1908, 0x1401, texture.data)
+          entry[1] = digest
+        end
+        entry[0]
+      end
+
+      def pixels
+        render(@last_scene, clear: @last_clear, capture: true) if @last_scene
+        @captured_pixels || "\0".b * (@pixel_width * @pixel_height * 4)
+      end
+      def read_pixels
+        @window.make_current
+        gl(:glReadBuffer, [I], V, 0x0405)
+        bytes = "\0".b * (@pixel_width * @pixel_height * 4)
+        gl(:glReadPixels, [I] * 6 + [P], V, 0, 0, @pixel_width, @pixel_height, 0x1908, 0x1401, bytes)
+        rows = @pixel_height.times.map { |y| bytes.byteslice((@pixel_height - y - 1) * @pixel_width * 4, @pixel_width * 4) }.join
+        rows.unpack("C*").each_slice(4).flat_map { |r, g, b, 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
+        @window.make_current
+        @textures.each_value { |entry| gl(:glDeleteTextures, [I, P], V, 1, [entry[0]].pack("I")) }
+        @textures.clear
+        gl(:glDeleteBuffers, [I, P], V, 1, [@buffer].pack("I")) if @buffer
+        gl(:glDeleteVertexArrays, [I, P], V, 1, [@vao].pack("I")) if @vao
+        gl(:glDeleteProgram, [I], V, @program) if @program
+      end
+    end
+  end
+end

data/lib/zaniah/gpu/pipeline.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module GPU
+    Pipeline = Data.define(:shader, :blend)
+  end
+end

data/lib/zaniah/gpu/software.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module GPU
+    class Software
+      attr_reader :width, :height, :pixels
+
+      def initialize(width, height)
+        resize(width, height)
+      end
+
+      def resize(width, height)
+        raise ArgumentError, "invalid viewport" unless width.positive? && height.positive? && width * height <= 32_000_000
+        @width, @height = width.to_i, height.to_i
+        @viewport = Bounds.new(0, 0, @width, @height)
+        @pixels = "\0".b * (@width * @height * 4)
+      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")
+        @pixels.replace(Color.parse(clear).to_a.map { |value| (value.clamp(0, 1) * 255).round }.pack("C4") * (@width * @height))
+        scene.each_command do |kind, offset, clip|
+          bounds = clip ? @viewport.intersect(clip) : @viewport
+          case kind
+          when :quad then draw_quad(scene.quads, offset, bounds)
+          when :sprite then draw_sprite(scene, offset, bounds)
+          when :sprite_batch
+            first, count = scene.expand_sprite_batch(offset)
+            count.times { |index| draw_sprite(scene, first + index * 13, bounds) }
+          when :triangle then draw_triangle(scene.paths, offset, bounds)
+          end
+        end
+        @pixels
+      end
+
+      def write_png(path) = PNG.write(path, @width, @height, @pixels)
+      def release = @pixels.clear
+
+      private
+
+      def draw_quad(data, offset, clip)
+        x, y, width, height, red, green, blue, alpha, top_left, top_right, bottom_right, bottom_left, border, border_red, border_green, border_blue, border_alpha = data.slice(offset, Scene::QUAD_STRIDE)
+        bounds = Bounds.new(x, y, width, height).intersect(clip)
+        colors = [[red, green, blue, alpha], [border_red, border_green, border_blue, border_alpha]]
+        top, bottom = [bounds.y.floor, 0].max, [bounds.bottom.ceil, @height].min
+        left, right = [bounds.x.floor, 0].max, [bounds.right.ceil, @width].min
+        pixel_y = top
+        while pixel_y < bottom
+          pixel_x = left
+          while pixel_x < right
+            center_x, center_y = pixel_x + 0.5, pixel_y + 0.5
+            radius = center_y < y + height / 2.0 ? (center_x < x + width / 2.0 ? top_left : top_right) : (center_x < x + width / 2.0 ? bottom_left : bottom_right)
+            radius = radius.clamp(0, [width, height].min / 2.0)
+            quad_x = (center_x - x - width / 2.0).abs - width / 2.0 + radius
+            quad_y = (center_y - y - height / 2.0).abs - height / 2.0 + radius
+            distance = Math.sqrt([quad_x, 0].max**2 + [quad_y, 0].max**2) + [[quad_x, quad_y].max, 0].min - radius
+            coverage = (0.5 - distance).clamp(0, 1)
+            if coverage.positive?
+              color = colors[border.positive? && distance >= -border ? 1 : 0]
+              blend(pixel_x, pixel_y, color[0], color[1], color[2], color[3] * coverage)
+            end
+            pixel_x += 1
+          end
+          pixel_y += 1
+        end
+      end
+
+      def draw_sprite(scene, offset, clip)
+        x, y, width, height, red, green, blue, alpha, id, source_x, source_y, source_width, source_height = scene.sprite_data.slice(offset, 13)
+        return if width <= 0 || height <= 0
+        texture = scene.textures.fetch(id)
+        bounds = Bounds.new(x, y, width, height).intersect(clip)
+        ([bounds.y.ceil, 0].max...[bounds.bottom.ceil, @height].min).each do |pixel_y|
+          ([bounds.x.ceil, 0].max...[bounds.right.ceil, @width].min).each do |pixel_x|
+            texture_x = (source_x + (pixel_x + 0.5 - x) * source_width / width).floor.clamp(0, texture.width - 1)
+            texture_y = (source_y + (pixel_y + 0.5 - y) * source_height / height).floor.clamp(0, texture.height - 1)
+            index = texture_y * texture.width + texture_x
+            if texture.format == :r8
+              blend(pixel_x, pixel_y, red, green, blue, alpha * texture.data.getbyte(index) / 255.0)
+            else
+              pixel = index * 4
+              blend(pixel_x, pixel_y, red * texture.data.getbyte(pixel) / 255.0,
+                green * texture.data.getbyte(pixel + 1) / 255.0,
+                blue * texture.data.getbyte(pixel + 2) / 255.0,
+                alpha * texture.data.getbyte(pixel + 3) / 255.0)
+            end
+          end
+        end
+      end
+
+      def draw_triangle(data, offset, clip)
+        x0, y0, x1, y1, x2, y2, red, green, blue, alpha = data.slice(offset, 10)
+        area = (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0)
+        return if area.zero?
+        bounds = Bounds.new([x0, x1, x2].min, [y0, y1, y2].min,
+          [x0, x1, x2].max - [x0, x1, x2].min,
+          [y0, y1, y2].max - [y0, y1, y2].min).intersect(clip)
+        (bounds.y.floor...bounds.bottom.ceil).each do |pixel_y|
+          (bounds.x.floor...bounds.right.ceil).each do |pixel_x|
+            x, y = pixel_x + 0.5, pixel_y + 0.5
+            u = ((x1 - x) * (y2 - y) - (y1 - y) * (x2 - x)) / area.to_f
+            v = ((x2 - x) * (y0 - y) - (y2 - y) * (x0 - x)) / area.to_f
+            blend(pixel_x, pixel_y, red, green, blue, alpha) if u >= 0 && v >= 0 && u + v <= 1
+          end
+        end
+      end
+
+      def blend(x, y, red, green, blue, alpha)
+        return if alpha <= 0
+        index = (y * @width + x) * 4
+        alpha = alpha.clamp(0, 1)
+        destination_alpha = @pixels.getbyte(index + 3) / 255.0
+        combined_alpha = alpha + destination_alpha * (1 - alpha)
+        [red, green, blue].each_with_index do |value, channel|
+          result = (value * alpha + @pixels.getbyte(index + channel) / 255.0 * destination_alpha * (1 - alpha)) / combined_alpha
+          @pixels.setbyte(index + channel, (result.clamp(0, 1) * 255).round)
+        end
+        @pixels.setbyte(index + 3, (combined_alpha * 255).round)
+      end
+    end
+  end
+end

data/lib/zaniah/gpu/texture.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module GPU
+    class Texture
+      attr_reader :width, :height, :format, :data, :revision
+
+      def initialize(width, height, format: :rgba8, data: nil)
+        raise ArgumentError, "invalid texture" unless width.is_a?(Integer) && height.is_a?(Integer) && width.positive? && height.positive? && [:r8, :rgba8].include?(format)
+        @width, @height, @format = width, height, format
+        @revision = 0
+        @channels = format == :r8 ? 1 : 4
+        @data = data ? data.b.dup : "\0".b * (width * height * @channels)
+        raise ArgumentError, "incorrect texture data size" unless @data.bytesize == width * height * @channels
+      end
+
+      def upload(x, y, width, height, bytes)
+        raise ArgumentError, "texture write out of bounds" if x.negative? || y.negative? || width.negative? || height.negative? || x + width > @width || y + height > @height
+        raise ArgumentError, "incorrect upload size" unless bytes.bytesize == width * height * @channels
+        height.times do |row|
+          @data[((y + row) * @width + x) * @channels, width * @channels] = bytes.byteslice(row * width * @channels, width * @channels)
+        end
+        @revision += 1
+        self
+      end
+
+      def release
+        @data.clear
+        @revision += 1
+      end
+    end
+  end
+end

data/lib/zaniah/gpu/vulkan.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "fiddle/import"
+require_relative "../ffi/library"
+
+module Zaniah
+  module GPU
+    # Minimal offscreen Vulkan path for validating the pure Ruby SPIR-V emitter.
+    # It renders a vertex-index triangle into RGBA8 and reads back native memory.
+    # Window presentation and general Scene rendering remain Metal/OpenGL work.
+    class Vulkan
+      module Types
+        extend Fiddle::Importer
+        Instance = struct ["int s_type", "void *next", "unsigned int flags", "void *application", "unsigned int layer_count", "void *layers", "unsigned int extension_count", "void *extensions"]
+        Queue = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int family", "unsigned int count", "void *priorities"]
+        Device = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int queue_count", "void *queues", "unsigned int layer_count", "void *layers", "unsigned int extension_count", "void *extensions", "void *features"]
+        Image = struct ["int s_type", "void *next", "unsigned int flags", "int image_type", "int format", "unsigned int width", "unsigned int height", "unsigned int depth", "unsigned int mip_levels", "unsigned int layers", "unsigned int samples", "int tiling", "unsigned int usage", "int sharing", "unsigned int family_count", "void *families", "int initial_layout"]
+        Buffer = struct ["int s_type", "void *next", "unsigned int flags", "unsigned long long size", "unsigned int usage", "int sharing", "unsigned int family_count", "void *families"]
+        Allocation = struct ["int s_type", "void *next", "unsigned long long size", "unsigned int type_index"]
+        ImageView = struct ["int s_type", "void *next", "unsigned int flags", "unsigned long long image", "int view_type", "int format", "int components[4]", "unsigned int aspect", "unsigned int mip_level", "unsigned int level_count", "unsigned int array_layer", "unsigned int layer_count"]
+        Attachment = struct ["unsigned int flags", "int format", "unsigned int samples", "int load", "int store", "int stencil_load", "int stencil_store", "int initial_layout", "int final_layout"]
+        Subpass = struct ["unsigned int flags", "int bind_point", "unsigned int input_count", "void *inputs", "unsigned int color_count", "void *colors", "void *resolves", "void *depth_stencil", "unsigned int preserve_count", "void *preserves"]
+        Dependency = struct ["unsigned int source", "unsigned int destination", "unsigned int source_stage", "unsigned int destination_stage", "unsigned int source_access", "unsigned int destination_access", "unsigned int flags"]
+        RenderPass = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int attachment_count", "void *attachments", "unsigned int subpass_count", "void *subpasses", "unsigned int dependency_count", "void *dependencies"]
+        Framebuffer = struct ["int s_type", "void *next", "unsigned int flags", "unsigned long long render_pass", "unsigned int attachment_count", "void *attachments", "unsigned int width", "unsigned int height", "unsigned int layers"]
+        Shader = struct ["int s_type", "void *next", "unsigned int flags", "size_t code_size", "void *code"]
+        Stage = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int stage", "unsigned long long shader", "void *name", "void *specialization"]
+        VertexInput = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int binding_count", "void *bindings", "unsigned int attribute_count", "void *attributes"]
+        Assembly = struct ["int s_type", "void *next", "unsigned int flags", "int topology", "unsigned int primitive_restart"]
+        Viewport = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int viewport_count", "void *viewports", "unsigned int scissor_count", "void *scissors"]
+        Rasterization = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int depth_clamp", "unsigned int discard", "int polygon_mode", "unsigned int cull_mode", "int front_face", "unsigned int depth_bias", "float depth_bias_constant", "float depth_bias_clamp", "float depth_bias_slope", "float line_width"]
+        Multisample = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int samples", "unsigned int sample_shading", "float min_sample_shading", "void *sample_mask", "unsigned int alpha_to_coverage", "unsigned int alpha_to_one"]
+        Blend = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int logic_enable", "int logic_op", "unsigned int attachment_count", "void *attachments", "float constants[4]"]
+        Layout = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int set_count", "void *sets", "unsigned int push_count", "void *pushes"]
+        Pipeline = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int stage_count", "void *stages", "void *vertex_input", "void *assembly", "void *tessellation", "void *viewport", "void *rasterization", "void *multisample", "void *depth_stencil", "void *blend", "void *dynamic", "unsigned long long layout", "unsigned long long render_pass", "unsigned int subpass", "unsigned long long base_pipeline", "int base_index"]
+        CommandPool = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int family"]
+        CommandAllocation = struct ["int s_type", "void *next", "unsigned long long pool", "int level", "unsigned int count"]
+        CommandBegin = struct ["int s_type", "void *next", "unsigned int flags", "void *inheritance"]
+        RenderBegin = struct ["int s_type", "void *next", "unsigned long long render_pass", "unsigned long long framebuffer", "int x", "int y", "unsigned int width", "unsigned int height", "unsigned int clear_count", "void *clears"]
+        MemoryBarrier = struct ["int s_type", "void *next", "unsigned int source_access", "unsigned int destination_access"]
+        Fence = struct ["int s_type", "void *next", "unsigned int flags"]
+        Submit = struct ["int s_type", "void *next", "unsigned int wait_count", "void *wait_semaphores", "void *wait_stages", "unsigned int command_count", "void *commands", "unsigned int signal_count", "void *signal_semaphores"]
+      end
+
+      P, I, U, Q, V = Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_UINT, -Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_VOID
+      attr_reader :width, :height, :pixels, :device_name
+
+      def initialize(width: 128, height: 128)
+        raise ArgumentError, "invalid Vulkan image dimensions" unless [width, height].all? { |n| n.is_a?(Integer) && n.positive? } && width * height <= 16_777_216
+        @width, @height, @arena, @resources, @memories = width, height, [], [], []
+        @lib = FFI::Library.new("libvulkan.so.1", "vulkan-1.dll", "libvulkan.1.dylib", "libMoltenVK.dylib")
+        output = keep("\0".b * 8)
+        check(call(:vkCreateInstance, [P, P, P], I, build(Types::Instance, s_type: 1), 0, output), "vkCreateInstance")
+        @instance = output.unpack1("J")
+        count = keep([0].pack("I"))
+        check(call(:vkEnumeratePhysicalDevices, [P, P, P], I, @instance, count, 0), "vkEnumeratePhysicalDevices")
+        raise Error, "no Vulkan physical device" if count.unpack1("I").zero?
+        physicals = keep("\0".b * (count.unpack1("I") * Fiddle::SIZEOF_VOIDP))
+        check(call(:vkEnumeratePhysicalDevices, [P, P, P], I, @instance, count, physicals), "vkEnumeratePhysicalDevices")
+        @physical = physicals.unpack1("J")
+        properties = keep("\0".b * 4096)
+        call(:vkGetPhysicalDeviceProperties, [P, P], V, @physical, properties)
+        @device_name = properties.byteslice(20, 256).split("\0", 2).first
+        count.replace([0].pack("I"))
+        call(:vkGetPhysicalDeviceQueueFamilyProperties, [P, P, P], V, @physical, count, 0)
+        families = keep("\0".b * (count.unpack1("I") * 24))
+        call(:vkGetPhysicalDeviceQueueFamilyProperties, [P, P, P], V, @physical, count, families)
+        @family = count.unpack1("I").times.find { |index| (families.byteslice(index * 24, 4).unpack1("I") & 1) != 0 }
+        raise Error, "no Vulkan graphics queue" unless @family
+        queue_info = build(Types::Queue, s_type: 2, family: @family, count: 1, priorities: keep([1.0].pack("f")))
+        info = build(Types::Device, s_type: 3, queue_count: 1, queues: queue_info)
+        check(call(:vkCreateDevice, [P, P, P, P], I, @physical, info, 0, output), "vkCreateDevice")
+        @device = output.unpack1("J")
+        call(:vkGetDeviceQueue, [P, U, U, P], V, @device, @family, 0, output)
+        @queue = output.unpack1("J")
+        @memory_properties = keep("\0".b * 1024)
+        call(:vkGetPhysicalDeviceMemoryProperties, [P, P], V, @physical, @memory_properties)
+        create_target
+      rescue StandardError, LoadError
+        release
+        raise
+      end
+
+      def keep(object)
+        @arena << object
+        object
+      end
+      def build(type, **values)
+        object = type.malloc(Fiddle::RUBY_FREE)
+        object.to_ptr[0, type.size] = "\0" * type.size
+        values.each { |name, value| object[name.to_s] = value.is_a?(String) ? Fiddle::Pointer[value] : value }
+        keep(object)
+      end
+      def call(name, arguments, result, *values) = @lib.fn(name, arguments, result, need_gvl: false).call(*values)
+      def check(result, name)
+        raise Error, "#{name} failed with VkResult #{result}" unless result.zero?
+        result
+      end
+      def create(kind, info)
+        output = keep("\0".b * 8)
+        check(call("vkCreate#{kind}", [P, P, P, P], I, @device, info, 0, output), "vkCreate#{kind}")
+        handle = output.unpack1("Q")
+        @resources << ["vkDestroy#{kind}", handle]
+        handle
+      end
+      def allocate_for(kind, handle, required_flags:)
+        requirements = keep("\0".b * 24)
+        call("vkGet#{kind}MemoryRequirements", [P, Q, P], V, @device, handle, requirements)
+        size, _alignment, bits = requirements.unpack("QQI")
+        count = @memory_properties.unpack1("I")
+        index = count.times.find do |n|
+          flags = @memory_properties.byteslice(4 + n * 8, 4).unpack1("I")
+          (bits & (1 << n)) != 0 && (flags & required_flags) == required_flags
+        end
+        raise Error, "Vulkan memory type unavailable (flags #{required_flags})" unless index
+        output = keep("\0".b * 8)
+        info = build(Types::Allocation, s_type: 5, size: size, type_index: index)
+        check(call(:vkAllocateMemory, [P, P, P, P], I, @device, info, 0, output), "vkAllocateMemory")
+        memory = output.unpack1("Q")
+        @memories << memory
+        check(call("vkBind#{kind}Memory", [P, Q, Q, Q], I, @device, handle, memory, 0), "vkBind#{kind}Memory")
+        memory
+      end
+      def create_target
+        @image = create("Image", build(Types::Image, s_type: 14, image_type: 1, format: 37,
+          width: @width, height: @height, depth: 1, mip_levels: 1, layers: 1, samples: 1, usage: 0x11))
+        allocate_for("Image", @image, required_flags: 0)
+        @view = create("ImageView", build(Types::ImageView, s_type: 15, image: @image, view_type: 1,
+          format: 37, aspect: 1, level_count: 1, layer_count: 1))
+        attachment = build(Types::Attachment, format: 37, samples: 1, load: 1, store: 0,
+          stencil_load: 2, stencil_store: 1, initial_layout: 0, final_layout: 6)
+        reference = keep([0, 2].pack("I2"))
+        subpass = build(Types::Subpass, color_count: 1, colors: reference)
+        incoming = build(Types::Dependency, source: 0xffffffff, destination: 0, source_stage: 1,
+          destination_stage: 0x400, destination_access: 0x100)
+        outgoing = build(Types::Dependency, source: 0, destination: 0xffffffff, source_stage: 0x400,
+          destination_stage: 0x1000, source_access: 0x100, destination_access: 0x800)
+        dependencies = keep(incoming.to_ptr[0, Types::Dependency.size] + outgoing.to_ptr[0, Types::Dependency.size])
+        @render_pass = create("RenderPass", build(Types::RenderPass, s_type: 38,
+          attachment_count: 1, attachments: attachment, subpass_count: 1, subpasses: subpass,
+          dependency_count: 2, dependencies: dependencies))
+        @framebuffer = create("Framebuffer", build(Types::Framebuffer, s_type: 37, render_pass: @render_pass,
+          attachment_count: 1, attachments: keep([@view].pack("Q")), width: @width, height: @height, layers: 1))
+        @buffer = create("Buffer", build(Types::Buffer, s_type: 12, size: @width * @height * 4, usage: 2))
+        @read_memory = allocate_for("Buffer", @buffer, required_flags: 6)
+        @pool = create("CommandPool", build(Types::CommandPool, s_type: 39, flags: 2, family: @family))
+        @layout = create("PipelineLayout", build(Types::Layout, s_type: 30))
+      end
+
+      def shader(bytes)
+        unless bytes.is_a?(String) && bytes.bytesize.between?(20, 16_777_216) && (bytes.bytesize % 4).zero? && bytes.unpack1("V") == 0x07230203
+          raise ArgumentError, "expected a SPIR-V word stream"
+        end
+        create("ShaderModule", build(Types::Shader, s_type: 16, code_size: bytes.bytesize, code: keep(bytes)))
+      end
+      def pipeline(vertex_spirv, fragment_spirv)
+        vertex = build(Types::Stage, s_type: 18, stage: 1, shader: shader(vertex_spirv), name: keep("main\0"))
+        fragment = build(Types::Stage, s_type: 18, stage: 16, shader: shader(fragment_spirv), name: keep("main\0"))
+        stages = keep(vertex.to_ptr[0, Types::Stage.size] + fragment.to_ptr[0, Types::Stage.size])
+        vertex_input = build(Types::VertexInput, s_type: 19)
+        assembly = build(Types::Assembly, s_type: 20, topology: 3)
+        viewport = keep([0, 0, @width, @height, 0, 1].pack("f6"))
+        scissor = keep([0, 0, @width, @height].pack("i2I2"))
+        viewport_state = build(Types::Viewport, s_type: 22, viewport_count: 1, viewports: viewport, scissor_count: 1, scissors: scissor)
+        raster = build(Types::Rasterization, s_type: 23, front_face: 1, line_width: 1.0)
+        multisample = build(Types::Multisample, s_type: 24, samples: 1)
+        blend_attachment = keep([0, 1, 0, 0, 1, 0, 0, 15].pack("I8"))
+        blend = build(Types::Blend, s_type: 26, attachment_count: 1, attachments: blend_attachment)
+        info = build(Types::Pipeline, s_type: 28, stage_count: 2, stages: stages,
+          vertex_input: vertex_input, assembly: assembly, viewport: viewport_state,
+          rasterization: raster, multisample: multisample, blend: blend, layout: @layout,
+          render_pass: @render_pass, base_index: -1)
+        output = keep("\0".b * 8)
+        check(call(:vkCreateGraphicsPipelines, [P, Q, U, P, P, P], I, @device, 0, 1, info, 0, output), "vkCreateGraphicsPipelines")
+        result = output.unpack1("Q")
+        @resources << [:vkDestroyPipeline, result]
+        result
+      end
+
+      def render_triangle(vertex_spirv:, fragment_spirv:)
+        raise IOError, "Vulkan device released" unless @device
+        # ponytail: validation submissions retain resources until release;
+        # recycle pipelines/command buffers before using this as a frame loop.
+        pipeline_handle = pipeline(vertex_spirv, fragment_spirv)
+        output = keep("\0".b * 8)
+        info = build(Types::CommandAllocation, s_type: 40, pool: @pool, level: 0, count: 1)
+        check(call(:vkAllocateCommandBuffers, [P, P, P], I, @device, info, output), "vkAllocateCommandBuffers")
+        command = output.unpack1("J")
+        check(call(:vkBeginCommandBuffer, [P, P], I, command, build(Types::CommandBegin, s_type: 42, flags: 1)), "vkBeginCommandBuffer")
+        render = build(Types::RenderBegin, s_type: 43, render_pass: @render_pass, framebuffer: @framebuffer,
+          width: @width, height: @height, clear_count: 1, clears: keep([0, 0, 0, 1].pack("f4")))
+        call(:vkCmdBeginRenderPass, [P, P, I], V, command, render, 0)
+        call(:vkCmdBindPipeline, [P, I, Q], V, command, 0, pipeline_handle)
+        call(:vkCmdDraw, [P, U, U, U, U], V, command, 3, 1, 0, 0)
+        call(:vkCmdEndRenderPass, [P], V, command)
+        region = keep([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, @width, @height, 1].pack("Q I2 I4 i3 I3"))
+        call(:vkCmdCopyImageToBuffer, [P, Q, I, Q, U, P], V, command, @image, 6, @buffer, 1, region)
+        barrier = build(Types::MemoryBarrier, s_type: 46, source_access: 0x1000, destination_access: 0x2000)
+        call(:vkCmdPipelineBarrier, [P, U, U, U, U, P, U, P, U, P], V, command, 0x1000, 0x4000, 0, 1, barrier, 0, 0, 0, 0)
+        check(call(:vkEndCommandBuffer, [P], I, command), "vkEndCommandBuffer")
+        fence = create("Fence", build(Types::Fence, s_type: 8))
+        submit = build(Types::Submit, s_type: 4, command_count: 1, commands: keep([command].pack("J")))
+        check(call(:vkQueueSubmit, [P, U, P, Q], I, @queue, 1, submit, fence), "vkQueueSubmit")
+        check(call(:vkWaitForFences, [P, U, P, U, Q], I, @device, 1, keep([fence].pack("Q")), 1, 10_000_000_000), "vkWaitForFences")
+        check(call(:vkMapMemory, [P, Q, Q, Q, U, P], I, @device, @read_memory, 0, @width * @height * 4, 0, output), "vkMapMemory")
+        begin
+          @pixels = Fiddle::Pointer.new(output.unpack1("J"))[0, @width * @height * 4]
+        ensure
+          call(:vkUnmapMemory, [P, Q], V, @device, @read_memory)
+        end
+        @pixels
+      end
+      def write_png(path)
+        raise Error, "render a Vulkan frame before capture" unless @pixels
+        PNG.write(path, @width, @height, @pixels)
+      end
+      def release
+        if @device
+          call(:vkDeviceWaitIdle, [P], I, @device)
+          @resources.reverse_each { |name, handle| call(name, [P, Q, P], V, @device, handle, 0) }
+          @memories.each { |memory| call(:vkFreeMemory, [P, Q, P], V, @device, memory, 0) }
+          call(:vkDestroyDevice, [P, P], V, @device, 0)
+          @device = nil
+        end
+        call(:vkDestroyInstance, [P, P], V, @instance, 0) if @instance
+        @instance = nil
+        @resources&.clear
+        @memories&.clear
+        @arena&.clear
+      end
+    end
+  end
+end

data/lib/zaniah/gpu.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "gpu/buffer"
+require_relative "gpu/texture"
+require_relative "gpu/pipeline"
+require_relative "gpu/frame_encoder"
+require_relative "gpu/software"
+
+module Zaniah
+  module GPU
+    def self.create(window = nil, backend: :software, width: nil, height: nil)
+      return window.create_device(backend) if window && backend != :software
+      raise ArgumentError, "backend requires a native window" unless backend == :software
+      size = window&.content_size
+      Software.new(width || size&.width || 800, height || size&.height || 600)
+    end
+  end
+end

data/lib/zaniah/hsla.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Zaniah
+  HSLA = Data.define(:h, :s, :l, :a) do
+    def to_rgba
+      chroma = (1 - (2 * l - 1).abs) * s
+      phase = (h % 1.0) * 6
+      x = chroma * (1 - (phase % 2 - 1).abs)
+      values = [[chroma, x, 0], [x, chroma, 0], [0, chroma, x],
+        [0, x, chroma], [x, 0, chroma], [chroma, 0, x]][phase.floor]
+      Color.new(*values.map { |value| value + l - chroma / 2.0 }, a)
+    end
+  end
+end