vulkan-ruby 0.1.0

data/lib/vulkan/shader_stage.rb

@@ -0,0 +1,33 @@
+module Vulkan
+  class ShaderStage
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    attr_reader :entry_point, :stage, :module_handle
+
+    def initialize(vk, code: nil,
+                       file_path: nil,
+                       entry_point: 'main',
+                       stage:)
+      code ||= File.open(file_path, 'rb') { |file| file.read }
+      @vk = vk
+      @entry_point = entry_point
+      @stage = stage
+
+      code_p = Fiddle::Pointer.malloc(code.size + 1)
+      code_p[0, code.size] = code
+      create_info = VkShaderModuleCreateInfo.malloc
+      create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
+      create_info.codeSize = code.size
+      create_info.pCode = code_p
+
+      module_handle_p = Vulkan.create_value('void *', nil)
+      check_result @vk.vkCreateShaderModule(vk.device, create_info, nil, module_handle_p)
+      @module_handle = module_handle_p.value
+      finalize_with vk, :vkDestroyShaderModule, vk.device, @module_handle, nil
+
+      @handle = @module_handle
+    end
+  end
+end

data/lib/vulkan/surface.rb

@@ -0,0 +1,10 @@
+module Vulkan
+  class Surface
+    include Vulkan::Finalizer
+    
+    def initialize(instance, handle)
+      @handle = handle
+      finalize_with Vulkan[instance, nil], :vkDestroySurfaceKHR, instance.to_ptr, @handle, nil
+    end
+  end
+end

data/lib/vulkan/swapchain.rb

@@ -0,0 +1,87 @@
+module Vulkan
+  class Swapchain
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    attr_reader :extent
+    attr_reader :color_space
+    attr_reader :format
+    attr_reader :image_views
+
+    def initialize(instance, device, surface:,
+                                     surface_width:,
+                                     surface_height:,
+                                     app_config: {},
+                                     builder_class: Vulkan::SwapchainBuilder,
+                                     image_usage: VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+                                     image_array_layers: 1,
+                                     sharing_mode: VK_SHARING_MODE_EXCLUSIVE,
+                                     composite_alpha: VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+                                     clipped: true,
+                                     old_swapchain: nil)
+      @vk = Vulkan[instance, device]
+
+      info = device.physical_device.swapchain_surface_info(surface)
+      builder = builder_class.new(info, app_config)
+      @extent = { width: builder.width(surface_width), height: builder.height(surface_height) }
+
+      image_format = builder.format
+      @format = image_format[:format]
+      @color_space = image_format[:color_space]
+
+      create_info = VkSwapchainCreateInfoKHR.malloc
+      create_info.sType                 = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
+      create_info.surface               = surface.to_ptr
+      create_info.minImageCount         = builder.image_count
+      create_info.imageFormat           = @format
+      create_info.imageColorSpace       = @color_space
+      create_info.imageExtent.width     = @extent[:width]
+      create_info.imageExtent.height    = @extent[:height]
+      create_info.imageArrayLayers      = image_array_layers
+      create_info.imageUsage            = image_usage
+      create_info.imageSharingMode      = sharing_mode
+      create_info.queueFamilyIndexCount = 0
+      create_info.pQueueFamilyIndices   = nil
+      create_info.preTransform          = syms_to_surface_transforms(builder.transformation)
+      create_info.compositeAlpha        = composite_alpha
+      create_info.presentMode           = sym_to_present_mode(builder.presentation_mode)
+      create_info.clipped               = clipped ? VK_TRUE : VK_FALSE
+      create_info.oldSwapchain          = old_swapchain
+
+      swapchain = Vulkan.create_value("void *", nil)
+      check_result @vk.vkCreateSwapchainKHR(device.to_ptr, create_info, nil, swapchain)
+      @handle = swapchain.value
+      finalize_with @vk, :vkDestroySwapchainKHR, device.to_ptr, @handle, nil
+
+      image_count_p = Vulkan.create_value('uint32_t', 0)
+      check_result @vk.vkGetSwapchainImagesKHR(device.to_ptr, @handle, image_count_p, nil)
+      images_p = Vulkan.struct("images[#{image_count_p.value}]" => 'void *handle').malloc
+      check_result @vk.vkGetSwapchainImagesKHR(device.to_ptr, @handle, image_count_p, images_p);
+      @image_views = images_p.images.map { |i| ImageView.new(@vk, i.handle, sym_to_image_format(@format)) }
+
+      @image_index_p = Vulkan.create_value('uint32_t', 0)
+    end
+
+    def [](method_name)
+      send method_name
+    end
+
+    def width
+      @extent[:width]
+    end
+
+    def height
+      @extent[:height]
+    end
+
+    def size
+      image_views.size
+    end
+
+    def next_image_index(semaphore: nil, fence: nil, timeout: 0xffffffffffffffff)
+      @vk.vkAcquireNextImageKHR(@vk.device, to_ptr, timeout, semaphore, fence, @image_index_p)
+      @image_index_p.value
+    end
+  end
+end

