vulkan-ruby 0.1.0

data/lib/vulkan/logical_device.rb

@@ -0,0 +1,165 @@
+module Vulkan
+  class LogicalDevice
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+    
+    attr_reader :physical_device
+    attr_reader :queue_families
+    attr_reader :enabled_features
+
+    def initialize(instance, physical_device, queues:, extensions:, features: physical_device.supported_features)
+      raise ArgumentError, "instance can't be nil" unless instance
+      raise ArgumentError, "physical_device can't be nil" unless physical_device
+      @instance = instance
+      @physical_device = physical_device
+
+      extensions.concat ENV['DEVICE_EXTENSIONS'].split(/\:\s/) if ENV['DEVICE_EXTENSIONS']
+
+      if queues.size == 0
+        # take the first available queue, to satisfy the spec (must request a queue)
+        queues = [{ family: physical_device.queue_families.first, priorities: [1.0] }]
+      end
+
+      queues_p = queues.each_with_index.map do |queue_info, index|
+        family_index = queue_family_to_index(queue_info[:family])
+        priorities   = queue_info[:priorities]   || raise(ArgumentError, 'queue :priorities (array of floats) is required')
+
+        priorities = [1.0] if priorities.size == 0
+        queue_priorities_p = Fiddle::Pointer.malloc(Fiddle::SIZEOF_FLOAT * priorities.size)
+        priorities.each_with_index do |priority, i|
+          queue_priorities_p[i * Fiddle::SIZEOF_FLOAT, Fiddle::SIZEOF_FLOAT] = [priority].pack(Fiddle::PackInfo::PACK_MAP[Fiddle::TYPE_FLOAT])
+        end
+
+        device_queue_info = VkDeviceQueueCreateInfo.malloc
+        device_queue_info.sType                   = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
+        device_queue_info.pNext                   = nil
+        device_queue_info.flags                   = 0
+        device_queue_info.queueFamilyIndex        = family_index
+        device_queue_info.queueCount              = priorities.size
+        device_queue_info.pQueuePriorities        = queue_priorities_p
+        device_queue_info
+      end
+      queue_infos_p = array_of_structures(queues_p)
+
+      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
+
+      enabled_features = VkPhysicalDeviceFeatures.malloc
+      enabled_features.to_ptr.copy_from physical_device.features.to_ptr
+      enabled_features.class.members.each do |member|
+        member_name = member.gsub(/[0-9A-Z]+/) { |x| "_#{x.downcase}" }.to_sym
+        if features.include?(member_name)
+          if enabled_features[member] == VK_FALSE
+            raise Error::UnsupportedFeature.new(member_name, member)
+          end
+        else
+          enabled_features[member] = VK_FALSE
+        end
+      end
+      @enabled_features = struct_to_hash(enabled_features).reject! { |name, enabled| enabled != VK_TRUE }.keys
+
+      device_create_info = VkDeviceCreateInfo.malloc
+      device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
+      device_create_info.pNext = nil
+      device_create_info.flags = 0
+      device_create_info.queueCreateInfoCount = queues.size
+      device_create_info.pQueueCreateInfos = queue_infos_p
+      device_create_info.enabledLayerCount = 0 # deprecated
+      device_create_info.ppEnabledLayerNames = nil
+      device_create_info.enabledExtensionCount = extensions.size
+      device_create_info.ppEnabledExtensionNames = extensions_p
+      device_create_info.pEnabledFeatures = enabled_features
+
+      device_wrapper = Vulkan.create_value("void *", nil)
+      check_result Vulkan[instance, nil].vkCreateDevice(physical_device.to_ptr, device_create_info, nil, device_wrapper)
+      @handle = device_wrapper.value
+      @vk = Vulkan[instance, self]
+      finalize_with Vulkan[instance, nil], :vkDestroyDevice, @handle, nil
+
+      queue_handle_wrapper = Vulkan.create_value("void *", nil)
+      @queue_families = queues.map do |queue|
+        queues = queue[:priorities].each_with_index.map do |priority, index|
+          @vk.vkGetDeviceQueue(@handle, queue_family_to_index(queue[:family]), index, queue_handle_wrapper)
+          Vulkan::Queue.new(@vk, queue_handle_wrapper.value, index: index, priority: priority)
+        end
+        queue[:family].merge queues: queues
+      end
+    end
+
+    def max_samples
+      physical_device.max_samples
+    end
+
+    def max_color_samples
+      physical_device.max_color_samples
+    end
+
+    def max_depth_samples
+      physical_device.max_depth_samples
+    end
+
+    def feature_enabled?(feature_name)
+      @enabled_features.include?(feature_name)
+    end
+
+    def create_buffer(**args)
+      Vulkan::Buffer.new(@vk, physical_device, **args)
+    end
+
+    def create_shader_stage(**args)
+      Vulkan::ShaderStage.new(@vk, **args)
+    end
+
+    def create_fence(**args)
+      Vulkan::Fence.new(@vk, **args)
+    end
+
+    def create_semaphore
+      Vulkan::Semaphore.new(@vk)
+    end
+
+    def create_pipeline(**args)
+      Vulkan::Pipeline.new(@vk, **args)
+    end
+
+    def create_swapchain(**args)
+      Vulkan::Swapchain.new(@instance, self, **args)
+    end
+
+    def create_renderpass
+      Vulkan::RenderPass.new(@vk)
+    end
+
+    def create_command_pool(**args)
+      Vulkan::CommandPool.new(@vk, **args)
+    end
+
+    def create_descriptor_set_pool(**args)
+      Vulkan::DescriptorPool.new(@vk, **args)
+    end
+
+    def create_image(**args)
+      Vulkan::Image.new(@vk, physical_device, **args)
+    end
+
+    def create_sampler(**args)
+      Vulkan::Sampler.new(@vk, self, **args)
+    end
+
+    def create_framebuffer(**args)
+      Vulkan::Framebuffer.new(@vk, **args)
+    end
+
+    def hexaddr
+      to_ptr.to_i.to_s(16)
+    end
+
+    def to_ptr
+      @handle
+    end
+  end
+end

