vulkan-ruby 0.1.0

data/lib/vulkan/conversions.rb

@@ -0,0 +1,511 @@
+module Vulkan
+  module Conversions
+    IMAGE_FORMATS = {}
+    IMAGE_TILING = {}
+    DESCRIPTOR_TYPES = {}
+    BUFFER_USAGE_BITS = {}
+    IMAGE_USAGE_BITS = {}
+    IMAGE_TYPES = {}
+    SHADER_STAGE_BITS = {}
+    SHARING_MODES = {}
+    IMAGE_CREATE_BITS = {}
+    PIPELINE_STAGE_BITS = {}
+    DEPENDENCY_FLAG_BITS = {}
+    IMAGE_ASPECT_BITS = {}
+    ACCESS_MASK_BITS = {}
+    FILTERS = {}
+    SAMPLER_ADDRESS_MODES = {}
+    SAMPLER_MIPMAP_MODES = {}
+    COMPARE_OPS = {}
+    BORDER_COLORS = {}
+    MEMORY_PROPERTIES = {}
+    FORMAT_FEATURE_BITS = {}
+    VERTEX_INPUT_RATES = {}
+    PRESENT_MODES = {}
+    SURFACE_TRANSFORMS = {}
+    DYNAMIC_STATES = {}
+
+    Vulkan.constants.each do |name|
+      output = case name.to_s
+               when /^VK_FORMAT_FEATURE_(.*?)_BIT/     then FORMAT_FEATURE_BITS
+               when /^VK_FORMAT_(.*?)$/                then IMAGE_FORMATS
+               when /^VK_IMAGE_TILING_(.*?)$/          then IMAGE_TILING
+               when /^VK_DESCRIPTOR_TYPE_(.*?)$/       then DESCRIPTOR_TYPES
+               when /^VK_BUFFER_USAGE_(.*?)_BIT/       then BUFFER_USAGE_BITS
+               when /^VK_IMAGE_USAGE_(.*?)_BIT/        then IMAGE_USAGE_BITS
+               when /^VK_IMAGE_TYPE_(.*?)$/            then IMAGE_TYPES
+               when /^VK_IMAGE_ASPECT_(.*?)_BIT/       then IMAGE_ASPECT_BITS
+               when /^VK_SHADER_STAGE_(.*?)(?:_BIT|$)/ then SHADER_STAGE_BITS
+               when /^VK_SHARING_MODE_(.*?)$/          then SHARING_MODES
+               when /^VK_IMAGE_CREATE_(.*?)_BIT/       then IMAGE_CREATE_BITS
+               when /^VK_PIPELINE_STAGE_(.*?)_BIT/     then PIPELINE_STAGE_BITS
+               when /^VK_DEPENDENCY_(.*?)_BIT/         then DEPENDENCY_FLAG_BITS
+               when /^VK_ACCESS_(.*?)_BIT/             then ACCESS_MASK_BITS
+               when /^VK_FILTER_(.*?)$/                then FILTERS
+               when /^VK_SAMPLER_ADDRESS_MODE_(.*?)$/  then SAMPLER_ADDRESS_MODES
+               when /^VK_COMPARE_OP_(.*?)$/            then COMPARE_OPS
+               when /^VK_BORDER_COLOR_(.*?)$/          then BORDER_COLORS
+               when /^VK_SAMPLER_MIPMAP_MODE_(.*?)$/   then SAMPLER_MIPMAP_MODES
+               when /^VK_MEMORY_PROPERTY_(.*?)_BIT/    then MEMORY_PROPERTIES
+               when /^VK_VERTEX_INPUT_RATE_(.*?)$/     then VERTEX_INPUT_RATES
+               when /^VK_PRESENT_MODE_(.*?)(?:_KHR)?$/ then PRESENT_MODES
+               when /^VK_SURFACE_TRANSFORM_(.*?)_BIT/  then SURFACE_TRANSFORMS
+               when /^VK_DYNAMIC_STATE_(.*)/           then DYNAMIC_STATES
+               else next
+               end
+      key = $1.downcase
+      raise 'BUG: two identical constant names? %s => %s' % [name, key] if output.include?(key)
+      output[key.to_sym] = output[key] = Vulkan.const_get(name)
+    end
+
+    def sym_to_present_mode(sym)
+      PRESENT_MODES[sym]
+    end
+
+    def present_mode_to_sym(mode)
+      PRESENT_MODES.key(mode)&.to_sym
+    end
+
+    def sym_to_samples(sym)
+      # 4 => 4 because VK_SAMPLE_COUNT_4_BIT == 4.
+      # But we'll keep this method here in case that changes or is not always
+      # true.
+      sym
+    end
+
+    def sym_to_dynamic_state(sym)
+      DYNAMIC_STATES[sym]
+    end
+
+    def syms_to_surface_transforms(sym)
+      syms_to_flags sym, SURFACE_TRANSFORMS
+    end
+
+    def sym_to_val(sym, vals)
+      vals[sym] || sym
+    end
+
+    def syms_to_flags(syms, bits)
+      [syms].flatten.reduce(0) { |bit, sym| bit | sym_to_val(sym, bits) }
+    end
+
+    def flags_to_syms(flags, bits)
+      return flags   if flags.kind_of?(Array)
+      return [flags] if flags.kind_of?(Symbol)
+      bits.reduce([]) do |syms, (name, bit)|
+        syms << name if flags & bit != 0
+        syms
+      end
+      syms
+    end
+
+    def sym_to_vertex_input_rate(sym)
+      sym_to_val(sym, VERTEX_INPUT_RATES)
+    end
+
+    def sym_to_compare_op(sym)
+      sym_to_val(sym, COMPARE_OPS)
+    end
+
+    def syms_to_buffer_usage_flags(syms)
+      syms_to_flags(syms, BUFFER_USAGE_BITS)
+    end
+
+    def buffer_usage_flags_to_syms(bits)
+      flags_to_syms(bits, BUFFER_USAGE_BITS)
+    end
+
+    def syms_to_format_feature_flags(syms)
+      syms_to_flags(syms, FORMAT_FEATURE_BITS)
+    end
+
+    def syms_to_access_mask(syms)
+      syms_to_flags(syms, ACCESS_MASK_BITS)
+    end
+
+    def syms_to_memory_properties(syms)
+      syms_to_flags(syms, MEMORY_PROPERTIES)
+    end
+
+    def sym_to_border_color(sym)
+      sym_to_val(sym, BORDER_COLORS)
+    end
+
+    def bool_to_vk(bool)
+      bool ? VK_TRUE : VK_FALSE
+    end
+
+    def syms_to_pipeline_stage_flags(syms)
+      syms_to_flags(syms, PIPELINE_STAGE_BITS)
+    end
+
+    def syms_to_image_aspect_flags(syms)
+      syms_to_flags(syms, IMAGE_ASPECT_BITS)
+    end
+
+    def syms_to_dependency_flags(syms)
+      syms_to_flags(syms, DEPENDENCY_FLAG_BITS)
+    end
+
+    def syms_to_image_create_flags(syms)
+      syms_to_flags(syms, IMAGE_CREATE_BITS)
+    end
+
+    def sym_to_filter(sym)
+      sym_to_val sym, FILTERS
+    end
+
+    def sym_to_sampler_address_mode(sym)
+      sym_to_val sym, SAMPLER_ADDRESS_MODES
+    end
+
+    def sym_to_sampler_mipmap_mode(sym)
+      sym_to_val sym, SAMPLER_MIPMAP_MODES
+    end
+
+    def sym_to_image_tiling(sym)
+      sym_to_val sym, IMAGE_TILING
+    end
+
+    def syms_to_image_usage_flags(syms)
+      syms_to_flags(syms, IMAGE_USAGE_BITS)
+    end
+
+    def sym_to_image_format(sym)
+      sym_to_val sym, IMAGE_FORMATS
+    end
+
+    alias sym_to_format sym_to_image_format
+
+    def sym_to_image_type(sym)
+      # can't let it be a number because if it is numeric then it might
+      # need to be passed-through without transformation.
+      sym_to_val sym, IMAGE_TYPES
+    end
+
+    def sym_to_sharing_mode(sym)
+      sym_to_val sym, SHARING_MODES
+    end
+
+    def syms_to_descriptor_set_layout_type_flags(syms)
+      flags = 0
+      syms.each do |sym|
+        flags |= case sym
+                 when :push                   then VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR
+                 when :update_after_bind_pool then VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
+                 else sym
+                 end
+      end
+      flags
+    end
+
+    def sym_to_descriptor_type(sym)
+      DESCRIPTOR_TYPES[sym] || sym
+    end
+
+    def syms_to_shader_stage_flags(syms)
+      syms_to_flags syms, SHADER_STAGE_BITS
+    end
+
+    def sym_to_subpass_contents(sym)
+      case sym
+      when :inline                                then VK_SUBPASS_CONTENTS_INLINE
+      when :secondary, :secondary_command_buffers then VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
+      else sym
+      end
+    end
+
+    def sym_to_command_buffer_level(sym)
+      case sym
+      when :primary   then VK_COMMAND_BUFFER_LEVEL_PRIMARY
+      when :secondary then VK_COMMAND_BUFFER_LEVEL_SECONDARY
+      else sym
+      end
+    end
+
+    def sym_to_command_buffer_usage(sym)
+      case sym
+      when :simultaneous         then VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
+      when :one_time_submit      then VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
+      when :render_pass_continue then VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
+      else sym
+      end
+    end
+
+    def sym_to_index_type(sym)
+      case sym
+      when :uint16 then VK_INDEX_TYPE_UINT16
+      when :uint32 then VK_INDEX_TYPE_UINT32
+      else sym
+      end
+    end
+
+    def queue_family_to_index(family)
+      case family
+      when nil, :ignored then VK_QUEUE_FAMILY_IGNORED
+      when Numeric       then family
+      when Hash          then queue_family_to_index(family[:index])
+      else raise ArgumentError, 'queue family must be :ignored, a number, or a hash containing :index'
+      end
+    end
+
+    def sym_to_blend_factor(sym)
+      case sym
+      when 0, :zero                  then VK_BLEND_FACTOR_ZERO
+      when 1, :one                   then VK_BLEND_FACTOR_ONE
+      when :src_color                then VK_BLEND_FACTOR_SRC_COLOR
+      when :one_minus_src_color      then VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR
+      when :dst_color                then VK_BLEND_FACTOR_DST_COLOR
+      when :one_minus_dst_color      then VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR
+      when :src_alpha                then VK_BLEND_FACTOR_SRC_ALPHA
+      when :one_minus_src_alpha      then VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
+      when :dst_alpha                then VK_BLEND_FACTOR_DST_ALPHA
+      when :one_minus_dst_alpha      then VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA
+      when :constant_color           then VK_BLEND_FACTOR_CONSTANT_COLOR
+      when :one_minus_constant_color then VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR
+      when :constant_alpha           then VK_BLEND_FACTOR_CONSTANT_ALPHA
+      when :one_minus_constant_alpha then VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA
+      when :src_alpha_saturate       then VK_BLEND_FACTOR_SRC_ALPHA_SATURATE
+      when :src1_color               then VK_BLEND_FACTOR_SRC1_COLOR
+      when :one_minus_src1_color     then VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR
+      when :src1_alpha               then VK_BLEND_FACTOR_SRC1_ALPHA
+      when :one_minus_src1_alpha     then VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
+      else sym
+      end
+    end
+
+    def sym_to_blend_op(sym)
+      case sym
+      when :add              then VK_BLEND_OP_ADD
+      when :subtract         then VK_BLEND_OP_SUBTRACT
+      when :reverse_subtract then VK_BLEND_OP_REVERSE_SUBTRACT
+      when :min              then VK_BLEND_OP_MIN
+      when :max              then VK_BLEND_OP_MAX
+      else sym
+      end
+    end
+
+    def sym_to_topology(sym)
+      case sym
+      when :triangle, :triangles, :triangle_list then VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
+      when :point,    :points,    :point_list    then VK_PRIMITIVE_TOPOLOGY_POINT_LIST
+      when :line,     :lines,     :line_list     then VK_PRIMITIVE_TOPOLOGY_LINE_LIST
+      when :line_strip                           then VK_PRIMITIVE_TOPOLOGY_LINE_STRIP
+      when :triangle_strip                       then VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
+      else sym
+      end
+    end
+
+    def sym_to_polygon_mode(sym)
+      case sym
+      when :fill  then VK_POLYGON_MODE_FILL
+      when :line  then VK_POLYGON_MODE_LINE
+      when :point then VK_POLYGON_MODE_POINT
+      else sym
+      end
+    end
+
+    def sym_to_cull_mode(sym)
+      case sym
+      when :back           then VK_CULL_MODE_BACK_BIT
+      when :front          then VK_CULL_MODE_FRONT_BIT
+      when :front_and_back then VK_CULL_MODE_FRONT_AND_BACK
+      when :none, nil      then VK_CULL_MODE_NONE
+      else sym
+      end
+    end
+
+    def sym_to_front_face(sym)
+      case sym
+      when :clockwise         then VK_FRONT_FACE_CLOCKWISE
+      when :counter_clockwise then VK_FRONT_FACE_COUNTER_CLOCKWISE
+      else sym
+      end
+    end
+
+    def sym_to_color_component_bit(sym)
+      case sym
+      when :r, :red   then VK_COLOR_COMPONENT_R_BIT
+      when :g, :green then VK_COLOR_COMPONENT_G_BIT
+      when :b, :blue  then VK_COLOR_COMPONENT_B_BIT
+      when :a, :alpha then VK_COLOR_COMPONENT_A_BIT
+      else sym
+      end
+    end
+
+    def sym_to_load_op(sym)
+      case sym
+      when :load           then VK_ATTACHMENT_LOAD_OP_LOAD
+      when :clear          then VK_ATTACHMENT_LOAD_OP_CLEAR
+      when :dont_care, nil then VK_ATTACHMENT_LOAD_OP_DONT_CARE
+      else sym
+      end
+    end
+
+    def sym_to_store_op(sym)
+      case sym
+      when :store          then VK_ATTACHMENT_STORE_OP_STORE
+      when :dont_care, nil then VK_ATTACHMENT_STORE_OP_DONT_CARE
+      else sym
+      end
+    end
+
+    def sym_to_image_layout(sym)
+      case sym
+      when :undefined, nil, :any
+        VK_IMAGE_LAYOUT_UNDEFINED
+      when :general
+        VK_IMAGE_LAYOUT_GENERAL
+      when :color_optimal, :color, :color_attachment_optimal
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
+      when :stencil_optimal, :depth_optimal, :depth_stencil_optimal, :depth_stencil_attachment_optimal,
+           :stencil,         :depth,         :depth_stencil,         :depth_stencil_attachment
+        VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
+      when :stencil_read_only_optimal, :stencil_ro_optimal, :stencil_read_only, :stencil_ro,
+           :depth_read_only_optimal, :depth_ro_optimal, :depth_read_only, :depth_ro,
+           :depth_stencil_ro_optimal, :depth_stencil_read_only, :depth_stencil_ro
+        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
+      when :shader_read_only_optimal, :shader_ro_optimal, :shader_read_only, :shader_ro
+        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+      when :transfer_src_optimal, :transfer_src, :src_optimal
+        VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
+      when :transfer_dst_optimal, :transfer_dst, :dst_optimal
+        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
+      when :preinitialized
+        VK_IMAGE_LAYOUT_PREINITIALIZED
+      when :present_src, :presentation_src, :presentment_src
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
+      else sym
+      end
+    end
+
+    def sym_to_pipeline_bind_point(sym)
+      case sym
+      when :graphics then VK_PIPELINE_BIND_POINT_GRAPHICS
+      when :compute  then VK_PIPELINE_BIND_POINT_COMPUTE
+      else sym
+      end
+    end
+
+    def num_to_samples(i)
+      case i
+      when 1  then VK_SAMPLE_COUNT_1_BIT
+      when 2  then VK_SAMPLE_COUNT_2_BIT
+      when 4  then VK_SAMPLE_COUNT_4_BIT
+      when 8  then VK_SAMPLE_COUNT_8_BIT
+      when 16 then VK_SAMPLE_COUNT_16_BIT
+      when 32 then VK_SAMPLE_COUNT_32_BIT
+      when 64 then VK_SAMPLE_COUNT_64_BIT
+      else i
+      end
+    end
+
+    def array_of_uint32s(ary)
+      return nil if ary.nil? || ary.empty?
+      size = ary.size * 4
+      ints = Fiddle::Pointer.malloc(size)
+      ints[0, size] = ary.pack("L")
+      ints
+    end
+
+    def array_of_structures(ary)
+      return nil if ary.nil? || ary.empty?
+      size = ary.map { |struct| struct.to_ptr.size }.sum
+      pointers = Fiddle::Pointer.malloc(size)
+      raise ArgumentError, "size is 0?, #{ary}" if size == 0
+      offset = 0
+      ary.each_with_index do |addr, i|
+        (pointers + offset).copy_from(addr.to_ptr)
+        offset += addr.to_ptr.size
+      end
+      pointers
+    end
+
+    def array_of_pointers(ary, pointers = nil)
+      return nil if ary.nil? || ary.empty?
+      pointers ||= Fiddle::Pointer.malloc(ary.size * Fiddle::SIZEOF_VOIDP)
+      ary.each_with_index do |ptr, i|
+        mem = [ptr.to_ptr.to_i].pack(Fiddle::PackInfo::PACK_MAP[Fiddle::TYPE_VOIDP])
+        pointers[i * Fiddle::SIZEOF_VOIDP, Fiddle::SIZEOF_VOIDP] = mem
+      end
+      pointers
+    end
+
+    # Converts a byte array (array of numbers) representing a null-terminated
+    # C-string into a Ruby string.
+    def cstr_to_rbstr(byte_array_or_ptr)
+      case byte_array_or_ptr
+      when Fiddle::Pointer then byte_array_or_ptr.to_s
+      else byte_array_or_ptr.pack('C*').sub(/\x00*\z/, '')
+      end
+    end
+
+    # Takes a version string and constructs a Vulkan packed version number
+    # from it.
+    def vk_make_version(version)
+      version = Gem::Version.new(version)
+      major, minor, patch = *version.segments
+      (((major) << 22) | ((minor || 0) << 12) | (patch || 0))
+    end
+
+    # returns a Gem::Version from the specified numeric Vulkan packed version
+    # number.
+    def vk_parse_version(version)
+      major = (version >> 22) & 0x3ff
+      minor = (version >> 12) & 0x3ff
+      patch = (version      ) & 0xfff
+      Gem::Version.new([major, minor, patch].join('.'))
+    end
+
+    # Using the specified regular expression, scans the list of Vulkan
+    # constants, looking for the first constant whose name matches the regular
+    # expression AND whose value matches the given value. The return value is
+    # the first regex group (`$1`) from the match, converted to a symbol.
+    def const_to_symbol(val, rx)
+      Vulkan.constants.each do |konst|
+        if konst.to_s[rx]
+          return $1.downcase.to_sym if val == Vulkan.const_get(konst)
+        end
+      end
+      val
+    end
+
+    # Performs similarly to #const_to_symbol, but returns an array of symbols
+    # for a set of matching flag names, rather than for a single value.
+    def flags_to_symbols(val, rx)
+      [].tap do |ary|
+        Vulkan.constants.each do |konst|
+          if konst.to_s[rx]
+            flag_value = Vulkan.const_get(konst)
+            ary << $1.downcase.to_sym if val & flag_value > 0
+          end
+        end
+      end
+    end
+
+    # Converts a Fiddle/FFI memory struct into a simple Ruby hash, mostly for
+    # happier debugging.
+    def struct_to_hash(struct, initial = {})
+      struct.class.members.each_with_index.inject(initial) do |hash, (member, index)|
+        member = member[0] if member.kind_of?(Array)
+        member_name = member.gsub(/[0-9A-Z]+/) { |x| "_#{x.downcase}" }.to_sym
+        type = struct.class.types[index]
+        hash.tap do |h|
+          val = struct.send(member)
+          val = struct_to_hash(val) if val.respond_to?(:to_ptr) && !val.kind_of?(Array)
+          if val.kind_of?(Array)
+            val = val.map do |v|
+              if v.respond_to?(:to_ptr) && v.to_ptr.kind_of?(Fiddle::CStructEntity)
+                struct_to_hash(v)
+              else
+                v
+              end
+            end
+          end
+          h[member_name] = val
+          h[member_name] = cstr_to_rbstr(h[member_name]) if type.kind_of?(Array) && type[0] == Fiddle::TYPE_CHAR
+        end
+      end
+    end
+  end
+end