data/lib/vulkan/swapchain_builder.rb

@@ -0,0 +1,111 @@
+module Vulkan
+  class SwapchainBuilder
+    attr_reader :surface_info
+    attr_reader :config
+
+    def initialize(swapchain_surface_info, config = {})
+      @surface_info = swapchain_surface_info
+      @config = config
+      raise 'swapchain not supported' unless usage_supported?
+    end
+
+    # Chooses and returns a swapchain image format from those supported.
+    # An override may be specified in
+    # `config[:graphics][:swapchain][:image][:format]` and/or
+    # `config[:graphics][:swapchain][:image][:color_space]`. The
+    # defaults are `:r8g8b8a8_unorm` and `:srgb_nonlinear`, respectively.
+    def format
+      supported = surface_info.formats
+
+      # By default use the most widely supported R8 G8 B8 A8 format with
+      # nonlinear colorspace.
+      preferred_format = { format: :r8g8b8a8_unorm, color_space: :srgb_nonlinear }
+
+      # If app config specifies an override, and it is supported, then
+      # use it.
+      if override = config.dig(:graphics, :swapchain, :image)
+        preferred_format[:format] = override[:format] if override.key?(:format)
+        preferred_format[:color_space] = override[:color_space] if override.key?(:color_space)
+      end
+
+      # If the list contains only one entry with an undefined format then
+      # it means that there are no preferred surface formats and any can
+      # be chosen.
+      return preferred_format if supported.size == 1 && supported[0][:format] == :undefined
+
+      # Check if the preferred format is supported, and use it if possible
+      return preferred_format if supported.include?(preferred_format)
+
+      # No match found, try to match the format ignoring colorspace
+      supported.each { |sup| return sup if sup[:format] == preferred_format[:format] }
+
+      # No match, return the first format in the list
+      return supported.first || raise('no supported swapchain image formats')
+    end
+
+    def presentation_mode
+      # :fifo should always be available;
+      # :mailbox is the lowest latency V-Sync enabled mode (something like
+      # triple-buffering) so use it if available
+      supported = surface_info.presentation_modes
+      preferred_mode = config.dig(:graphics, :swapchain, :vsync) == false ? :immediate :
+                       config.dig(:graphics, :swapchain, :presentation_mode)&.to_sym
+      if preferred_mode && supported.include?(preferred_mode)
+        return preferred_mode
+      else
+        return :mailbox if supported.include?(:mailbox)
+        return :fifo if supported.include?(:fifo)
+        return :fifo_relaxed if supported.include?(:fifo_relaxed)
+        return :immediate if supported.include?(:immediate)
+        return raise('no supported presentation modes (available: %s)' % supported.inspect)
+      end
+    end
+
+    def transformation
+      return :identity if @surface_info.capabilities[:supported_transforms].include?(:identity)
+      return @surface_info.capabilities[:current_transform]
+    end
+
+    def usage_supported?
+      usage = @surface_info.capabilities[:supported_usage]
+      usage.include?(:transfer_dst)
+    end
+
+    def width(desired_width)
+      surface_capabilities = surface_info.capabilities
+      desired_width  ||= surface_capabilities[:current_extent][:width]
+      if desired_width  == -1
+        desired_width  = (config.dig(:graphics, :swapchain, :width))  ||
+                         (config.dig(:window, :width)) ||
+                         640
+      end
+      desired_width.clamp(surface_capabilities[:min_image_extent][:width],
+                          surface_capabilities[:max_image_extent][:width])
+    end
+
+    def height(desired_height)
+      surface_capabilities = surface_info.capabilities
+      desired_height  ||= surface_capabilities[:current_extent][:height]
+      if desired_height  == -1
+        desired_height  = (config.dig(:graphics, :swapchain, :height))  ||
+                         (config.dig(:window, :height)) ||
+                         640
+      end
+      desired_height.clamp(surface_capabilities[:min_image_extent][:height],
+                           surface_capabilities[:max_image_extent][:height])
+    end
+
+    def dimensions(desired_width = nil, desired_height = nil)
+      [width(desired_width), height(desired_height)]
+    end
+
+    def image_count
+      count = @surface_info.capabilities[:min_image_count] + 1
+      if @surface_info.capabilities[:max_image_count] > 0 &&
+         count > @surface_info.capabilities[:max_image_count]
+        count = @surface_info.capabilities[:max_image_count]
+      end
+      return count
+    end
+  end
+end