data/lib/vulkan/memory.rb

@@ -0,0 +1,171 @@
+module Vulkan
+  class Memory
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    attr_reader :requirements
+    attr_reader :physical_device
+
+    def initialize(vk, physical_device,
+                       owner:,
+                       properties: [:host_visible])
+      @range_array = nil
+      @vk = vk
+      @physical_device = physical_device
+      @properties = syms_to_memory_properties(properties)
+      @owner = owner
+      @mapped = Vulkan.create_value('void *', nil)
+
+      @requirements = query_memory_requirements
+
+      alloc_info = VkMemoryAllocateInfo.malloc
+      alloc_info.sType           = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
+      alloc_info.allocationSize  = @requirements.size
+      alloc_info.memoryTypeIndex = memory_type_index
+      memory_handle_p = Vulkan.create_value('void *', nil)
+      check_result @vk.vkAllocateMemory(@vk.device, alloc_info, nil, memory_handle_p)
+      @handle = memory_handle_p.value
+      finalize_with @vk, :vkFreeMemory, @vk.device, @handle, nil
+      bind
+    end
+
+    def size
+      @requirements.size
+    end
+
+    def memory_type_index
+      properties = {}
+      physical_device.memory_properties[:memory_type_count].times do |i|
+        if (requirements.memoryTypeBits & (1 << i)) != 0
+          if (physical_device.memory_properties[:memory_types][i][:property_flags] & @properties) == @properties
+            return i
+          else
+            properties[i] = "0x%x" % physical_device.memory_properties[:memory_types][i][:property_flags]
+          end
+        end
+      end
+
+      raise 'failed to find suitable memory type (needed properties == 0x%x, memory type count == %d, requrement memory type bits == 0b%s, available properties == %s)' % [
+        @properties,
+        physical_device.memory_properties[:memory_type_count],
+        requirements.memoryTypeBits.to_s(2),
+        properties.inspect
+      ]
+    end
+
+    def data
+      raise 'no data pointer: buffer is not mapped' unless mapped?
+      @mapped
+    end
+
+    def mapped?
+      @mapped && @mapped.value.to_i != 0
+    end
+
+    def unmap
+      raise 'buffer is not mapped' unless mapped?
+      @mapped.value = nil
+      @vk.vkUnmapMemory(@vk.device, @handle)
+    end
+
+    # Flushes a single range of memory, which defaults to the entire buffer.
+    # Do this after modifying memory to inform the device that it may have
+    # changed. This method is called automatically after the block form of
+    # #map has completed, but is not called automatically if no block is
+    # provided to #map.
+    #
+    # See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFlushMappedMemoryRanges.html
+    def flush(offset: 0, size: offset > 0 ? self.size - offset : VK_WHOLE_SIZE)
+      flush_all [{ offset: offset, size: size }]
+    end
+
+    # Flushes each of a set of memory ranges, given as
+    # `[{:offset => number, :size => number}]`. No defaults are provided,
+    # and ArgumentError will be raised if any fields are omitted.
+    # Do this after modifying memory to inform the device that it may have
+    # changed.
+    #
+    # See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFlushMappedMemoryRanges.html
+    def flush_all(ranges)
+      @vk.vkFlushMappedMemoryRanges(@vk.device, ranges.size, memory_ranges(ranges))
+    end
+
+    # Invalidates a single range of memory, which defaults to the entire
+    # buffer. Do this prior to reading memory that may have been modified by
+    # a device. This method is called automatically at the beginning of #map,
+    # but is not called automatically at any other point, so if you leave
+    # the memory mapped (for example, by not passing a block to #map), then
+    # you need to call this method explicitly at the appropriate times.
+    #
+    # See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkInvalidateMappedMemoryRanges.html
+    def invalidate(offset: 0, size: offset > 0 ? self.size - offset : VK_WHOLE_SIZE)
+      invalidate_all [{ offset: offset, size: size }]
+    end
+
+    # Invalidates each of a set of memory ranges, given as
+    # `[{:offset => number, :size => number}]`. No defaults are provided,
+    # and ArgumentError will be raised if any fields are omitted. Do this
+    # prior to reading memory that may have been modified by a device.
+    #
+    # See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkInvalidateMappedMemoryRanges.html
+    def invalidate_all(ranges)
+      @vk.vkInvalidateMappedMemoryRanges(@vk.device, ranges.size, memory_ranges(ranges))
+    end
+
+    # Provides a pointer to an array of memory ranges for e.g. flushing memory
+    protected def memory_ranges(ranges)
+      # avoid reallocating @range_array if possible
+      unless @range_array&.ranges&.count.to_i >= ranges.count
+        @range_array = Vulkan.struct("ranges[#{ranges.count}]" => VkMappedMemoryRange).malloc
+        ranges.each_with_index do |rng, i|
+          range = @range_array.ranges[i]
+          range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
+          range.pNext = nil
+          range.memory = @handle
+        end
+      end
+      ranges.each_with_index do |rng, i|
+        range = @range_array.ranges[i]
+        range.offset = rng[:offset] || raise(ArgumentError, "memory range must specify :offset")
+        range.size   = rng[:size]   || raise(ArgumentError, "memory range must specify :size")
+      end
+      @range_array
+    end
+
+    # Maps this memory range. If a block is provided, a pointer to the start
+    # of the mapped memory range is yielded to the block and the memory is
+    # automatically unmapped after the block finishes and `nil` is returned
+    # to prevent writing to a no-longer-mapped address.
+    #
+    # If no block is provided, the memory remains mapped and the pointer is
+    # returned.
+    #
+    # If `invalidate` is true, the range to be mapped will be invalidated
+    # automatically before mapping to ensure that the memory will be up to
+    # date with any changes from the device. If false, the memory may be out
+    # of date when you map it.
+    #
+    # If `flush` is true, and a block is given, then the memory will be
+    # flushed to ensure that it is updated on the device after your block
+    # completes. If no block is given, this option has no effect.
+    def map(offset: 0, size: offset > 0 ? self.size - offset : VK_WHOLE_SIZE,
+            invalidate: true, flush: true, &block)
+      raise 'buffer is already mapped' if mapped?
+      self.invalidate offset: offset, size: size if invalidate
+      @vk.vkMapMemory(@vk.device, @handle, offset, size, 0, @mapped)
+      size = self.size if size == VK_WHOLE_SIZE
+      if block_given?
+        begin
+          yield Fiddle::Pointer.new(@mapped.value.to_i, size)
+        ensure
+          self.flush offset: offset, size: size if flush
+          unmap
+        end
+        return nil
+      else
+        return Fiddle::Pointer.new(@mapped.value.to_i, size)
+      end
+    end
+  end
+end

