zaniah 0.2.0 → 0.3.0

data/lib/zaniah/gpu/vulkan.rb

@@ -2,13 +2,13 @@
 
 require "fiddle/import"
 require_relative "../ffi/library"
+require_relative "instance_packing"
 
 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.
+    # Offscreen Vulkan renderer and user-supplied SPIR-V validation path.
     class Vulkan
+      INSTANCE_STRIDE = InstancePacking::STRIDE
       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"]
@@ -26,11 +26,15 @@ module Zaniah
         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"]
+        VertexBinding = struct ["unsigned int binding", "unsigned int stride", "int input_rate"]
+        VertexAttribute = struct ["unsigned int location", "unsigned int binding", "int format", "unsigned int offset"]
         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]"]
+        Dynamic = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int count", "void *states"]
+        PushConstant = struct ["unsigned int stage_flags", "unsigned int offset", "unsigned int size"]
         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"]
@@ -38,16 +42,28 @@ module Zaniah
         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"]
+        ImageBarrier = struct ["int s_type", "void *next", "unsigned int source_access", "unsigned int destination_access", "int old_layout", "int new_layout", "unsigned int source_family", "unsigned int destination_family", "unsigned long long image", "unsigned int aspect", "unsigned int mip_level", "unsigned int level_count", "unsigned int array_layer", "unsigned int layer_count"]
         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"]
+        DescriptorBinding = struct ["unsigned int binding", "int descriptor_type", "unsigned int count", "unsigned int stage_flags", "void *immutable_samplers"]
+        DescriptorLayout = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int count", "void *bindings"]
+        DescriptorPoolSize = struct ["int descriptor_type", "unsigned int count"]
+        DescriptorPool = struct ["int s_type", "void *next", "unsigned int flags", "unsigned int max_sets", "unsigned int count", "void *sizes"]
+        DescriptorAllocation = struct ["int s_type", "void *next", "unsigned long long pool", "unsigned int count", "void *layouts"]
+        DescriptorImage = struct ["unsigned long long sampler", "unsigned long long view", "int layout"]
+        DescriptorWrite = struct ["int s_type", "void *next", "unsigned long long set", "unsigned int binding", "unsigned int array_element", "unsigned int count", "int descriptor_type", "void *images", "void *buffers", "void *texel_views"]
+        Sampler = struct ["int s_type", "void *next", "unsigned int flags", "int mag_filter", "int min_filter", "int mipmap_mode", "int address_u", "int address_v", "int address_w", "float mip_lod_bias", "unsigned int anisotropy", "float max_anisotropy", "unsigned int compare", "int compare_op", "float min_lod", "float max_lod", "int border_color", "unsigned int unnormalized"]
       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
+      attr_reader :width, :height, :pixels, :device_name, :draw_calls
 
       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, [], [], []
+        @native_textures, @scene_pipelines = {}, {}
+        @instance_buffer = @instance_memory = @instance_capacity = nil
+        @pixels = @draw_calls = nil
         @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")
@@ -76,6 +92,7 @@ module Zaniah
         @memory_properties = keep("\0".b * 1024)
         call(:vkGetPhysicalDeviceMemoryProperties, [P, P], V, @physical, @memory_properties)
         create_target
+        @arena.clear
       rescue StandardError, LoadError
         release
         raise
@@ -144,7 +161,18 @@ module Zaniah
         @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))
+        binding = build(Types::DescriptorBinding, descriptor_type: 1, count: 1, stage_flags: 16)
+        @descriptor_layout = create("DescriptorSetLayout",
+          build(Types::DescriptorLayout, s_type: 32, count: 1, bindings: binding))
+        pool_size = build(Types::DescriptorPoolSize, descriptor_type: 1, count: 4096)
+        @descriptor_pool = create("DescriptorPool",
+          build(Types::DescriptorPool, s_type: 33, max_sets: 4096, count: 1, sizes: pool_size))
+        @sampler = create("Sampler", build(Types::Sampler, s_type: 31, mag_filter: 0, min_filter: 0,
+          mipmap_mode: 0, address_u: 2, address_v: 2, address_w: 2, max_lod: 1.0))
+        push = build(Types::PushConstant, stage_flags: 1, size: 8)
+        @layout = create("PipelineLayout", build(Types::Layout, s_type: 30,
+          set_count: 1, sets: keep([@descriptor_layout].pack("Q")), push_count: 1, pushes: push))
+        @white = Texture.new(1, 1, data: "\xff".b * 4)
       end
 
       def shader(bytes)