data/lib/vulkan/swapchain_surface_info.rb

@@ -0,0 +1,54 @@
+module Vulkan
+  class SwapchainSurfaceInfo < Hash
+    include Vulkan::Checks
+    include Vulkan::Conversions
+
+    attr_accessor :builder
+
+    def initialize(instance, physical_device, surface)
+      super()
+      @vk = Vulkan[instance, nil]
+      @physical_device = physical_device
+      @surface = surface
+      merge! capabilities:       capabilities,
+             formats:            formats,
+             presentation_modes: presentation_modes
+    end
+
+    def presentation_modes
+      @presentation_modes ||= begin
+        modes_count_p = Vulkan.create_value('uint32_t', 0)
+        check_result @vk.vkGetPhysicalDeviceSurfacePresentModesKHR(@physical_device.to_ptr, @surface.to_ptr, modes_count_p, nil)
+        modes_p = Vulkan.struct(["VkPresentModeKHR modes[#{modes_count_p.value}]"]).malloc
+        check_result @vk.vkGetPhysicalDeviceSurfacePresentModesKHR(@physical_device.to_ptr, @surface.to_ptr, modes_count_p, modes_p)
+        modes_p.modes.map { |mode| present_mode_to_sym(mode) }
+      end
+    end
+
+    def formats
+      @formats ||= begin
+        format_count_p = Vulkan.create_value('uint32_t', 0)
+        check_result @vk.vkGetPhysicalDeviceSurfaceFormatsKHR(@physical_device.to_ptr, @surface.to_ptr, format_count_p, nil)
+        formats_p = Vulkan.struct("formats[#{format_count_p.value}]" => VkSurfaceFormatKHR).malloc
+        check_result @vk.vkGetPhysicalDeviceSurfaceFormatsKHR(@physical_device.to_ptr, @surface.to_ptr, format_count_p, formats_p)
+        formats_p.formats.map { |fmt| struct_to_hash(fmt) }
+      end
+    end
+
+    def capabilities
+      @capabilities ||= begin
+        capabilities = VkSurfaceCapabilitiesKHR.malloc
+        check_result @vk.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(@physical_device.to_ptr, @surface.to_ptr, capabilities)
+        capabilities = struct_to_hash(capabilities)
+        capabilities[:supported_transforms_flags] = capabilities[:supported_transforms]
+        capabilities[:supported_transforms] = flags_to_symbols(capabilities[:supported_transforms_flags], /^VK_SURFACE_TRANSFORM_(.*?)_BIT/)
+        capabilities[:current_transform_flags] = capabilities[:current_transform]
+        capabilities[:current_transform] = flags_to_symbols(capabilities[:current_transform_flags], /^VK_SURFACE_TRANSFORM_(.*?)_BIT/)
+        capabilities[:supported_composite_alpha_flags] = capabilities[:supported_composite_alpha]
+        capabilities[:supported_composite_alpha] = flags_to_symbols(capabilities[:supported_composite_alpha_flags], /^VK_COMPOSITE_ALPHA_(.*?)_BIT/)
+        capabilities[:supported_usage] = flags_to_symbols(capabilities[:supported_usage_flags], /^VK_IMAGE_USAGE_(.*?)_BIT/)
+        capabilities
+      end
+    end
+  end
+end

