vulkan-ruby 0.1.0

data/lib/vulkan/generated.rb

@@ -0,0 +1,77 @@
+require 'fiddle/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'
+
+  class << self
+    @@lookup_map = {}
+    @@function_registry = {}
+
+    # Returns a dispatch table for the given instance and device.
+    def [](instance, device)
+      hash = [instance, device].hash
+      @@lookup_map[hash] ||= Vulkan::DispatchTable.new(instance, device)
+    end
+
+    def register_function(proto, params)
+      # DispatchTable can use method_missing to know the name of a function to
+      # look up, but we need to know the params and its return type, which come
+      # from vk.xml and which are foreign concepts to ruby so we need to
+      # persist that information for lookup within method_missing. See
+      # DispatchTable#method_missing.
+      signature = "#{proto}(#{params})"
+      name, ctype, argtype = parse_signature(signature, Vulkan.send(:type_alias))
+      function_registry[name.intern] = {
+        name: name,
+        return_type: ctype,
+        params_types: argtype,
+        prototype: proto,
+        params: params,
+        signature: signature
+      }
+    end
+
+    def function_registry
+      @@function_registry
+    end
+  end
+
+  require_relative 'generated/types'
+  require_relative 'generated/enums'
+  require_relative 'generated/structs'
+
+  extern "PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName)", :stdcall
+  require_relative 'generated/commands'
+  require_relative 'generated/extensions'
+end

data/lib/vulkan/image.rb

