vulkan-ruby 0.1.0 → 1.3.207.1

data/lib/vulkan/generated.rb

@@ -1,38 +1,8 @@
-require 'fiddle/types'
+require 'vulkan/manual_types'
 
 module Vulkan
   load_vulkan_library
-
-  typealias 'int8_t',   'char'
-  typealias 'int16_t',  'short'
-  typealias 'int32_t',  'int'
-  typealias 'int64_t',  'long'
-  typealias 'uint8_t',  'unsigned char'
-  typealias 'uint16_t', 'unsigned short'
-  typealias 'uint32_t', 'unsigned int'
-  typealias 'uint64_t', 'unsigned long'
-
-  # platform-specific definitions, but we need them even on alternatives,
-  # or else things get complicated when parsing vk.xml
-  # X11
-  typealias 'Display',  'void' # HACK: since only pointers to this type are used, its size need not be known
-  typealias 'VisualID', 'unsigned long'
-  typealias 'XID',      'unsigned long'
-  typealias 'Window',   'XID'
-  typealias 'RROutput', 'XID'
-  # Wayland
-  typealias 'wl_display', 'void' # HACK: since only pointers to this type are used, its size need not be known
-  typealias 'wl_surface', 'void' # HACK: since only pointers to this type are used, its size need not be known
-  # Windows
-  include Fiddle::Win32Types
-  typealias 'WCHAR',     'unsigned short'
-  typealias 'LPCWSTR',   'WCHAR *'
-  # XCB
-  typealias 'xcb_connection_t', 'void' # HACK: since only pointers to this type are used, its size need not be known
-  typealias 'xcb_visualid_t',   'uint32_t'
-  typealias 'xcb_window_t',     'uint32_t'
-  # Zircon
-  typealias 'zx_handle_t', 'uint32_t'
+  include Vulkan::ManualTypes
 
   class << self
     @@lookup_map = {}
@@ -73,5 +43,5 @@ module Vulkan
 
   extern "PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName)", :stdcall
   require_relative 'generated/commands'
-  require_relative 'generated/extensions'
+  # require_relative 'generated/extensions'
 end

data/lib/vulkan/manual_types.rb

@@ -0,0 +1,44 @@
+require 'fiddle/import'
+require 'fiddle/types'
+
+module Vulkan
+  # Defines types manually that could not be auto generated from vk.xml.
+  # A type defined here will be skipped if encountered while processing
+  # vk.xml.
+  module ManualTypes
+    def self.included(base)
+      base.module_eval do
+        typealias 'int8_t',   'char'
+        typealias 'int16_t',  'short'
+        typealias 'int32_t',  'int'
+        typealias 'int64_t',  'long'
+        typealias 'uint8_t',  'unsigned char'
+        typealias 'uint16_t', 'unsigned short'
+        typealias 'uint32_t', 'unsigned int'
+        typealias 'uint64_t', 'unsigned long'
+
+        # platform-specific definitions, but we need them even on alternatives,
+        # or else things get complicated when parsing vk.xml
+        # X11
+        typealias 'Display',  'void' # HACK: since only pointers to this type are used, its size need not be known
+        typealias 'VisualID', 'unsigned long'
+        typealias 'XID',      'unsigned long'
+        typealias 'Window',   'XID'
+        typealias 'RROutput', 'XID'
+        # Wayland
+        typealias 'wl_display', 'void' # HACK: since only pointers to this type are used, its size need not be known
+        typealias 'wl_surface', 'void' # HACK: since only pointers to this type are used, its size need not be known
+        # Windows
+        include Fiddle::Win32Types
+        typealias 'WCHAR',     'unsigned short'
+        typealias 'LPCWSTR',   'WCHAR *'
+        # XCB
+        typealias 'xcb_connection_t', 'void' # HACK: since only pointers to this type are used, its size need not be known
+        typealias 'xcb_visualid_t',   'uint32_t'
+        typealias 'xcb_window_t',     'uint32_t'
+        # Zircon
+        typealias 'zx_handle_t', 'uint32_t'
+      end
+    end
+  end
+end

data/lib/vulkan/version.rb

@@ -1,3 +1,10 @@
+require 'vulkan/generated/version'
+
 module Vulkan