data/lib/vulkan/version.rb

@@ -0,0 +1,3 @@
+module Vulkan
+  VERSION = "0.1.0"
+end

data/lib/vulkan/window_surface.rb

@@ -0,0 +1,13 @@
+require 'vulkan/surface'
+
+module Vulkan
+  # Provides a handle to an underlying window surface based on an SDL2
+  # window (or otherwise, any object which responds to `vk_create_surface`
+  # and which returns the integer address of the created surface), and a
+  # Vulkan instance.
+  class WindowSurface < Surface
+    def initialize(instance, window)
+      super(instance, window.vk_create_surface(instance.to_ptr.to_i))
+    end
+  end
+end

data/lib/vulkan-ruby.rb

@@ -0,0 +1 @@
+require 'vulkan'

data/lib/vulkan.rb

@@ -0,0 +1,91 @@
+require 'pathname'
+require 'rubygems/version'
+require 'vulkan/platform'
+require 'fiddle_ext'
+
+module Vulkan
+  extend Fiddle::Importer
+  extend Vulkan::Platform
+
+  class << self
+    def root
+      Pathname.new(__dir__).join('vulkan')
+    end
+
+    def parse_signature(sig, type_alias = @type_alias)
+      super(sig, type_alias)
+    end
+
+    def vulkan_library_candidates
+      [
+        ENV['PATH_TO_VULKAN'],
+        *case os
+         when :windows then ['vulkan-1.dll']
+         when :osx     then ['libvulkan.dylib', 'libvulkan.1.dylib', 'libMoltenVK.dylib']
+         when :linux   then ['libvulkan.so', 'libvulkan.so.1']
+         else               []
+         end
+      ].compact
+    end
+
+    def load_vulkan_library
+      candidates = vulkan_library_candidates
+      begin
+        dlload candidates.shift
+      rescue
+        retry if candidates.any?
+        raise "could not determine vulkan library to load for this OS (#{os.inspect}): try passing PATH_TO_VULKAN"
+      end
+    end
+
+    def format_has_stencil_component?(format)
+      case format
+      when VK_FORMAT_D32_SFLOAT_S8_UINT, :d32_sfloat_s8_uint then true
+      when VK_FORMAT_D24_UNORM_S8_UINT,  :d24_unorm_s8_uint  then true
+      else false
+      end
+    end
+
+    def num_mip_levels(*sizes)
+      Math.log2(sizes.max).floor + 1
+    end
+  end
+
+  require 'vulkan/generated'
+  require 'vulkan/error'
+end
+
+require 'vulkan/version'
+require 'vulkan/checks'
+require 'vulkan/conversions'
+require 'vulkan/finalizer'
+require 'vulkan/framebuffer'
+require 'vulkan/surface'
+require 'vulkan/pipeline'
+require 'vulkan/window_surface'
+require 'vulkan/dispatch_table'
+require 'vulkan/physical_device'
+require 'vulkan/logical_device'
+require 'vulkan/instance'
+require 'vulkan/queue_family'
+require 'vulkan/swapchain'
+require 'vulkan/swapchain_surface_info'
+require 'vulkan/swapchain_builder'
+require 'vulkan/image_view'
+require 'vulkan/shader_stage'
+require 'vulkan/render_pass'
+require 'vulkan/render_pass/subpass'
+require 'vulkan/command_pool'
+require 'vulkan/command_buffer'
+require 'vulkan/semaphore'
+require 'vulkan/fence'
+require 'vulkan/queue'
+require 'vulkan/buffer'
+require 'vulkan/descriptor_pool'
+require 'vulkan/descriptor_set'
+require 'vulkan/descriptor_set_layout'
+require 'vulkan/image'
+require 'vulkan/memory'
+require 'vulkan/buffer_memory'
+require 'vulkan/image_memory'
+require 'vulkan/sampler'