@@ -153,62 +181,277 @@ module Zaniah
         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"))
+      def pipeline(vertex_spirv, fragment_spirv, topology: 3, instanced: false)
+        vertex_shader, fragment_shader = shader(vertex_spirv), shader(fragment_spirv)
+        vertex = build(Types::Stage, s_type: 18, stage: 1, shader: vertex_shader, name: keep("main\0"))
+        fragment = build(Types::Stage, s_type: 18, stage: 16, shader: fragment_shader, 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)
+        vertex_input = if instanced
+          binding = build(Types::VertexBinding, stride: INSTANCE_STRIDE * 4, input_rate: 1)
+          attributes = 10.times.map do |location|
+            value = build(Types::VertexAttribute, location: location, format: 109, offset: location * 16)
+            value.to_ptr[0, Types::VertexAttribute.size]
+          end.join
+          build(Types::VertexInput, s_type: 19, binding_count: 1, bindings: binding,
+            attribute_count: 10, attributes: keep(attributes))
+        else
+          build(Types::VertexInput, s_type: 19)
+        end
+        assembly = build(Types::Assembly, s_type: 20, topology: topology)
         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_attachment = keep([1, 1, 7, 0, 1, 7, 0, 15].pack("I8"))
         blend = build(Types::Blend, s_type: 26, attachment_count: 1, attachments: blend_attachment)
+        dynamic = build(Types::Dynamic, s_type: 27, count: 1, states: keep([1].pack("I")))
         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,
+          rasterization: raster, multisample: multisample, blend: blend, dynamic: dynamic, 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
+      ensure
+        destroy_resource(:vkDestroyShaderModule, vertex_shader) if vertex_shader
+        destroy_resource(:vkDestroyShaderModule, fragment_shader) if fragment_shader
       end
 
-      def render_triangle(vertex_spirv:, fragment_spirv:)
+      def render(scene, clear: "#0000")
         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)
+        arena_start = @arena.length
+        bytes, batches = InstancePacking.pack(scene)
+        command = begin_command
+        submitted = false
+        transients = []
+        descriptors = batches.map { |(_kind, texture, _clip), _first, _count| prepare_texture(texture || @white, command, transients) }
+        upload_instances(bytes) unless bytes.empty?
+        render_pass(command, clear)
+        @draw_calls = 0
+        unless bytes.empty?
+          call(:vkCmdBindVertexBuffers, [P, U, U, P, P], V, command, 0, 1,
+            keep([@instance_buffer].pack("Q")), keep([0].pack("Q")))
+          call(:vkCmdPushConstants, [P, Q, U, U, U, P], V, command, @layout, 1, 0, 8,
+            keep([@width.to_f, @height.to_f].pack("f2")))
+          batches.each_with_index do |((kind, _texture, clip), first, count), index|
+            scissor = scissor_bytes(clip)
+            next unless scissor
+            call(:vkCmdSetScissor, [P, U, U, P], V, command, 0, 1, keep(scissor))
+            pipeline_handle = scene_pipeline(kind)
+            call(:vkCmdBindPipeline, [P, I, Q], V, command, 0, pipeline_handle)
+            descriptor = descriptors[index]
+            call(:vkCmdBindDescriptorSets, [P, I, Q, U, U, P, U, P], V,
+              command, 0, @layout, 0, 1, keep([descriptor].pack("Q")), 0, 0)
+            vertices = kind == :triangle ? 3 : 4
+            call(:vkCmdDraw, [P, U, U, U, U], V, command, vertices, count, 0, first)
+            @draw_calls += 1
+          end
+        end
+        call(:vkCmdEndRenderPass, [P], V, command)
+        copy_target(command)
+        submitted = true
+        @pixels = submit(command, read: true)
+      ensure
+        free_command(command) if command && !submitted
+        transients&.each { |buffer, memory| destroy_buffer_memory(buffer, memory) }
+        @arena&.slice!(arena_start, @arena.length - arena_start) if arena_start
+      end
+
+      def resize(width, height)
+        width, height = Integer(width), Integer(height)
+        raise ArgumentError, "invalid Vulkan image dimensions" unless [width, height].all?(&:positive?) && width * height <= 16_777_216
+        return if width == @width && height == @height
+        release
+        initialize(width: width, height: height)
+      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 scene_pipeline(kind)
+        topology = kind == :triangle ? 3 : 4
+        (@scene_pipelines ||= {})[topology] ||= begin
+          directory = File.join(__dir__, "vulkan")
+          pipeline(File.binread(File.join(directory, "scene.vert.spv")),
+            File.binread(File.join(directory, "scene.frag.spv")), topology: topology, instanced: true)
+        end
+      end
+
+      def begin_command
         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)