-  VERSION = "0.1.0"
+  VULKAN_RUBY_VERSION = [ 1 ]
+
+  VERSION = [ VK_API_VERSION_MAJOR,
+              VK_API_VERSION_MINOR,
+              VK_API_VERSION_PATCH,
+              *VULKAN_RUBY_VERSION ].join('.')
 end

data/tasks/fetch.rake

@@ -4,6 +4,7 @@ task :fetch do
   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
+    file << URI.open("https://raw.githubusercontent.com/KhronosGroup/Vulkan-Docs/main/xml/vk.xml",
+                     :ssl_verify_mode => OpenSSL::SSL::VERIFY_NONE).read
   end
 end

data/tasks/generate/enums.rake

@@ -1,40 +1,109 @@
+ALL_ENUMS = {}
+
+def enum_offset(extnum, offset, dir = 1)
+  base_value = 1000000000
+  range_size = 1000
+  (base_value + (extnum - 1) * range_size + offset) * dir
+end
+
+def find_enum_value(name)
+  ALL_ENUMS.each do |category, enums|
+    return enums[name] if enums.keys.include?(name)
+  end
+  nil
+end
+
+def resolve_enum_alias(name)
+  val = find_enum_value(name)
+  if val.kind_of?(Hash) && val[:alias]
+    return resolve_enum_alias(val[:alias])
+  else
+    return val
+  end
+end
+
+def process_literal_value(value)
+  value.sub(/(\d+)[fFuUlL]+/, '\1')
+end
+
 namespace :generate do
   desc 'generate enums'
   task :enums do
+    vk_xml.xpath('/registry/enums').each do |enums|
+      raise "duplicate enums? #{enums}" if ALL_ENUMS[enums['name']]
+      _enums = ALL_ENUMS[enums['name']] = {}
+      enums.xpath('enum').each do |enum|
+        raise "duplicate enum? #{enum}" if _enums[enum['name']]
+        value = nil
+        if enum['value'] then value = process_literal_value(enum['value'])
+        elsif enum['alias'] then value = { alias: enum['alias'] }
+        elsif enum['bitpos'] then value = 1 << enum['bitpos'].to_i
+        end
+        raise "could not compute enum value: #{enum}" unless value
+        _enums[enum['name']] = value
+      end
+    end
+
+    process_enum = proc do |enum, extnum = nil|
+      extnumber = enum['extnumber'] || extnum
+      if enum['extends'] && enum['offset']
+        category = ALL_ENUMS[enum['extends']] || raise("Enum category not found for #{enum}")
+        raise "No extnumber" unless extnumber
+        value = enum_offset(extnumber.to_i, enum['offset'].to_i, enum['dir'] == '-' ? -1 : 1)
+        raise "Could not compute offset for #{enum}" unless value
+      elsif enum['extends'] && enum['bitpos']
+        category = ALL_ENUMS[enum['extends']] || raise("Enum category not found for #{enum}")
+        value = 1 << enum['bitpos'].to_i
+      elsif enum['alias']
+        category = ALL_ENUMS[enum['extends']] || ALL_ENUMS[nil] ||= {}
+        value = { alias: enum['alias'] }
+      elsif enum['extends'] && enum['value']
+        category = ALL_ENUMS[enum['extends']] || raise("Enum category not found for #{enum}")
+        value = process_literal_value(enum['value'])
+      elsif enum['value']
+        category = ALL_ENUMS[nil] ||= {}
+        value = process_literal_value(enum['value'])
+      else
+        if find_enum_value(enum['name'])
+          next # we already have a value for this so carry on
+        else
+          raise "Unhandled enum: #{enum}"
+        end
+      end
+
+      raise "no category for #{enum}" unless category
+      raise "no value for #{enum}" unless value
+      existing_value = category[enum['name']]
+      raise "duplicate enum? #{enum} (current: #{existing_value})" if existing_value && existing_value != value
+      category[enum['name']] = value
+    end
+
+    vk_xml.xpath('/registry/feature/require/enum').each do |enum|
+      process_enum.call(enum)
+    end
+
+    vk_xml.xpath('/registry/extensions/extension').each do |extension|
+      extension.xpath('require/enum').each do |enum|
+        process_enum.call(enum, extension['number'])
+      end
+    end
+
     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]