data/lib/vulkan/descriptor_pool.rb

@@ -0,0 +1,45 @@
+module Vulkan
+  class DescriptorPool
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    def initialize(vk, flags: VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, max_sets:, pool_sizes:)
+      @vk = vk
+      @flags = flags
+      pool_info = VkDescriptorPoolCreateInfo.malloc
+      pool_info.sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
+      pool_info.poolSizeCount = pool_sizes.size
+      pool_info.pPoolSizes    = array_of_structures(pool_sizes.map { |info| build_pool_size(**info) })
+      pool_info.flags         = @flags
+      pool_info.maxSets       = max_sets
+      handle_p = Vulkan.create_value('VkDescriptorPool')
+      check_result @vk.vkCreateDescriptorPool(@vk.device, pool_info, nil, handle_p)
+      @handle = handle_p.value
+      finalize_with @vk, :vkDestroyDescriptorPool, @vk.device, @handle, nil
+    end
+
+    def descriptor_sets_freeable?
+      @flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT == VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
+    end
+
+    def alloc(layouts:)
+      count = layouts.size
+      alloc_info = VkDescriptorSetAllocateInfo.malloc
+      alloc_info.sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
+      alloc_info.descriptorPool     = to_ptr
+      alloc_info.descriptorSetCount = count
+      alloc_info.pSetLayouts        = array_of_structures(layouts.map { |layout| Vulkan.create_value('void *', layout.to_ptr.to_i) })
+      sets_p = Vulkan.struct(['VkDescriptorSet sets[%d]' % count]).malloc
+      check_result @vk.vkAllocateDescriptorSets(@vk.device, alloc_info, sets_p)
+      count.times.map { |i| Vulkan::DescriptorSet.new(@vk, self, layouts[i], sets_p.sets[i], descriptor_sets_freeable?) }
+    end
+
+    def build_pool_size(type:, count:)
+      VkDescriptorPoolSize.malloc.tap do |pool_size|
+        pool_size.type            = sym_to_descriptor_type(type)
+        pool_size.descriptorCount = count
+      end
+    end
+  end
+end