+        check(call(:vkBeginCommandBuffer, [P, P], I, command,
+          build(Types::CommandBegin, s_type: 42, flags: 1)), "vkBeginCommandBuffer")
+        command
+      end
+
+      def render_pass(command, clear)
+        color = Color.parse(clear).premultiplied
+        info = build(Types::RenderBegin, s_type: 43, render_pass: @render_pass, framebuffer: @framebuffer,
+          width: @width, height: @height, clear_count: 1, clears: keep(color.pack("f4")))
+        call(:vkCmdBeginRenderPass, [P, P, I], V, command, info, 0)
+      end
+
+      def upload_instances(bytes)
+        if !@instance_buffer || @instance_capacity < bytes.bytesize
+          destroy_buffer_memory(@instance_buffer, @instance_memory) if @instance_buffer
+          @instance_capacity = [bytes.bytesize, 4096].max
+          @instance_buffer = create("Buffer", build(Types::Buffer, s_type: 12,
+            size: @instance_capacity, usage: 0x80))
+          @instance_memory = allocate_for("Buffer", @instance_buffer, required_flags: 6)
+        end
+        output = keep("\0".b * 8)
+        check(call(:vkMapMemory, [P, Q, Q, Q, U, P], I, @device, @instance_memory,
+          0, bytes.bytesize, 0, output), "vkMapMemory")
+        Fiddle::Pointer.new(output.unpack1("J"))[0, bytes.bytesize] = bytes
+        call(:vkUnmapMemory, [P, Q], V, @device, @instance_memory)
+      end
+
+      def prepare_texture(texture, command, transients)
+        entry = @native_textures[texture]
+        return entry[:descriptor] if entry && entry[:revision] == texture.revision
+        if entry
+          destroy_resource(:vkDestroyImageView, entry[:view])
+          destroy_resource(:vkDestroyImage, entry[:image])
+          free_memory(entry[:memory])
+        else
+          output = keep("\0".b * 8)
+          info = build(Types::DescriptorAllocation, s_type: 34, pool: @descriptor_pool,
+            count: 1, layouts: keep([@descriptor_layout].pack("Q")))
+          check(call(:vkAllocateDescriptorSets, [P, P, P], I, @device, info, output), "vkAllocateDescriptorSets")
+          entry = {descriptor: output.unpack1("Q")}
+          @native_textures[texture] = entry
+        end
+        entry[:image] = create("Image", build(Types::Image, s_type: 14, image_type: 1,
+          format: texture.format == :r8 ? 9 : 37, width: texture.width, height: texture.height,
+          depth: 1, mip_levels: 1, layers: 1, samples: 1, usage: 6))
+        entry[:memory] = allocate_for("Image", entry[:image], required_flags: 0)
+        entry[:view] = create("ImageView", build(Types::ImageView, s_type: 15, image: entry[:image],
+          view_type: 1, format: texture.format == :r8 ? 9 : 37, aspect: 1, level_count: 1, layer_count: 1))
+        staging = create("Buffer", build(Types::Buffer, s_type: 12, size: texture.data.bytesize, usage: 1))
+        staging_memory = allocate_for("Buffer", staging, required_flags: 6)
+        upload_memory(staging_memory, texture.data)
+        transition_image(command, entry[:image], 0, 7, 0, 0x1000, 1, 0x1000)
+        region = keep([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, texture.width, texture.height, 1].pack("Q I2 I4 i3 I3"))
+        call(:vkCmdCopyBufferToImage, [P, Q, Q, I, U, P], V,
+          command, staging, entry[:image], 7, 1, region)
+        transition_image(command, entry[:image], 7, 5, 0x1000, 0x20, 0x1000, 0x80)
+        image = build(Types::DescriptorImage, sampler: @sampler, view: entry[:view], layout: 5)
+        write = build(Types::DescriptorWrite, s_type: 35, set: entry[:descriptor], count: 1,
+          descriptor_type: 1, images: image)
+        call(:vkUpdateDescriptorSets, [P, U, P, U, P], V, @device, 1, write, 0, 0)
+        entry[:revision] = texture.revision
+        transients << [staging, staging_memory]
+        entry[:descriptor]
+      end
+
+      def upload_memory(memory, bytes)
+        output = keep("\0".b * 8)
+        check(call(:vkMapMemory, [P, Q, Q, Q, U, P], I, @device, memory,
+          0, bytes.bytesize, 0, output), "vkMapMemory")
+        Fiddle::Pointer.new(output.unpack1("J"))[0, bytes.bytesize] = bytes
+        call(:vkUnmapMemory, [P, Q], V, @device, memory)
+      end
+
+      def transition_image(command, image, old_layout, new_layout, source_access, destination_access, source_stage, destination_stage)
+        barrier = build(Types::ImageBarrier, s_type: 45, source_access: source_access,
+          destination_access: destination_access, old_layout: old_layout, new_layout: new_layout,
+          source_family: 0xffffffff, destination_family: 0xffffffff, image: image,
+          aspect: 1, level_count: 1, layer_count: 1)
+        call(:vkCmdPipelineBarrier, [P, U, U, U, U, P, U, P, U, P], V,
+          command, source_stage, destination_stage, 0, 0, 0, 0, 0, 1, barrier)
+      end
+
+      def scissor_bytes(clip)
+        return [0, 0, @width, @height].pack("i2I2") unless clip
+        left, top = [clip.x.floor, 0].max, [clip.y.floor, 0].max
+        right, bottom = [clip.right.ceil, @width].min, [clip.bottom.ceil, @height].min
+        return if left >= right || top >= bottom
+        [left, top, right - left, bottom - top].pack("i2I2")
+      end
+
+      def copy_target(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)
+        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)
+      end
+
+      def submit(command, read: false)
         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