+      ALL_ENUMS.each do |category, enums|
+        f.puts "  # #{category}" unless category.nil?
+
+        enums.each do |name, value|
+          if value.kind_of?(Hash) && value[:alias]
+            f.puts "  #{name} = #{resolve_enum_alias(value[:alias])} # Alias of #{value[:alias]}"
           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
+        f.puts
       end
 
       f.puts 'end'

data/tasks/generate/extensions.rake

@@ -1,35 +1,34 @@
-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
+    # 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'
+    #   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
+    #       extension.css('enum').each do |enum|
+    #         dir = enum['dir'] == '-' ? -1 : enum['dir']
+    #         alias_name = enum['alias']
+    #         value = enum['value'] || enum_offset(enum['extnumber'] || extnum, enum['offset'].to_i, (dir || 1).to_i)
+    #         if alias_name
+    #           f.puts "  #{enum['name']} = #{alias_name} unless defined?(#{enum['name']})"
+    #         else
+    #           f.puts "  #{enum['name']} = #{value} unless defined?(#{enum['name']})"
+    #         end
+    #       end
 
-          f.puts 'end'
-        end
-      end
-    end
+    #       f.puts 'end'
+    #     end
+    #   end
+    # end
   end
 end

data/tasks/generate/types.rake

@@ -1,80 +1,29 @@
-NAME_PADDING = 56
+# Include the manually specified types here, and then we will skip them while
+# processing vk.xml if they are encountered. This way, all special cases need
+# only be added to that file to be properly dealt with everywhere.
+require 'vulkan/manual_types'
+::ManualTypes = Class.new do
+  extend Fiddle::Importer
+  # HACK, fiddle only initializes this if we call dlload which we don't need here
+  @type_alias = {}
+  include Vulkan::ManualTypes
+end.new
 
-def pad_name(name)
-  name.ljust(NAME_PADDING)
-end
-
-def base_types
-  @base_types ||= {}.tap do |base_types|
-    vk_xml.xpath('//types/type').each do |type|
-      if type.attribute('category')&.value == 'basetype'
-        name = type.xpath('name').first&.text
-        ctype = type.xpath('type').first&.text
-        raise "type has no name: #{type.to_s.inspect}" unless name
-        raise "type has no ctype: #{type.to_s.inspect}" unless ctype
-        raise "unknown platform type: #{type.to_s.inspect} (#{ctype.to_s.inspect})" unless platform_type_map[ctype]
-        base_types[name] = ctype # platform_type_map[ctype]
-      end
-    end
-  end
-end
-
-def platform_types
-  @platform_types ||= {}.tap do |platform_types|
-    vk_xml.xpath('//types/type').each do |type|
-      if type.attribute('requires')&.value == 'vk_platform'
-        name = type.attribute('name').value
-        raise "type has no name: #{type.to_s.inspect}" unless name
-        raise "unknown platform type: #{type.to_s.inspect} (#{name.inspect})" unless platform_type_map[name]
-        platform_types[name] = platform_type_map[name]
-      end
-    end
-  end
-end
+TYPE_ALIASES = {}
 
-def generate_type_map(out)
-  base_types.each do |name, type|
-    out.puts "  typealias #{pad_name name.inspect}, '#{type}'"
-  end
-  @types = {}.tap do |processed_types|
-    vk_xml.xpath('//types/type').each do |type|
-      if type.attributes['category']&.value == 'bitmask'
-        alias_name = type.attributes['alias']&.value
-        name = (type.xpath('name').first&.text) ||
-               (type.attributes['name']&.value)
-        raise "type has no name: #{type.to_s.inspect}" unless name
-        if alias_name
-          raise "type alias not yet processed: #{type.to_s.inspect}" unless processed_types[alias_name]
-          btype = processed_types[alias_name]
-        else
-          btype = type.xpath('type').first&.text
-          raise "type has no base type: #{type.to_s.inspect}" unless btype
-          raise "unknown base type: #{type.to_s.inspect} (#{btype.to_s.inspect})" unless base_types[btype]
-          # btype = base_types[btype]
-        end
-        out.puts "  typealias #{pad_name name.inspect}, #{base_types[btype].inspect}"
-        processed_types[name] = btype
-      elsif type.attributes['category']&.value == 'handle'
-        name = (type.xpath('name').first&.text) || (type.attributes['name']&.value)
-        raise "type has no name: #{type.to_s.inspect}" unless name
-        out.puts "  typealias #{pad_name name.inspect}, 'void *'"
-        processed_types[name] = 'void *'
-      elsif type.attributes['category']&.value == 'funcpointer'
-        # we'll just treat function pointers as void pointers, shouldn't matter
-        # as long as the signatures are correct, which we'll call a programmer
-        # responsibility.
-        name = (type.xpath('name').first&.text) || (type.attributes['name']&.value)
-        raise "type has no name: #{type.to_s.inspect}" unless name
-        out.puts "  typealias #{pad_name name.inspect}, 'void *'"
-        processed_types[name] = 'void *'
-      end
-    end
+# Returns an array whose entries are 2-element arrays containing first the
+# name of the type to be created, and second the name of the type that it is
+# an alias of. The return value is sorted such that types that depend on
+# other types appear later.
+def resolve_type_aliases(aliases = TYPE_ALIASES.dup)
+  result = []
+  aliases.dup.each do |name, alias_of|
+    next if aliases[alias_of] # we want only leaf nodes
+    aliases.delete name
+    result << [name, alias_of]
   end