@@ -0,0 +1,263 @@
+module Vulkan
+  class Image
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    attr_reader :dimensions
+    attr_reader :width
+    attr_reader :height
+    attr_reader :depth
+    attr_reader :mip_levels
+    attr_reader :array_layers
+    attr_reader :format
+    attr_reader :tiling
+    attr_reader :initial_layout
+    attr_reader :layout
+    attr_reader :usage
+    attr_reader :sharing
+    attr_reader :samples
+    attr_reader :memory
+
+    # You should only set this if you have transitioned the image to a
+    # different layout outside of this class, by working directly with
+    # a command buffer.
+    attr_writer :layout
+
+    def initialize(vk, physical_device,
+                       dimensions: ,
+                       width: ,
+                       height: ,
+                       depth: ,
+                       mip_levels:     1,
+                       array_layers:   1,
+                       format:         :r8g8b8a8_unorm,
+                       tiling:         :optimal,
+                       initial_layout: :undefined,
+                       usage:          [:transfer_dst, :sampled],
+                       sharing:        :exclusive,
+                       samples:        1,
+                       flags:          [],
+                       properties:     :device_local)
+      @vk             = vk
+      @dimensions     = dimensions
+      @width          = width
+      @height         = height
+      @depth          = depth
+      @mip_levels     = mip_levels
+      @array_layers   = array_layers
+      @format         = format
+      @tiling         = tiling
+      @initial_layout = @layout = initial_layout
+      @usage          = usage
+      @sharing        = sharing
+      @samples        = samples
+      image_info = VkImageCreateInfo.malloc
+      image_info.sType         = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
+      image_info.imageType     = sym_to_image_type((1..3).include?(dimensions) ? :"#{dimensions}d" : dimensions)
+      image_info.extent.width  = width
+      image_info.extent.height = height
+      image_info.extent.depth  = depth
+      image_info.mipLevels     = mip_levels
+      image_info.arrayLayers   = array_layers
+      image_info.format        = sym_to_image_format(format)
+      image_info.tiling        = sym_to_image_tiling(tiling)
+      image_info.initialLayout = sym_to_image_layout(initial_layout)
+      image_info.usage         = syms_to_image_usage_flags(usage)
+      image_info.sharingMode   = sym_to_sharing_mode(sharing)
+      image_info.samples       = sym_to_samples(samples)
+      image_info.flags         = syms_to_image_create_flags(flags)
+      handle_p = Vulkan.create_value('VkImage')
+      check_result @vk.vkCreateImage(@vk.device, image_info, nil, handle_p)
+      @handle = handle_p.value
+      @memory = Vulkan::ImageMemory.new(@vk, physical_device, owner: self, properties: properties)
+      finalize_with @vk, :vkDestroyImage, @vk.device, @handle, nil
+    end
+
+    def create_view(format: self.format,
+                    base_mip_level: 0,
+                    level_count: mip_levels - base_mip_level,
+                    base_array_layer: 0,
+                    layer_count: array_layers - base_array_layer,
+                    aspects: :color,
+                    **other_image_view_args)
+      ImageView.new(@vk, self, format,
+                    base_mip_level:   base_mip_level,
+                    level_count:      level_count,
+                    base_array_layer: base_array_layer,
+                    layer_count:      layer_count,
+                    aspects:          aspects,
+                    **other_image_view_args)
+    end
+
+    def detect_transition_access_and_stage_flags(from, to)
+      from, to = sym_to_image_layout(from), sym_to_image_layout(to)
+      if from == VK_IMAGE_LAYOUT_UNDEFINED &&
+         to   == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
+        return {
+          src_access: 0,
+          dst_access: :transfer_write,
+          src_stages: :top_of_pipe,
+          dst_stages: :transfer,
+          dependencies: 0
+        }
+      elsif from == VK_IMAGE_LAYOUT_UNDEFINED &&
+            to   == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+        return {
+          src_access:   0,
+          dst_access:   :shader_read,
+          src_stages:   :color_attachment_output,
+          dst_stages:   :fragment_shader,
+          dependencies: 0
+        }
+      elsif from == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL &&
+            to   == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+        return {
+          src_access:   :transfer_write,
+          dst_access:   :shader_read,
+          src_stages:   :transfer,
+          dst_stages:   :fragment_shader,
+          dependencies: 0
+        }
+      elsif from == VK_IMAGE_LAYOUT_UNDEFINED &&
+            to   == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
+        return {
+          src_access: 0,
+          dst_access: [ :depth_stencil_attachment_read, :depth_stencil_attachment_write ],
+          src_stages: :top_of_pipe,
+          dst_stages: :early_fragment_tests,
+          dependencies: 0
+        }
+      elsif from == VK_IMAGE_LAYOUT_UNDEFINED &&
+            to   == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
+        return {
+          src_access: 0,
+          dst_access: [ :color_attachment_read, :color_attachment_write ],
+          src_stages: :top_of_pipe,
+          dst_stages: :color_attachment_output,
+          dependencies: 0
+        }
+      else
+        raise ArgumentError, "unsupported layout transition (%s to %s)!" % [from.inspect, to.inspect]
+      end
+    end
+
+    # Transitions the layout for this image using the given command buffer.
+    # Does not submit the command buffer. Use #transition_layout if you want
+    # to be sure the image has fully transitioned before continuing.
+    def transition_layout_using(cmd,
+                                from: self.layout,
+                                to:,
+                                src_queue_family: nil,
+                                dst_queue_family: nil,
+                                base_mip_level: 0,
+                                level_count: mip_levels - base_mip_level,
+                                base_array_layer: 0,
+                                layer_count: array_layers - base_array_layer,
+                                aspects: :color)
+      access_opts = detect_transition_access_and_stage_flags(from, to)
+      cmd.pipeline_image_barrier from_layout:      from,
+                                 to_layout:        to,
+                                 src_queue_family: src_queue_family,
+                                 dst_queue_family: dst_queue_family,
+                                 image:            self,
+                                 aspects:          aspects,
+                                 base_mip_level:   base_mip_level,
+                                 level_count:      level_count,
+                                 base_array_layer: base_array_layer,
+                                 layer_count:      layer_count,
+                                 **access_opts
+      @layout = to
+    end
+
+    # Transitions the layout for this image, using the given command pool to
+    # allocate a command buffer and using the given queue to submit it. If
+    # `wait_until_idle` is true, this method will block until the queue is
+    # idle. Otherwise, it will return as soon as the command buffer is
+    # submitted. See #transition_layout_with for other arguments.
+    def transition_layout(command_pool, queue, wait_until_idle: true, **other_args)
+      command_buffer = command_pool.create_command_buffer(usage: :one_time_submit) do |cmd|
+        transition_layout_using(cmd, **other_args)
+      end
+      queue.submit([command_buffer])
+      queue.wait_until_idle if wait_until_idle
+    end
+
+    def copy_from_buffer(command_pool, queue,
+                         buffer:,
+                         buffer_offset: 0,
+                         buffer_row_length: 0,
+                         buffer_image_height: 0,
+                         x: 0,
+                         y: 0,
+                         z: 0,
+                         width: self.width - x,
+                         height: self.height - y,
+                         depth: self.depth - z,
+                         aspects: :color,
+                         mip_level: 0,
+                         base_array_layer: 0,
+                         layer_count: array_layers - base_array_layer,
+                         wait_until_idle: true)
+      command_buffer = command_pool.create_command_buffer(usage: :one_time_submit) do |cmd|
+        cmd.copy_buffer_to_image buffer, self, [
+                                   buffer_offset:       buffer_offset,
+                                   buffer_row_length:   buffer_row_length,
+                                   buffer_image_height: buffer_image_height,
+                                   x:                   x,
+                                   y:                   y,
+                                   z:                   z,
+                                   width:               width,
+                                   height:              height,
+                                   depth:               depth,
+                                   aspects:             aspects,
+                                   mip_level:           mip_level,
+                                   base_array_layer:    base_array_layer,
+                                   layer_count:         layer_count
+                                 ]
+      end
+
+      queue.submit([command_buffer])
+      queue.wait_until_idle if wait_until_idle
+    end
+
+    # See CommandBuffer#blit_image for details. If `:wait_until_idle` is true,
+    # this method won't return until the blit operation has completed and its
+    # queue is idle.
+    def blit_from(command_pool, queue,
+                  src:,
+                  src_layout: :transfer_src_optimal,
+                  dst_layout: :transfer_dst_optimal,
+                  regions:,
+                  filter: :nearest,
+                  wait_until_idle: false)
+      command_buffer = command_pool.create_command_buffer(usage: :one_time_submit) do |cmd|
+        cmd.blit_image src_image: src,
+                       src_image_layout: src_layout,
+                       dst_image: self,
+                       dst_image_layout: dst_layout,
+                       regions: regions,
+                       filter: filter
+      end
+
+      queue.submit([command_buffer])
+      queue.wait_until_idle if wait_until_idle
+    end
+
+    def map(*args, &block)
+      memory.map(*args, &block)
+    end
+
+    def mapped?
+      memory.mapped?
+    end
+
+    def unmap
+      memory.unmap
+    end
+
+    def data
+      memory.data
+    end
+  end
+end