+        info = build(Types::Submit, s_type: 4, command_count: 1, commands: keep([command].pack("J")))
+        check(call(:vkQueueSubmit, [P, U, P, Q], I, @queue, 1, info, fence), "vkQueueSubmit")
+        check(call(:vkWaitForFences, [P, U, P, U, Q], I, @device, 1,
+          keep([fence].pack("Q")), 1, 10_000_000_000), "vkWaitForFences")
+        read ? read_target : nil
+      ensure
+        destroy_resource(:vkDestroyFence, fence) if fence
+        free_command(command)
+      end
+
+      def free_command(command)
+        call(:vkFreeCommandBuffers, [P, Q, U, P], V,
+          @device, @pool, 1, [command].pack("J")) if command && @device
+      end
+
+      def read_target
+        output = keep("\0".b * 8)
+        check(call(:vkMapMemory, [P, Q, Q, Q, U, P], I, @device, @read_memory,
+          0, @width * @height * 4, 0, output), "vkMapMemory")
+        bytes = Fiddle::Pointer.new(output.unpack1("J"))[0, @width * @height * 4]
+        bytes.bytes.each_slice(4).flat_map do |red, green, blue, alpha|
+          alpha.zero? ? [0, 0, 0, 0] : [[red * 255 / alpha, 255].min,
+            [green * 255 / alpha, 255].min, [blue * 255 / alpha, 255].min, alpha]
+        end.pack("C*")
+      ensure
+        call(:vkUnmapMemory, [P, Q], V, @device, @read_memory) if output&.unpack1("J").to_i.positive?
+      end
+
+      def destroy_resource(name, handle)
+        return unless handle
+        call(name, [P, Q, P], V, @device, handle, 0)
+        @resources.delete_if { |_function, value| value == handle }
+      end
+
+      def free_memory(memory)
+        return unless memory
+        call(:vkFreeMemory, [P, Q, P], V, @device, memory, 0)
+        @memories.delete(memory)
+      end
+
+      def destroy_buffer_memory(buffer, memory)
+        destroy_resource(:vkDestroyBuffer, buffer)
+        free_memory(memory)
+      end
+
+      def render_triangle(vertex_spirv:, fragment_spirv:)
+        raise IOError, "Vulkan device released" unless @device
+        arena_start = @arena.length
+        pipeline_handle = pipeline(vertex_spirv, fragment_spirv)
+        command = begin_command
+        submitted = false
+        render_pass(command, "#000f")
+        call(:vkCmdSetScissor, [P, U, U, P], V, command, 0, 1, keep(scissor_bytes(nil)))
+        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)
+        copy_target(command)
+        submitted = true
+        @pixels = submit(command, read: true)
+      ensure
+        free_command(command) if command && !submitted
+        destroy_resource(:vkDestroyPipeline, pipeline_handle) if pipeline_handle
+        @arena&.slice!(arena_start, @arena.length - arena_start) if arena_start
       end
       def write_png(path)
         raise Error, "render a Vulkan frame before capture" unless @pixels