data/tasks/examples.rake

@@ -0,0 +1,29 @@
+examples = []
+
+namespace :examples do
+  Dir[File.expand_path('../examples/*.rb', __dir__)].each do |filename|
+    basename = File.basename(filename, '.rb')
+    examples << "examples:#{basename}"
+    desc "run the '#{basename}' example script. Influential vars: DEBUG=1, CALL_TRACE=1, MAX_FRAMES=N"
+    task basename do
+      ENV['COVERAGE'] = basename
+      sh 'bundle', 'exec', 'ruby', filename
+    end
+
+    if basename[/^(.*?)_/]
+      # desc "alias for #{basename}"
+      task $1 => "examples:#{basename}"
+    end
+  end
+end
+
+desc 'Run all examples. Influential vars: DEBUG=1, CALL_TRACE=1, MAX_FRAMES=N'
+task examples: examples
+
+task :default do
+  # also run all examples as part of the tests
+  ENV['MAX_FRAMES'] = '5'
+  ENV['DEBUG'] = '1'
+  Rake::Task[:examples].invoke
+  puts 'Execution successful.'
+end

data/tasks/fetch.rake

@@ -0,0 +1,9 @@
+desc 'fetch latest version of vk.xml'
+task :fetch do
+  require 'open-uri'
+  require 'openssl'
+  require 'vulkan/version'
+  open(vk_xml_path, 'wb') do |file|
+    file << open("https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/registry/vk.xml", :ssl_verify_mode => OpenSSL::SSL::VERIFY_NONE).read
+  end
+end

data/tasks/generate/commands.rake

@@ -0,0 +1,51 @@
+namespace :generate do
+  desc 'generate commands'
+  task :commands do
+    core_features = vk_xml.css("feature[name=VK_VERSION_1_0] command").map { |command| command.attributes['name'].to_s }
+    addl_features = vk_xml.css("feature command").map { |command| command.attributes['name'].to_s } - core_features
+    instance_functions = vk_xml.css("require[comment='Device initialization'] command").map { |command| command.attributes['name'].to_s }
+
+    open(generate_dir.join('commands.rb'), 'w') do |f|
+      f.puts header_comment
+      f.puts
+      f.puts 'module Vulkan'
+      aliases = []
+      max_name_len = vk_xml.css("commands command proto").map { |name| name.text.size }.max
+      vk_xml.xpath('//commands/command').each do |command|
+        if command.attributes['name'] && command.attributes['alias']
+          name = command.attributes['name'].to_s
+          command_alias = command.attributes['alias'].to_s
+          aliases << [name, command_alias]
+          # f.puts "  def #{name}(*args); #{command_alias}(*args); end"
+        else
+          name = command.css('proto name').text
+          next if name == 'vkGetInstanceProcAddr'
+          proto = command.xpath('proto').text
+          params = command.xpath('param').map(&:text).join(', ')
+          if proto.to_s.strip.size == 0 || params.to_s.strip.size == 0
+            puts "WARN: unhandled command: #{proto}(#{params}) (#{command.to_s})"
+          else
+            # if instance_functions.include?(name) || params[/^vkInstance\s/]
+            #   f.puts "  lookup_instance_function #{proto.inspect.ljust(max_name_len+2)}, #{params.inspect}"
+            # else
+            #   f.puts "  lookup_device_function   #{proto.inspect.ljust(max_name_len+2)}, #{params.inspect}"
+            # end
+            f.puts "  register_function #{proto.inspect.ljust(max_name_len+2)}, #{params.inspect}"
+          end
+        end
+        # <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_LAYER_NOT_PRESENT,VK_ERROR_EXTENSION_NOT_PRESENT,VK_ERROR_INCOMPATIBLE_DRIVER">
+        #     <proto><type>VkResult</type> <name>vkCreateInstance</name></proto>
+        #     <param>const <type>VkInstanceCreateInfo</type>* <name>pCreateInfo</name></param>
+        #     <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+        #     <param><type>VkInstance</type>* <name>pInstance</name></param>
+        # </command>
+      end
+      # if aliases.any?
+      #   f.puts "  class << self"
+      #   aliases.each { |a| f.puts "    alias #{a[0].ljust(max_name_len)} #{a[1]}"}
+      #   f.puts "  end"
+      # end
+      f.puts 'end'
+    end
+  end
+end