data/lib/vulkan/image_memory.rb

@@ -0,0 +1,13 @@
+module Vulkan
+  class ImageMemory < Memory
+    def query_memory_requirements
+      VkMemoryRequirements.malloc.tap do |req|
+        @vk.vkGetImageMemoryRequirements(@vk.device, @owner.to_ptr, req)
+      end
+    end
+
+    def bind
+      @vk.vkBindImageMemory(@vk.device, @owner.to_ptr, to_ptr, 0);
+    end
+  end
+end

data/lib/vulkan/image_view.rb

@@ -0,0 +1,46 @@
+module Vulkan
+  class ImageView
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    attr_reader :image
+
+    def initialize(vk, image, image_format,
+                   view_type: VK_IMAGE_VIEW_TYPE_2D,
+                   red_swizzle: VK_COMPONENT_SWIZZLE_IDENTITY,
+                   green_swizzle: VK_COMPONENT_SWIZZLE_IDENTITY,
+                   blue_swizzle: VK_COMPONENT_SWIZZLE_IDENTITY,
+                   alpha_swizzle: VK_COMPONENT_SWIZZLE_IDENTITY,
+                   aspects: :color,
+                   base_mip_level: 0,
+                   level_count: 1,
+                   base_array_layer: 0,
+                   layer_count: 1)
+      @vk = vk
+      @image = image
+      create_info = VkImageViewCreateInfo.malloc
+      create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
+      create_info.image = image.respond_to?(:to_ptr) ? image.to_ptr : image
+      create_info.viewType = view_type
+      create_info.format = sym_to_image_format(image_format)
+      create_info.components.r = red_swizzle
+      create_info.components.g = green_swizzle
+      create_info.components.b = blue_swizzle
+      create_info.components.a = alpha_swizzle
+      create_info.subresourceRange.aspectMask = syms_to_image_aspect_flags(aspects)
+      create_info.subresourceRange.baseMipLevel = base_mip_level
+      create_info.subresourceRange.levelCount = level_count
+      create_info.subresourceRange.baseArrayLayer = base_array_layer
+      create_info.subresourceRange.layerCount = layer_count
+      view_p = Vulkan.create_value("void *", nil)
+      check_result @vk.vkCreateImageView(vk.device, create_info, nil, view_p)
+      @handle = view_p.value
+      finalize_with @vk, :vkDestroyImageView, vk.device, @handle, nil
+    end
+
+    def to_ptr
+      @handle
+    end
+  end
+end