data/lib/vulkan/descriptor_set.rb

@@ -0,0 +1,86 @@
+module Vulkan
+  class DescriptorSet
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    class DescriptorWrite
+      include Vulkan::Conversions
+
+      def initialize(owner, layout)
+        @changed = false
+        @writer = VkWriteDescriptorSet.malloc
+        @writer.sType            = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
+        @writer.dstSet           = owner.to_ptr
+        @writer.dstBinding       = layout.binding
+        @writer.dstArrayElement  = 0
+        @writer.descriptorType   = layout.descriptorType
+        @writer.descriptorCount  = layout.descriptorCount
+        @writer.pBufferInfo      = nil
+        @writer.pImageInfo       = nil
+        @writer.pTexelBufferView = nil
+      end
+
+      def set_buffer(buffer, offset: 0, range: buffer.size, array_element: 0)
+        @changed = true
+        @info = VkDescriptorBufferInfo.malloc
+        @info.buffer        = buffer.to_ptr
+        @info.offset        = offset
+        @info.range         = range
+        @writer.pImageInfo  = @writer.pTexelBufferView = nil
+        @writer.pBufferInfo = @info
+        @writer.dstArrayElement = array_element
+      end
+
+      def set_image_view_and_sampler(image_view, sampler, layout: :shader_read_only_optimal, array_element: 0)
+        @changed = true
+        @info = VkDescriptorImageInfo.malloc
+        @info.imageLayout   = sym_to_image_layout(layout)
+        @info.imageView     = image_view.to_ptr
+        @info.sampler       = sampler.to_ptr
+        @writer.pBufferInfo = @writer.pTexelBufferView = nil
+        @writer.pImageInfo  = @info
+        @writer.dstArrayElement = array_element
+      end
+
+      def to_ptr
+        @writer.to_ptr
+      end
+
+      def changed?
+        @changed
+      end
+    end
+
+    def initialize(vk, pool, layout, handle, freeable)
+      @vk = vk
+      @handle = handle
+      if freeable
+        handle_p = Vulkan.create_value('void *', handle)
+        finalize_with vk, :vkFreeDescriptorSets, vk.device, pool, 1, handle_p
+      end
+
+      @descriptor_writes = layout.descriptors.each_with_index.map do |desc_layout, i|
+        DescriptorWrite.new(self, desc_layout)
+      end
+    end
+
+    def [](index)
+      @descriptor_writes[index]
+    end
+
+    def commit
+      writes = @descriptor_writes.select { |write| write.changed? }
+      return unless writes.any?
+      writes_p = array_of_structures(writes)
+      @vk.vkUpdateDescriptorSets(@vk.device, writes.size, writes_p, 0, nil)
+    end
+
+    def update_texel_view(*, **)
+      raise NotImplemented
+    end
+
+    def update_image(image)
+      raise NotImplemented
+    end
+  end
+end