@@ -227,6 +470,9 @@ module Zaniah
         @resources&.clear
         @memories&.clear
         @arena&.clear
+        @native_textures&.clear
+        @scene_pipelines&.clear
+        @instance_buffer = @instance_memory = @instance_capacity = nil
       end
     end
   end

data/lib/zaniah/gpu.rb

@@ -9,10 +9,15 @@ 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)
+      return window.create_device(backend) if window && !%i[software vulkan].include?(backend)
+      dimensions = [(width || size&.width || 800).to_i, (height || size&.height || 600).to_i]
+      return Software.new(*dimensions) if backend == :software
+      if backend == :vulkan
+        require_relative "gpu/vulkan"
+        return Vulkan.new(width: dimensions[0], height: dimensions[1])
+      end
+      raise ArgumentError, "backend requires a native window"
     end
   end
 end

data/lib/zaniah/input/dispatcher.rb

@@ -5,34 +5,90 @@ module Zaniah
     Hit = Data.define(:bounds, :owner)
 
     class Dispatcher
-      attr_reader :focused
+      attr_reader :focused, :focus_origin, :focus_tree
 
-      def initialize(keymap: Keymap.new)
+      def initialize(keymap: Keymap.default_ui)
         @keymap, @hits = keymap, []
+        @transforms = [Transform.identity]
+        @focus_tree = FocusTree.new
       end
 
-      def focus(handle)
-        return if @focused == handle
+      def focus(handle, origin: :programmatic)
+        return unless handle.nil? || handle.focusable
+        @focus_tree.register(handle) if handle
+        if @focused == handle
+          @focus_origin = origin
+          return
+        end
         @focused&.on_focus&.call(false)
-        @focused = handle
+        @focused, @focus_origin = handle, origin
         handle&.on_focus&.call(true)
+        reveal(handle)
       end
 
+      def focus_visible? = @focus_origin == :keyboard
+
       def key(key)
         chain = @focused ? @focused.ancestors : []
         context = chain.reverse.each_with_object({}) { |handle, result| result.merge!(handle.context) }
         action = @keymap.dispatch(key, context: context)
         return action if action.nil? || action == :pending
+        target = case action
+        when :focus_next then @focus_tree.next(@focused)
+        when :focus_previous then @focus_tree.previous(@focused)
+        when :focus_left then @focus_tree.spatial(@focused, :left)
+        when :focus_right then @focus_tree.spatial(@focused, :right)
+        when :focus_up then @focus_tree.spatial(@focused, :up)
+        when :focus_down then @focus_tree.spatial(@focused, :down)
+        end
+        if target
+          focus(target, origin: :keyboard)
+          return action
+        end
         chain.each { |handle| break if handle.on_action&.call(action) }
         action
       end
 