data/lib/vulkan/instance.rb

@@ -0,0 +1,183 @@
+module Vulkan
+  class Instance
+    extend  Vulkan::Checks
+    extend  Vulkan::Conversions
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    class << self
+      def extensions
+        @extensions ||= begin
+          property_count_ptr = Vulkan.create_value("uint32_t", 0)
+          check_result Vulkan[nil, nil].vkEnumerateInstanceExtensionProperties(nil, property_count_ptr, nil)
+          property_count = property_count_ptr.value
+          container = Vulkan.struct("properties[#{property_count}]" => VkExtensionProperties).malloc
+          check_result Vulkan[nil, nil].vkEnumerateInstanceExtensionProperties(nil, property_count_ptr, container)
+          container.properties.map { |prop| struct_to_hash(prop) }
+        end
+      end
+
+      def layers
+        @layers ||= begin
+          property_count_ptr = Vulkan.create_value("uint32_t", 0)
+          check_result Vulkan[nil, nil].vkEnumerateInstanceLayerProperties(property_count_ptr, nil)
+          property_count = property_count_ptr.value
+          container_struct = Vulkan.struct("properties[#{property_count}]" => VkLayerProperties)
+          container = container_struct.malloc
+          check_result Vulkan[nil, nil].vkEnumerateInstanceLayerProperties(property_count_ptr, container)
+          container.properties.map { |prop| struct_to_hash(prop) }
+        end
+      end
+
+      def extension_names
+        extensions.map { |ext| ext[:extension_name] }
+      end
+
+      def layer_names
+        layers.map { |layer| layer[:layer_name] }
+      end
+
+      def version
+        ver_p = Vulkan.create_value('uint32_t', 0)
+        check_result Vulkan[nil, nil].vkEnumerateInstanceVersion(ver_p)
+        vk_parse_version ver_p.value
+      end
+    end
+
+    def initialize(application_name: $0,            application_version: '1.0.0',
+                   engine_name: 'vulkan-ruby',      engine_version: Vulkan::VERSION,
+                   api_version: self.class.version, extensions: ,
+                   layers: [])
+      layers.concat     ENV['LAYERS'].split(/\:\s/)              if ENV['LAYERS']
+      extensions.concat ENV['INSTANCE_EXTENSIONS'].split(/\:\s/) if ENV['INSTANCE_EXTENSIONS']
+
+      if ENV['DEBUG']
+        extension_names = self.class.extension_names
+        %w(
+          VK_EXT_debug_utils
+        ).each { |ext_name| extensions << ext_name if extension_names.include?(ext_name) }
+
+        layer_names = self.class.layer_names
+        %w(
+          VK_LAYER_LUNARG_standard_validation
+          VK_LAYER_LUNARG_parameter_validation
+          VK_LAYER_LUNARG_assistant_layer
+          VK_LAYER_LUNARG_api_dump
+          VK_LAYER_GOOGLE_unique_objects
+          VK_LAYER_LUNARG_demo_layer
+          VK_LAYER_GOOGLE_threading
+          VK_LAYER_LUNARG_monitor
+          VK_LAYER_LUNARG_starter_layer
+          VK_LAYER_LUNARG_core_validation
+          VK_LAYER_LUNARG_object_tracker
+        ).each do |layer_name|
+          layers << layer_name if layer_names.include?(layer_name)
+        end
+      end
+
+      extensions_p = Vulkan.struct("names[#{extensions.size}]" => ['char *name']).malloc
+      extensions.each_with_index do |ext, i|
+        extname = ext.kind_of?(String) ? ext : ext[:extension_name]
+        extensions_p.names[i].name = Fiddle::Pointer[extname.b + "\x00"]
+      end
+
+      layers_p = Vulkan.struct("names[#{layers.size}]" => ['char *name']).malloc
+      layers.each_with_index do |layer, i|
+        layer_name = layer.kind_of?(String) ? layer : layer[:layer_name]
+        layers_p.names[i].name = Fiddle::Pointer[layer_name.b + "\x00"]
+      end
+
+      application_info = VkApplicationInfo.malloc
+      application_info.sType               = VK_STRUCTURE_TYPE_APPLICATION_INFO
+      application_info.pNext               = nil
+      application_info.pApplicationName    = application_name
+      application_info.applicationVersion  = vk_make_version(application_version)
+      application_info.pEngineName         = 'vulkan-ruby'
+      application_info.engineVersion       = vk_make_version(engine_version)
+      application_info.apiVersion          = vk_make_version(api_version)
+
+      instance_info = VkInstanceCreateInfo.malloc
+      instance_info.sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
+      instance_info.pNext                   = nil
+      instance_info.flags                   = 0
+      instance_info.pApplicationInfo        = application_info
+      instance_info.enabledLayerCount       = layers.size
+      instance_info.ppEnabledLayerNames     = layers_p
+      instance_info.enabledExtensionCount   = extensions.size
+      instance_info.ppEnabledExtensionNames = extensions_p
+
+      instance_wrapper = Vulkan.create_value("void *", nil)
+      check_result Vulkan[nil, nil].vkCreateInstance(instance_info, nil, instance_wrapper)
+      @handle = instance_wrapper.value
+      @vk = Vulkan[self, nil]
+      hook_debug_utils_callback if extensions.include?('VK_EXT_debug_utils')
+      finalize_with @vk, :vkDestroyInstance, @handle, nil
+    end
+
+    def on_log(&cb)
+      @log_callback = cb
+    end
+
+    def hook_debug_utils_callback
+      _, return_type, param_types = Vulkan.parse_signature('VkBool32 debug_callback(int   messageSeverity,' +
+                                                                                   'int   messageType,' +
+                                                                                   'void *pCallbackData,' +
+                                                                                   'void *pUserData)')
+      @debug_util_callback = Fiddle::Closure::BlockCaller.new(return_type, param_types) do |msg_severity, msg_type, cb_data_addr, user_arg_addr|
+        data     = VkDebugUtilsMessengerCallbackDataEXT.new(cb_data_addr)
+        type     = const_to_symbol(msg_type,     /^VK_DEBUG_UTILS_MESSAGE_TYPE_(.*?)_BIT_EXT$/)
+        severity = const_to_symbol(msg_severity, /^VK_DEBUG_UTILS_MESSAGE_SEVERITY_(.*?)_BIT_EXT$/)
+        if @log_callback
+          @log_callback.call severity, type, data.pMessage.to_s
+        else
+          puts ['[UTIL]', "[#{severity}]", "[#{type}]", data.pMessage.to_s].join("\t")
+        end
+        VK_FALSE # don't bail
+      end
+
+      create_info = VkDebugUtilsMessengerCreateInfoEXT.malloc
+      create_info.sType           = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT
+      create_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
+                                    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
+                                    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
+      create_info.messageType     = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT    |
+                                    VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
+                                    VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
+      create_info.pUserData       = nil
+      create_info.pfnUserCallback = @debug_util_callback
+
+      callback_p = Vulkan.create_value('void *', nil)
+      check_result @vk.vkCreateDebugUtilsMessengerEXT(to_ptr, create_info, nil, callback_p)
+      @debug_util_callback_handle = callback_p.value
+      finalize_with @vk, :vkDestroyDebugUtilsMessengerEXT, to_ptr, @debug_util_callback_handle, nil
+    end
+
+    def create_window_surface(window)
+      WindowSurface.new(self, window)
+    end
+
+    # Returns an array of physical device handles. Use these to query the
+    # capabilities of each physical device, and to create logical devices
+    # based on the results.
+    def physical_device_handles
+      @physical_device_handles ||= begin
+        # get device count
+        device_count_ptr = Vulkan.create_value("uint32_t", 0)
+        # check_result func.call(@handle, device_count_ptr, nil)
+        check_result @vk.vkEnumeratePhysicalDevices(@handle, device_count_ptr, nil)
+        device_count = device_count_ptr.value
+        # allocate n devices
+        container_struct = Vulkan.struct("handles[#{device_count}]" => ['VkPhysicalDevice handle'])
+        container = container_struct.malloc
+        # check_result func.call(@handle, device_count_ptr, container)
+        check_result @vk.vkEnumeratePhysicalDevices(@handle, device_count_ptr, container)
+        container.handles
+      end
+    end
+
+    def physical_devices
+      @physical_devices ||= physical_device_handles.map { |dev| PhysicalDevice.new(self, dev.handle) }
+    end
+  end
+end