data/lib/vulkan/descriptor_set_layout.rb

@@ -0,0 +1,39 @@
+module Vulkan
+  class DescriptorSetLayout
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    attr_reader :descriptors
+    attr_reader :types
+
+    def initialize(vk, *types, descriptors:)
+      @vk = vk
+      @types = types
+      @descriptors = descriptors.map { |d| build_descriptor(**d) }
+      value_p = Vulkan.create_value('VkDescriptorSetLayout', nil)
+      check_result @vk.vkCreateDescriptorSetLayout(@vk.device, build_layout_info, nil, value_p)
+      @handle = value_p.value
+      finalize_with @vk, :vkDestroyDescriptorSetLayout, @vk.device, value_p.value, nil
+    end
+
+    def build_layout_info
+      VkDescriptorSetLayoutCreateInfo.malloc.tap do |layout|
+        layout.sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
+        layout.flags        = syms_to_descriptor_set_layout_type_flags(@types)
+        layout.bindingCount = descriptors.size
+        layout.pBindings    = array_of_structures(@descriptors)
+      end
+    end
+
+    def build_descriptor(binding:, type:, count: 1, stages:, samplers: [])
+      VkDescriptorSetLayoutBinding.malloc.tap do |descr|
+        descr.binding            = binding
+        descr.descriptorType     = sym_to_descriptor_type(type)
+        descr.descriptorCount    = count
+        descr.stageFlags         = syms_to_shader_stage_flags(stages)
+        descr.pImmutableSamplers = array_of_pointers(samplers)
+      end
+    end
+  end
+end