-      def clear_hits = @hits.clear
-      def hits = @hits.map { |bounds, _, owner| Hit.new(bounds, owner) }.freeze
+      def register_focus(handle)
+        owner = handle.owner&.respond_to?(:parent) ? handle.owner.parent : nil
+        while owner
+          if owner.respond_to?(:focus_handle) && (parent = owner.focus_handle)
+            unless parent.equal?(handle)
+              handle.parent = parent
+              break
+            end
+          end
+          owner = owner.respond_to?(:parent) ? owner.parent : nil
+        end
+        @focus_tree.register(handle)
+      end
 
-      def hit(bounds, clip: nil, owner: nil, &handler)
-        bounds = bounds.intersect(@clip) if @clip
-        @hits << [clip ? bounds.intersect(clip) : bounds, handler, owner]
+      def input(event)
+        return false unless @focused
+        @focused.ancestors.each { |handle| return true if handle.on_input&.call(event) }
+        false
+      end
+
+      def clear_hits
+        @hits.clear
+        @focus_tree.clear
+        @transforms.replace([Transform.identity])
+      end
+      def hits = @hits.map { |bounds, _, owner, _, clip| Hit.new(clip ? bounds.intersect(clip) : bounds, owner) }.freeze
+
+      def hover_chain(position)
+        return [] unless position
+        owner = @hits.reverse_each.find { |hit| hit_contains?(hit, position) }&.[](2)
+        [].tap do |chain|
+          while owner
+            chain << owner
+            owner = owner.respond_to?(:parent) ? owner.parent : nil
+          end
+        end
+      end
+
+      def hit(bounds, clip: nil, owner: nil, transform: @transforms.last, &handler)
+        @hits << [bounds, handler, owner, transform, clip || @clip]
       end
 
       def clip(bounds)
@@ -43,20 +99,48 @@ module Zaniah
         @clip = previous
       end
 
+      def push_transform(transform)
+        raise ArgumentError, "expected a Transform" unless transform.is_a?(Transform)
+        @transforms << @transforms.last.compose(transform)
+        pushed = true
+        yield
+      ensure
+        @transforms.pop if pushed
+      end
+
       def mouse(event)
         if @capture
           @capture.call(event)
           @capture = nil if event.is_a?(MouseUp)
           return true
         end
-        @hits.reverse_each do |bounds, handler, _owner|
-          next unless bounds.contains?(event.position)
+        @hits.reverse_each do |hit|
+          next unless hit_contains?(hit, event.position)
+          handler = hit[1]
           handled = handler.call(event)
           @capture = handler if handled == :capture && event.is_a?(MouseDown)
           return true if handled
         end
         false
       end
+
+      private
+
+      def hit_contains?(hit, position)
+        bounds, _, _, transform, clip = hit
+        return false if clip && !clip.contains?(position)
+        bounds.contains?(transform.inverse.apply(position))
+      rescue ArgumentError
+        false
+      end
+
+      def reveal(handle)
+        owner, bounds = handle&.owner, handle&.bounds
+        while owner
+          owner.scroll_to(bounds, align: :nearest) if bounds && owner.is_a?(ScrollView)
+          owner = owner.respond_to?(:parent) ? owner.parent : nil
+        end
+      end
     end
   end
 end

data/lib/zaniah/input/focus_handle.rb

@@ -3,11 +3,12 @@
 module Zaniah
   module Input
     class FocusHandle
-      attr_reader :parent, :children, :context
-      attr_accessor :on_action, :on_focus
+      attr_reader :parent, :children, :context, :owner
+      attr_accessor :on_action, :on_focus, :on_input, :tab_index, :focusable, :bounds
 
-      def initialize(parent: nil, context: {})
-        @parent, @context, @children = parent, context, []
+      def initialize(parent: nil, context: {}, owner: nil, tab_index: nil, focusable: true, bounds: nil)
+        @parent, @context, @owner, @children = parent, context, owner, []
+        @tab_index, @focusable, @bounds = tab_index, focusable, bounds
         parent&.children&.push(self)
       end
 
@@ -19,6 +20,14 @@ module Zaniah
         end
         list
       end
+
+      def parent=(value)
+        raise ArgumentError, "focus handle cannot parent itself" if value.equal?(self)
+        return if @parent.equal?(value)
+        @parent&.children&.delete(self)
+        @parent = value
+        value&.children&.push(self) unless value&.children&.include?(self)
+      end
     end
   end
 end