data/lib/vulkan/mock/swapchain_surface_info.rb

@@ -0,0 +1,42 @@
+module Vulkan
+  module Mock
+    # A mock object that you can use in your unit testing. This way you can
+    # construct Vulkan-ish data for testing against that doesn't depend on any
+    # underlying hardware. All of the properties of this object are optional,
+    # and sane (but arbitary) defaults will be provided for anything omitted.
+    class SwapchainSurfaceInfo
+      # These values were chosen arbitrarily.
+      DEFAULT_CAPABILITIES = {
+        min_image_count: 0,
+        max_image_count: 10,
+        current_extent: { width: 800, height: 600 },
+        min_image_extent: { width: 1, height: 1 },
+        max_image_extent: { width: 8192, height: 8192 },
+        max_image_array_layers: 128,
+        supported_transforms: [ :identity, :rotate_90, :rotate_180,
+                                :rotate_270, :horizontal_mirror,
+                                :horizontal_mirror_rotate_90,
+                                :horizontal_mirror_rotate_180,
+                                :horizontal_mirror_rotate_270,
+                                :inherit ],
+        current_transform: [ :identity ],
+        supported_composite_alpha: [ :opaque, :pre_multiplied, :post_multiplied, :inherit ],
+        supported_usage: [ :transfer_src, :transfer_dst, :sampled, :storage,
+                           :color_attachment, :depth_stencil_attachment,
+                           :transient_attachment, :input_attachment ]
+      }
+
+      attr_reader :presentation_modes
+      attr_reader :formats
+      attr_reader :capabilities
+
+      def initialize(presentation_modes: [:fifo, :mailbox, :immediate],
+                     formats: [{ format: :r8g8b8a8_snorm, color_space: :srgb_nonlinear }],
+                     **capabilities)
+        @presentation_modes = presentation_modes
+        @formats = formats
+        @capabilities = DEFAULT_CAPABILITIES.merge(capabilities)
+      end
+    end
+  end
+end