data/tasks/generate/enums.rake

@@ -0,0 +1,43 @@
+namespace :generate do
+  desc 'generate enums'
+  task :enums do
+    open(generate_dir.join('enums.rb'), 'w') do |f|
+      f.puts header_comment
+      f.puts
+      f.puts 'module Vulkan'
+      vk_xml.xpath('//types/type').each do |type|
+        if type.attributes['category']&.value == 'enum'
+          name = type.attributes['name']&.value
+          raise "enum has no name: #{type.to_s.inspect}" unless name
+          f.puts "  typealias #{name.inspect}, 'int'"
+        end
+      end
+
+      enums.tap do |processed_enums|
+        vk_xml.xpath('//enums/enum').each do |enum|
+          name = enum.attributes['name']&.value
+          value = enum.attributes['value']&.value
+          bitpos = enum.attributes['bitpos']&.value
+          alias_name = enum.attributes['alias']&.value
+          raise "enum has no name: #{enum.to_s.inspect}" unless name
+          if alias_name
+            raise "enum alias has not been processed yet: #{enum.to_s.inspect}" unless processed_enums[alias_name]
+            f.puts "  #{name} = #{processed_enums[alias_name]}"
+            processed_enums[name] = processed_enums[alias_name]
+          else
+            if bitpos
+              value = (1 << bitpos.to_i)
+            else
+              value = value.sub(/(\d+)[fUL]+/, '\1') # '1.0f' => '1.0', '100U' => '100'
+            end
+            raise "enum has no value: #{enum.to_s.inspect}" unless value
+            f.puts "  #{name} = #{value}"
+            processed_enums[name] = value
+          end
+        end
+      end
+
+      f.puts 'end'
+    end
+  end
+end

data/tasks/generate/extensions.rake

@@ -0,0 +1,35 @@
+def enum_offset(extnum, offset, dir = 1)
+  base_value = 1000000000
+  range_size = 1000
+  (base_value + (extnum - 1) * range_size + offset) * dir
+end
+
+namespace :generate do
+  desc 'generate extension enums, types, etc'
+  task :extensions do
+    rm_rf generate_dir.join('extensions')
+    mkdir_p generate_dir.join('extensions')
+    File.open(generate_dir.join('extensions.rb'), 'w') do |extout|
+      extout.puts header_comment
+      extout.puts
+      
+      vk_xml.css('extension').each do |extension|
+        extout.puts "require 'vulkan/generated/extensions/#{extension['name'].downcase}'"
+        extnum = extension['number'].to_i
+        File.open(generate_dir.join('extensions/%s.rb' % extension['name'].downcase), 'w') do |f|
+          f.puts header_comment
+          f.puts
+          f.puts 'module Vulkan'
+
+          extension.css('enum').each do |enum|
+            dir = enum['dir'] == '-' ? -1 : enum['dir']
+            value = enum['value'] || enum_offset(extnum, enum['offset'].to_i, (dir || 1).to_i)
+            f.puts "  #{enum['name']} = #{value} unless defined?(#{enum['name']})"
+          end
+
+          f.puts 'end'
+        end
+      end
+    end
+  end
+end