-  @types.each do |name, alias_name_or_type|
-    out.puts "  typealias #{pad_name name.inspect}, #{alias_name_or_type.inspect}"
-  end
-
-  # out.puts '    }'
+  result.concat resolve_type_aliases(aliases) unless aliases.empty?
+  result
 end
 
 namespace :generate do
@@ -84,7 +33,80 @@ namespace :generate do
       f.puts header_comment
       f.puts
       f.puts 'module Vulkan'
-      generate_type_map(f)
+
+      vk_xml.xpath('/registry/types/type').each do |type|
+        raise "duplicate type? #{type}" if TYPE_ALIASES[type['name']]
+        value = nil
+        # skip types we can't make use of
+        next if type['category'] == 'include'
+
+        name = type['name'] || type.xpath('name')&.text.to_s
+        name = nil if name.size == 0
+        if name
+          # skip C types defined by Fiddle (see lib/fiddle/cparser.rb #parse_ctype)
+          next if %w( char void int double float size_t ssize_t short ).include?(name)
+          # skip types we manually defined
+          next if ::ManualTypes.class.send(:type_alias).key?(name)
+        end
+
+        # types that depend on an external dependency, which we don't have access
+        # to. Try to define a default for them, which may or may not be correct.
+        # Note they won't be defined if they are already typealias'ed everywhere.
+        # We do this for a few known types in lib/vulkan/generated.rb.
+        # FIXME is there a better solution? Do nothing? Always manually define them?
+        if type['requires'] && type['requires'][/\.h/]
+          raise "No type name for #{type}" unless name
+          f.puts "  typealias '#{name}', 'void *' unless send(:type_alias).key?('#{name}') # defined in #{type['requires']}"
+        elsif type['category'] == 'define'
+          raise "No type name for #{type}" unless name
+          next if name['VERSION']
+          f.puts "  #{name} = 0 # dummy value, its real value could not be converted"
+        elsif type['category'] == 'basetype'
+          _type = type.xpath('type')&.text
+          raise "No type name for #{type}" unless name
+          if _type.size == 0
+            # we are about to choose type 'void' in hopes that it will only ever
+            # be used as a pointer (void *). In case we are wrong, check whether
+            # it was manually specified in lib/vulkan/generated.rb first. Then
+            # we can address these on a case by case basis.
+            f.puts "  typealias '#{name}', 'void' unless send(:type_alias).key?('#{name}')"
+          else
+            f.puts "  typealias '#{name}', '#{_type}'"
+          end
+        elsif type['category'] == 'bitmask'
+          _type = type.xpath('type')&.text
+          _type = nil if _type&.size == 0
+          raise "No type name for #{type}" unless name.size > 0
+          if _type
+            f.puts "  typealias '#{name}', '#{_type}'"
+          elsif type['alias']
+            TYPE_ALIASES[name] = type['alias']
+          end
+        elsif type['category'] == 'handle'
+          # all handles are pointers
+          raise "No type name for #{type}" unless name.size > 0
+          f.puts "  typealias '#{name}', 'void *' # handle"
+        elsif type['category'] == 'enum'
+          # FIXME we shouldn't assume an enum is an int, it could be smaller
+          # depending on the compiler.
+          raise "No type name for #{type}" unless name.size > 0
+          f.puts "  typealias '#{name}', 'int' # enum"
+        elsif type['category'] == 'funcpointer'
+          # function pointers are pointers.
+          # TODO do something with the arguments? Not sure fiddle knows/cares.
+          raise "No type name for #{type}" unless name.size > 0
+          f.puts "  typealias '#{name}', 'void *' # function pointer"
+        elsif type['category'] == 'struct' || type['category'] == 'union'
+          # structs and unions are handled by the generate:structs task.
+        else
+          raise "Unhandled type: #{type.to_s}"
+        end
+      end
+
+      resolve_type_aliases.each do |type_alias|
+        f.puts "  typealias '#{type_alias[0]}', '#{type_alias[1]}'"
+      end
+
       f.puts 'end'
     end
   end

