vulkan-ruby 0.1.0

data/tasks/generate/structs.rake

@@ -0,0 +1,117 @@
+namespace :generate do
+  desc 'generate structs'
+  task structs: ['generate:types', 'generate:enums'] do
+    require 'fiddle'
+    open(generate_dir.join('structs.rb'), 'w') do |f|
+      f.puts header_comment
+      f.puts
+      f.puts 'module Vulkan'
+      @structs = {}
+      if Fiddle::WINDOWS
+        @structs['SECURITY_ATTRIBUTES'] = [
+          'struct',
+          nil,
+          'DWORD nLength',
+          'LPVOID lpSecurityDescriptor',
+          'BOOL bInheritHandle'
+        ]
+      end
+      2.times do
+        @structs.tap do |processed|
+          vk_xml.xpath('//types/type').each do |struct|
+            if struct.attributes['category']&.value == 'struct' || struct.attributes['category']&.value == 'union'
+              name = struct.attributes['name']&.value
+              raise "struct has no name: #{struct.to_s.inspect}" unless name
+              if alias_name = struct.attributes['alias']&.value
+                raise "struct alias has not been processed yet: #{struct.to_s.inspect}" unless processed[alias_name]
+                # f.puts "    #{name} = #{alias_name}"
+                processed[name] = alias_name
+              else
+                # MyStruct = struct ['int i', 'char c', { position: ['float x', 'float y'] }]
+                members = struct.xpath('member').map do |m|
+                  m.xpath('comment').remove
+                  type = m.xpath('type').text.to_s.strip
+                  is_pointer = m.to_s[/<\/type>\s*\*/]
+                  # type = 'void' if is_pointer
+                  array = m.text[/\[[0-9]+\]$/]
+                  if processed[type] && !is_pointer
+                    arylen = array || ''
+                    arylen = "[#{m.xpath('enum').text.to_s.strip}]" if m.xpath('enum').any?
+                    nested_name = m.xpath('name').text.to_s.strip + arylen
+                    { nested_name => type }
+                  else
+                    # comment = m.xpath('comment').text.to_s.strip
+                    m.xpath('enum').each do |enum|
+                      enum.content = "\#{" + enum.text + "}" unless enum.text['#{']
+                    end
+                    # m.text.to_s.strip
+                    arylen = ''
+                    arylen = "[#{m.xpath('enum').text.to_s.strip}]" if m.xpath('enum').any?
+                    [type, is_pointer ? '*' : '', m.xpath('name').text.to_s.strip + arylen, array]
+                  end
+                end
+                # processed[name] = name
+                comment = struct.attributes['comment']&.value
+                processed[name] = [ struct.attributes['category'].value, comment, *members ]
+              end
+            end
+          end
+        end
+      end
+
+      # flattens hashes and arrays alike into a single array of values
+      totally_flatten = proc do |mbr|
+        result = []
+        if mbr.kind_of?(Array) || mbr.kind_of?(Hash)
+          mbr.flatten.each do |elem|
+            result.concat totally_flatten.call elem
+          end
+        else
+          result << mbr
+        end
+        result
+      end
+
+      # sort alphabetically, then loop through each pending item, tracking
+      # down dependencies and dumping them before dumping the item first.
+      pending = Hash[@structs.dup.sort { |a, b| a[0] <=> b[0] }]
+      dump = proc do |item|
+        name, members_or_alias = *item
+        pending.delete name
+        # find dependencies, dump them first
+        totally_flatten.call([members_or_alias]).each do |member|
+          if pending.key?(member)
+            dump.call [member, pending[member]]
+          end
+        end
+        # dump item
+        comment = nil
+        struct_or_union = members_or_alias
+        str = case members_or_alias
+              when String then members_or_alias # alias
+              else
+                struct_or_union = members_or_alias.shift
+                comment = members_or_alias.shift
+                members = members_or_alias.map do |member|
+                  if member.kind_of?(Hash)
+                    member = member.to_a[0]
+                    "{ \"#{member[0]}\" => #{member[1]} }"
+                  else
+                    member.compact.join(' ').inspect.gsub(/\\\#/, '#')
+                  end
+                end
+                "#{struct_or_union} [#{members.join(",\n")}]"
+              end
+        f.puts "  # #{comment.sub(/^\s*\/\/\s*/, '')}" if comment
+        str = "  #{name} = #{str}"
+        f.print str.lines.first
+        f.puts str.lines[1..-1].map { |line| (" " * (name.size + struct_or_union.size + 7)) + line }.join
+      end
+      while pending.any?
+        dump.call pending.to_a.first
+        f.puts
+      end
+      f.puts 'end'
+    end
+  end
+end

data/tasks/generate/types.rake

@@ -0,0 +1,91 @@
+NAME_PADDING = 56
+
+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
+
+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
+  end
+  @types.each do |name, alias_name_or_type|
+    out.puts "  typealias #{pad_name name.inspect}, #{alias_name_or_type.inspect}"
+  end
+
+  # out.puts '    }'
+end
+
+namespace :generate do
+  desc 'generate types'
+  task :types do
+    open(generate_dir.join('types.rb'), 'w') do |f|
+      f.puts header_comment
+      f.puts
+      f.puts 'module Vulkan'
+      generate_type_map(f)
+      f.puts 'end'
+    end
+  end
+end

data/tasks/generate.rake

@@ -0,0 +1,2 @@
+desc 'regenerate everything'
+task :generate => ['generate:types', 'generate:enums', 'generate:structs', 'generate:extensions']

data/tasks/helpers.rb

@@ -0,0 +1,59 @@
+def generate_dir
+  require 'pathname'
+  @generate_dir ||= begin
+    Pathname.new(File.expand_path('../lib/vulkan/generated', __dir__)).tap do |generate_dir|
+      mkdir_p generate_dir unless generate_dir.directory?
+    end
+  end
+end
+
+def vk_xml_path
+  @vk_xml_path ||= generate_dir.join('vk.xml')
+end
+
+def vk_xml
+  @vk_xml ||= begin
+    require 'nokogiri'
+    Nokogiri::XML(open(vk_xml_path))
+  end
+end
+
+def enums
+  @enums ||= {}
+end
+
+def header_comment
+  @header_comment ||= <<-end_comment.lines.map(&:strip).join("\n")
+    # vulkan-ruby #{Vulkan::VERSION}
+    #
+    #   => https://github.com/sinisterchipmunk/vulkan-ruby
+    #
+    # [NOTICE] This is an automatically generated file.
+  end_comment
+end
+
+def platform_type_map
+  @platform_type_map ||= {
+    'char'           => 'Fiddle::TYPE_CHAR',
+    'signed char'    => 'Fiddle::TYPE_CHAR',
+    'unsigned char'  => '-Fiddle::TYPE_CHAR',
+    'short'          => 'Fiddle::TYPE_SHORT',
+    'signed short'   => 'Fiddle::TYPE_SHORT',
+    'unsigned short' => '-Fiddle::TYPE_SHORT',
+    'int'            => 'Fiddle::TYPE_INT',
+    'signed int'     => 'Fiddle::TYPE_INT',
+    'unsigned int'   => '-Fiddle::TYPE_INT',
+    'int64_t'        => 'Fiddle::TYPE_LONG_LONG',
+    'uint64_t'       => '-Fiddle::TYPE_LONG_LONG',
+    'float'          => 'Fiddle::TYPE_FLOAT',
+    'double'         => 'Fiddle::TYPE_DOUBLE',
+    'ptrdiff_t'      => 'Fiddle::TYPE_PTRDIFF_T',
+    'void'           => 'Fiddle::TYPE_VOID',
+    'void *'         => 'Fiddle::TYPE_VOIDP',
+    'int8_t'         => 'Fiddle::TYPE_CHAR',
+    'int32_t'        => 'Fiddle::TYPE_INT',
+    'size_t'         => 'Fiddle::TYPE_SIZE_T',
+    'uint8_t'        => '-Fiddle::TYPE_CHAR',
+    'uint32_t'       => '-Fiddle::TYPE_INT',
+  }
+end

data/tasks/shaders.rake

@@ -0,0 +1,8 @@
+desc 'recompile ./examples/shaders'
+task :shaders do
+  chdir 'examples/shaders' do
+    Dir['*.{vert,frag}'].each do |shader|
+      sh 'glslangValidator', '-V', shader, '-o', "#{shader}.spv"
+    end
+  end
+end

data/vulkan-ruby.gemspec

@@ -0,0 +1,45 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "vulkan/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "vulkan-ruby"
+  spec.version       = Vulkan::VERSION
+  spec.authors       = ["Colin MacKenzie IV"]
+  spec.email         = ["sinisterchipmunk@gmail.com"]
+
+  spec.summary       = %q{Vulkan bindings for Ruby}
+  spec.homepage      = "https://github.com/sinisterchipmunk/vulkan-ruby"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://www.rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 3.1.1'
+  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 "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_dependency 'sorted_set'
+end