data/lib/vulkan/mock.rb

@@ -0,0 +1,5 @@
+module Vulkan
+  module Mock
+    autoload :SwapchainSurfaceInfo, 'vulkan/mock/swapchain_surface_info'
+  end
+end

data/lib/vulkan/physical_device.rb

@@ -0,0 +1,162 @@
+module Vulkan
+  class PhysicalDevice
+    include Vulkan::Checks
+    include Vulkan::Conversions
+
+    def initialize(instance, handle)
+      @handle = handle
+      @instance = instance
+      @vk = Vulkan[instance, nil]
+    end
+
+    def inspect
+      # force lazy instance variables to be initialized
+      to_hash
+      super
+    end
+
+    def to_ptr
+      @handle
+    end
+
+    def to_hash
+      {
+        extensions: extensions,
+        properties: properties,
+        features: features_hash,
+        queue_families: queue_families
+      }
+    end
+
+    def supported_features
+      struct_to_hash(features).reject! { |k, v| v != VK_TRUE }.keys
+    end
+
+    def unsupported_features
+      struct_to_hash(features).reject! { |k, v| v == VK_TRUE }.keys
+    end
+
+    def max_samples
+      [max_color_samples, max_depth_samples].min
+    end
+
+    def sample_counts_to_max(counts)
+      return VK_SAMPLE_COUNT_64_BIT if counts & VK_SAMPLE_COUNT_64_BIT != 0
+      return VK_SAMPLE_COUNT_32_BIT if counts & VK_SAMPLE_COUNT_32_BIT != 0
+      return VK_SAMPLE_COUNT_16_BIT if counts & VK_SAMPLE_COUNT_16_BIT != 0
+      return VK_SAMPLE_COUNT_8_BIT  if counts & VK_SAMPLE_COUNT_8_BIT  != 0
+      return VK_SAMPLE_COUNT_4_BIT  if counts & VK_SAMPLE_COUNT_4_BIT  != 0
+      return VK_SAMPLE_COUNT_2_BIT  if counts & VK_SAMPLE_COUNT_2_BIT  != 0
+      return VK_SAMPLE_COUNT_1_BIT
+    end
+
+    def max_color_samples
+      sample_counts_to_max properties[:limits][:framebuffer_color_sample_counts]
+    end
+
+    def max_depth_samples
+      sample_counts_to_max properties[:limits][:framebuffer_depth_sample_counts]
+    end
+
+    def detect_supported_format(*candidates, usage:, tiling: :optimal)
+      usage  = syms_to_format_feature_flags(usage)
+      tiling = sym_to_image_tiling(tiling)
+      candidates.flatten.each do |candidate|
+        props = VkFormatProperties.malloc
+        @vk.vkGetPhysicalDeviceFormatProperties(to_ptr, sym_to_format(candidate), props)
+        if tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & usage) == usage
+          return candidate
+        elsif tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & usage) == usage
+          return candidate
+        end
+      end
+      nil
+    end
+
+    # Returns the swapchain surface info if the `"VK_KHR_swapchain"` extension
+    # is supported, `nil` otherwise.
+    def swapchain_surface_info(surface)
+      if extension_names.include?('VK_KHR_swapchain')
+        SwapchainSurfaceInfo.new(@instance, self, surface)
+      else
+        nil
+      end
+    end
+
+    def extension_names
+      extensions.map { |ext| ext[:extension_name] }
+    end
+
+    def create_logical_device(**args)
+      Vulkan::LogicalDevice.new(@instance, self, **args)
+    end
+
+    alias create create_logical_device
+
+    def memory_properties
+      @memory_properties ||= begin
+        memory_properties = VkPhysicalDeviceMemoryProperties.malloc
+        @vk.vkGetPhysicalDeviceMemoryProperties(to_ptr, memory_properties)
+        struct_to_hash(memory_properties)
+      end
+    end
+
+    def queue_families
+      @queue_families ||= begin
+        count_ptr = Vulkan.create_value("uint32_t", 0)
+        @vk.vkGetPhysicalDeviceQueueFamilyProperties(@handle, count_ptr, nil)
+
+        container_struct = Vulkan.struct("queues[#{count_ptr.value}]" => VkQueueFamilyProperties)
+        container = container_struct.malloc
+        @vk.vkGetPhysicalDeviceQueueFamilyProperties(@handle, count_ptr, container)
+        container.queues.each_with_index.map do |prop, index|
+          info = struct_to_hash(prop, Vulkan::QueueFamily.new(@vk.instance, self, index))
+          info[:supports] = flags_to_symbols(info[:queue_flags], /^VK_QUEUE_(.*?)_BIT$/)
+          info[:index] = index
+          info[:queues] = [1.0]
+          info
+        end
+      end
+    end
+
+    def supports_feature?(feature_name)
+      features_hash[feature_name] == VK_TRUE
+    end
+
+    def features_hash
+      struct_to_hash features
+    end
+
+    def features
+      @features ||= begin
+        features = VkPhysicalDeviceFeatures.malloc
+        @vk.vkGetPhysicalDeviceFeatures(@handle, features)
+        features
+      end
+    end
+
+    def properties
+      @properties ||= begin
+        properties = VkPhysicalDeviceProperties.malloc
+        @vk.vkGetPhysicalDeviceProperties(@handle, properties)
+        properties = struct_to_hash(properties)
+        properties[:device_type] = const_to_symbol(properties[:device_type], /^VK_PHYSICAL_DEVICE_TYPE_(.*?)$/)
+        properties
+      end
+    end
+
+    def extensions
+      @extensions ||= begin
+        # get properties count
+        count_ptr = Vulkan.create_value("uint32_t", 0)
+        check_result @vk.vkEnumerateDeviceExtensionProperties(@handle, nil, count_ptr, nil)
+        count = count_ptr.value
+        # allocate n devices
+        container_struct = Vulkan.struct("handles[#{count}]" => VkExtensionProperties)
+        container = container_struct.malloc
+        check_result @vk.vkEnumerateDeviceExtensionProperties(@handle, nil, count_ptr, container)
+        container.handles.map { |handle| struct_to_hash(handle) }
+      end
+    end
+  end
+end