data/tasks/generate/version.rake

@@ -0,0 +1,32 @@
+namespace :generate do
+  desc "Regenerate Vulkan API version info"
+  task :version do
+    header_version = nil
+    vk_xml.xpath("/registry/types/type[@category='define']").each do |type|
+      name = type.xpath('name')&.text.to_s
+      # we are relying on VK_HEADER_VERSION to appear before VK_HEADER_VERSION_COMPLETE
+      if name == 'VK_HEADER_VERSION'
+        raise "could not parse header version: #{type.text}" unless type.text =~ /\s+(\d+)$/
+        header_version = $1.to_i
+      elsif name == 'VK_HEADER_VERSION_COMPLETE'
+        raise "no header version" unless header_version
+        raise "can't parse version" unless type.text =~ /\((\d+), (\d+), (\d+), VK_HEADER_VERSION/m
+        full_version = [$1.to_i, $2.to_i, $3.to_i, header_version]
+        open(generate_dir.join('version.rb'), 'w') do |f|
+          f.puts header_comment
+          f.puts
+          f.puts 'module Vulkan'
+          f.puts "  VK_API_VERSION_VARIANT = #{full_version[0].inspect}"
+          f.puts "  VK_API_VERSION_MAJOR = #{full_version[1].inspect}"
+          f.puts "  VK_API_VERSION_MINOR = #{full_version[2].inspect}"
+          f.puts "  VK_API_VERSION_PATCH = #{header_version.inspect}"
+          f.puts '  VK_HEADER_VERSION_COMPLETE = [VK_API_VERSION_VARIANT,'
+          f.puts '                                VK_API_VERSION_MAJOR,'
+          f.puts '                                VK_API_VERSION_MINOR,'
+          f.puts '                                VK_API_VERSION_PATCH]'
+          f.puts 'end'
+        end
+      end
+    end
+  end
+end

data/tasks/generate.rake

@@ -1,2 +1,8 @@
 desc 'regenerate everything'
-task :generate => ['generate:types', 'generate:enums', 'generate:structs', 'generate:extensions']
+task :generate => %w( generate:types
+                      generate:enums
+                      generate:structs
+                      generate:extensions
+                      generate:commands
+                      generate:version
+                    )

data/vulkan-ruby.gemspec

@@ -34,12 +34,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler",       "~> 2.1"
   spec.add_development_dependency "rake",          "~> 13.0"
   spec.add_development_dependency "minitest",      "~> 5.15"
+  spec.add_development_dependency 'simplecov',     '~> 0.16'
   spec.add_development_dependency "nokogiri",      '~> 1.8' # used to process vk.xml
   spec.add_development_dependency 'sdl2_vulkan',   '~> 0.1' # used by the examples
-  spec.add_development_dependency 'cglm',          '~> 0.1'
-  spec.add_development_dependency 'simplecov',     '~> 0.16'
-  spec.add_development_dependency 'chunky_png',    '~> 1.3'
-  spec.add_development_dependency 'oily_png',      '~> 1.2'
-  spec.add_development_dependency 'tiny_obj',      '~> 0.2'
+  spec.add_development_dependency 'cglm',          '~> 0.1' # used by the examples
+  spec.add_development_dependency 'chunky_png',    '~> 1.3' # used by the examples
+  spec.add_development_dependency 'oily_png',      '~> 1.2' # used by the examples
+  spec.add_development_dependency 'tiny_obj',      '~> 0.2' # used by the examples
   spec.add_dependency 'sorted_set'
 end