vulkan-ruby 0.1.0

data/lib/vulkan/pipeline.rb

@@ -0,0 +1,294 @@
+module Vulkan
+  class Pipeline
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    attr_reader :layout
+    attr_reader :input
+    attr_reader :viewport
+    attr_reader :scissor
+    attr_reader :rasterizer
+    attr_reader :multisampling
+    attr_reader :blending
+    attr_reader :layouts
+    attr_reader :constant_ranges
+    attr_reader :descriptors
+    attr_accessor :specialization_constants
+
+    # TODO support multiple viewports
+    def initialize(vk, viewport: { }, scissor: { })
+      @vk = vk
+      @shader_stages = []
+      @layouts = []
+      @constant_ranges = []
+      @descriptors = []
+      @input = {
+        topology: :triangles,
+        primitive_restart: false
+      }
+      @viewport = {
+        left: 0,
+        top: 0,
+        width: 640,
+        height: 480,
+        min_depth: 0,
+        max_depth: 1
+      }.merge(viewport)
+      @scissor = {
+        left: 0,
+        top: 0,
+        width: 0xffffffff,
+        height: 0xffffffff
+      }.merge(scissor)
+      @rasterizer = {
+        depth_clamp: false,
+        discard_all: false,
+        polygon_mode: :fill,
+        line_width: 1.0,
+        cull_mode: :back,
+        front_face: :counter_clockwise,
+        depth_bias: false,
+        depth_bias_clamp: 0,
+        depth_bias_constant: 0,
+        depth_bias_slope: 0
+      }
+      @multisampling = {
+        sample_shading: false,
+        samples: 1,
+        min_sample_shading: 0.2,
+        sample_mask: nil,
+        alpha_to_coverage: false,
+        alpha_to_one: false
+      }
+      @blending = {
+        enabled: true,
+        color_writes: [ :red, :green, :blue, :alpha ],
+        src_color: :src_alpha,
+        dst_color: :one_minus_src_alpha,
+        src_alpha: :one,
+        dst_alpha: :zero,
+        color_op: :add,
+        alpha_op: :add
+      }
+      @binding_descriptions = []
+      @attribute_descriptions = []
+      @dynamic_states = []
+      @specialization_constants = {}
+    end
+
+    def add_binding_description(binding:, stride:, input_rate:)
+      binding_description = VkVertexInputBindingDescription.malloc
+      binding_description.binding   = binding
+      binding_description.stride    = stride
+      binding_description.inputRate = sym_to_vertex_input_rate(input_rate)
+      @binding_descriptions << binding_description
+    end
+
+    def add_attribute_description(binding:, location:, format:, offset:)
+      attribute_description = VkVertexInputAttributeDescription.malloc
+      attribute_description.binding  = binding
+      attribute_description.location = location
+      attribute_description.format   = sym_to_format(format)
+      attribute_description.offset   = offset
+      @attribute_descriptions << attribute_description
+    end
+
+    def add_descriptor_set_layout(*a, **b)
+      if a.size == 1 && b.empty? && a.first.kind_of?(Vulkan::DescriptorSetLayout)
+        @layouts << a[0]
+      else
+        Vulkan::DescriptorSetLayout.new(@vk, *a, **b).tap { |layout| @layouts << layout }
+      end
+    end
+
+    def add_shader_stage(shader_stage)
+      @shader_stages << shader_stage
+    end
+
+    def depth(test: true,
+              write: true,
+              compare_op: :less,
+              bounds_test: false,
+              min_bounds: 0,
+              max_bounds: 1,
+              stencil_test: false,
+              stencil_front: nil,
+              stencil_back: nil)
+      @depth_stencil = VkPipelineDepthStencilStateCreateInfo.malloc
+      @depth_stencil.sType                 = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
+      @depth_stencil.depthTestEnable       = bool_to_vk(test)
+      @depth_stencil.depthWriteEnable      = bool_to_vk(write)
+      @depth_stencil.depthCompareOp        = sym_to_compare_op(compare_op)
+      @depth_stencil.depthBoundsTestEnable = bool_to_vk(bounds_test)
+      @depth_stencil.minDepthBounds        = min_bounds
+      @depth_stencil.maxDepthBounds        = max_bounds
+      @depth_stencil.stencilTestEnable     = bool_to_vk(stencil_test)
+      # TODO stencil test options
+    end
+
+    def add_dynamic_state(which)
+      @dynamic_states << which
+    end
+
+    def construct_specialization_info(specialization_constants_hash)
+      specialization_info = nil
+      if specialization_constants_hash&.any?
+        specialization_data = ""
+        specialization_entries = specialization_constants_hash.map do |id, data|
+          VkSpecializationMapEntry.malloc.tap do |entry|
+            entry.constantID = id
+            entry.offset = specialization_data.size
+            entry.size = data.size
+            specialization_data << data
+          end
+        end
+        specialization_info = VkSpecializationInfo.malloc
+        specialization_info.mapEntryCount = specialization_entries.count
+        specialization_info.pMapEntries = array_of_structures(specialization_entries)
+        specialization_info.dataSize = specialization_data.size
+        specialization_info.pData = specialization_data
+      end
+      specialization_info
+    end
+
+    def commit(render_pass, first_subpass_index: 0)
+      @render_pass = render_pass
+
+      shader_stage_create_infos = @shader_stages.map do |stage|
+        stage_info = VkPipelineShaderStageCreateInfo.malloc
+        stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+        stage_info.stage = syms_to_shader_stage_flags(stage.stage)
+        stage_info.module = stage.module_handle
+        stage_info.pName = Fiddle::Pointer[stage.entry_point]
+        specs = construct_specialization_info(@specialization_constants[stage.stage])
+        stage_info.pSpecializationInfo = specs
+        stage_info
+      end
+
+      vertex_input_info = VkPipelineVertexInputStateCreateInfo.malloc
+      vertex_input_info.sType                           = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
+      vertex_input_info.vertexBindingDescriptionCount   = @binding_descriptions.size
+      vertex_input_info.pVertexBindingDescriptions      = array_of_structures(@binding_descriptions)
+      vertex_input_info.vertexAttributeDescriptionCount = @attribute_descriptions.size
+      vertex_input_info.pVertexAttributeDescriptions    = array_of_structures(@attribute_descriptions)
+
+      input_assembly = VkPipelineInputAssemblyStateCreateInfo.malloc
+      input_assembly.sType                  = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
+      input_assembly.topology               = sym_to_topology(@input[:topology])
+      input_assembly.primitiveRestartEnable = bool_to_vk(@input[:primitive_restart])
+
+      viewport = VkViewport.malloc
+      viewport.x        = @viewport[:left]
+      viewport.y        = @viewport[:top]
+      viewport.width    = @viewport[:width]
+      viewport.height   = @viewport[:height]
+      viewport.minDepth = @viewport[:min_depth]
+      viewport.maxDepth = @viewport[:max_depth]
+
+      scissor = VkRect2D.malloc
+      scissor.offset.x      = @scissor[:left]
+      scissor.offset.y      = @scissor[:top]
+      scissor.extent.width  = @scissor[:width]
+      scissor.extent.height = @scissor[:height]
+
+      viewport_state = VkPipelineViewportStateCreateInfo.malloc
+      viewport_state.sType         = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
+      # TODO support multiple viewports and scissors
+      viewport_state.viewportCount = 1
+      viewport_state.pViewports    = viewport
+      viewport_state.scissorCount  = 1
+      viewport_state.pScissors     = scissor
+
+      rasterizer = VkPipelineRasterizationStateCreateInfo.malloc
+      rasterizer.sType                   = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
+      rasterizer.depthClampEnable        = bool_to_vk(@rasterizer[:depth_clamp])
+      rasterizer.rasterizerDiscardEnable = bool_to_vk(@rasterizer[:discard_all])
+      rasterizer.polygonMode             = sym_to_polygon_mode(@rasterizer[:polygon_mode])
+      rasterizer.lineWidth               = @rasterizer[:line_width]
+      rasterizer.cullMode                = sym_to_cull_mode(@rasterizer[:cull_mode])
+      rasterizer.frontFace               = sym_to_front_face(@rasterizer[:front_face])
+      rasterizer.depthBiasEnable         = bool_to_vk(@rasterizer[:depth_bias])
+      rasterizer.depthBiasConstantFactor = @rasterizer[:depth_bias_constant]
+      rasterizer.depthBiasClamp          = @rasterizer[:depth_bias_clamp]
+      rasterizer.depthBiasSlopeFactor    = @rasterizer[:depth_bias_slope]
+
+      multisampling = VkPipelineMultisampleStateCreateInfo.malloc
+      multisampling.sType                 = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+      multisampling.sampleShadingEnable   = bool_to_vk(@multisampling[:sample_shading])
+      multisampling.rasterizationSamples  = num_to_samples(@multisampling[:samples])
+      multisampling.minSampleShading      = @multisampling[:min_sample_shading]
+      multisampling.pSampleMask           = @multisampling[:sample_mask]
+      multisampling.alphaToCoverageEnable = bool_to_vk(@multisampling[:alpha_to_coverage])
+      multisampling.alphaToOneEnable      = @multisampling[:alpha_to_one]      ? VK_TRUE : VK_FALSE
+
+      color_blend_attachment = VkPipelineColorBlendAttachmentState.malloc
+      color_blend_attachment.colorWriteMask      = @blending[:color_writes].reduce(0) do |v, sym|
+                                                     v | sym_to_color_component_bit(sym)
+                                                   end
+      color_blend_attachment.blendEnable         = bool_to_vk(@blending[:enabled])
+      color_blend_attachment.srcColorBlendFactor = sym_to_blend_factor(@blending[:src_color])
+      color_blend_attachment.dstColorBlendFactor = sym_to_blend_factor(@blending[:dst_color])
+      color_blend_attachment.colorBlendOp        = sym_to_blend_op(@blending[:color_op])
+      color_blend_attachment.srcAlphaBlendFactor = sym_to_blend_factor(@blending[:src_alpha])
+      color_blend_attachment.dstAlphaBlendFactor = sym_to_blend_factor(@blending[:dst_alpha])
+      color_blend_attachment.alphaBlendOp        = sym_to_blend_op(@blending[:alpha_op])
+
+      color_blending = VkPipelineColorBlendStateCreateInfo.malloc
+      color_blending.sType             = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+      color_blending.logicOpEnable     = VK_FALSE;
+      color_blending.logicOp           = VK_LOGIC_OP_COPY; # TODO
+      color_blending.attachmentCount   = 1 # TODO multiple blend attachments
+      color_blending.pAttachments      = color_blend_attachment
+      color_blending.blendConstants[0] = 0.0 # TODO
+      color_blending.blendConstants[1] = 0.0 # TODO
+      color_blending.blendConstants[2] = 0.0 # TODO
+      color_blending.blendConstants[3] = 0.0 # TODO
+
+      pipeline_layout_info = VkPipelineLayoutCreateInfo.malloc
+      pipeline_layout_info.sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
+      pipeline_layout_info.setLayoutCount         = @layouts.size
+      pipeline_layout_info.pSetLayouts            = array_of_structures(@layouts.map { |l| Vulkan.create_value('void *', l.to_ptr) })
+      pipeline_layout_info.pushConstantRangeCount = 0 # @constant_ranges.size
+      pipeline_layout_info.pPushConstantRanges    = nil # FIXME
+      raise NotImplemented, 'push constant ranges not implemented' if @constant_ranges.any?
+
+      pipeline_layout_p = Vulkan.create_value('void *', nil)
+      check_result @vk.vkCreatePipelineLayout(@vk.device, pipeline_layout_info, nil, pipeline_layout_p)
+      @layout = pipeline_layout_p.value
+      finalize_with @vk, :vkDestroyPipelineLayout, @vk.device, @layout, nil
+
+      if @dynamic_states.any?
+        dynamic_states = VkPipelineDynamicStateCreateInfo.malloc
+        dynamic_states.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
+        dynamic_states.dynamicStateCount = @dynamic_states.count
+        dynamic_states.pDynamicStates = array_of_uint32s(@dynamic_states.map { |state| sym_to_dynamic_state(state) })
+      else
+        dynamic_states = nil
+      end
+
+      pipeline_info = VkGraphicsPipelineCreateInfo.malloc
+      pipeline_info.sType               = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
+      pipeline_info.stageCount          = shader_stage_create_infos.size
+      pipeline_info.pStages             = array_of_structures(shader_stage_create_infos)
+      pipeline_info.pVertexInputState   = vertex_input_info
+      pipeline_info.pInputAssemblyState = input_assembly
+      pipeline_info.pViewportState      = viewport_state
+      pipeline_info.pRasterizationState = rasterizer
+      pipeline_info.pMultisampleState   = multisampling
+      pipeline_info.pDepthStencilState  = @depth_stencil
+      pipeline_info.pColorBlendState    = color_blending
+      pipeline_info.pDynamicState       = dynamic_states
+      pipeline_info.layout              = @layout
+      pipeline_info.renderPass          = render_pass.to_ptr
+      pipeline_info.subpass             = first_subpass_index
+      pipeline_info.basePipelineHandle  = nil # TODO
+      pipeline_info.basePipelineIndex   = -1 # TODO
+
+      pipeline_p = Vulkan.create_value('void *', nil)
+      check_result @vk.vkCreateGraphicsPipelines(@vk.device, nil, 1, pipeline_info, nil, pipeline_p)
+      @handle = pipeline_p.value
+      finalize_with @vk, :vkDestroyPipeline, @vk.device, @handle, nil
+    end
+  end
+end

data/lib/vulkan/platform.rb

@@ -0,0 +1,34 @@
+require 'fiddle'
+require 'rbconfig'
+
+module Vulkan
+  module Platform
+    def calling_convention_human
+      case calling_convention
+      when Fiddle::Function::STDCALL then :stdcall
+      when Fiddle::Function::DEFAULT then :default
+      else raise "BUG: can't identify calling convention???"
+      end
+    rescue NameError
+      :default
+    end
+
+    def calling_convention
+      case Vulkan.os
+      when :windows then Fiddle::Function::STDCALL
+      else Fiddle::Function::DEFAULT
+      end
+    rescue NameError
+      Fiddle::Function::DEFAULT
+    end
+
+    def os
+      case RbConfig::CONFIG['host_os']
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/ then :windows
+      when /darwin|mac os/                            then :osx
+      when /linux/, /solaris|bsd/                     then :linux
+      else raise 'could not determine vulkan library to load for this OS'
+      end
+    end
+  end
+end

data/lib/vulkan/queue.rb

@@ -0,0 +1,94 @@
+module Vulkan
+  class Queue
+    include Vulkan::Checks
+    include Vulkan::Conversions
+
+    attr_reader :priority
+    attr_reader :index
+
+    def initialize(vk, handle, priority:, index:)
+      @vk = vk
+      @handle = handle
+      @priority = priority
+      @index = index
+
+      # pointers used and reused during queue submit and presentment, to avoid
+      # unnecessary GC
+      @wait_semaphores_buffers = { 0 => nil }
+      @wait_stages_buffers = { 0 => nil }
+      @signal_semaphores_buffers = { 0 => nil }
+      @command_buffers_buffers = { 0 => nil }
+      @submit_infos = { 0 => nil, 1 => Vulkan.struct("infos[1]" => VkSubmitInfo).malloc }
+      @submit_infos[1].infos[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO
+      @image_indices_buffers = { 0 => nil }
+      @swapchains_buffers = { 0 => nil }
+      @present_info = VkPresentInfoKHR.malloc
+      @present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
+    end
+
+    def submit_infos(submit_infos, fence = nil)
+      submit_infos_p = @submit_infos[submit_infos.size] ||= Vulkan.struct("infos[#{submit_infos.size}]" => VkSubmitInfo).malloc
+      submit_infos.each_with_index do |info, i|
+        next if submit_infos_p.infos[i] == info
+        submit_infos_p.infos[i].copy_from(info)
+      end
+
+      check_result @vk.vkQueueSubmit(to_ptr, submit_infos.size, submit_infos_p, fence)
+    end
+
+    def wait_until_idle
+      @vk.vkQueueWaitIdle(to_ptr)
+    end
+
+    def submit(command_buffers, wait_semaphores: [], wait_stages: [], signal_semaphores: [], fence: nil)
+      wait_stages_p = @wait_stages_buffers[wait_stages.size] ||= Vulkan.struct(["VkPipelineStageFlags stages[#{wait_stages.size}]"]).malloc
+      wait_stages.each_with_index { |stage, index| wait_stages_p.stages[index] = stage }
+
+      wait_semaphores_p = @wait_semaphores_buffers[wait_semaphores.size] ||= Fiddle::Pointer.malloc(wait_semaphores.size * Fiddle::SIZEOF_VOIDP)
+      array_of_pointers(wait_semaphores, wait_semaphores_p)
+
+      signal_semaphores_p = @signal_semaphores_buffers[signal_semaphores.size] ||= Fiddle::Pointer.malloc(signal_semaphores.size * Fiddle::SIZEOF_VOIDP)
+      array_of_pointers(signal_semaphores, signal_semaphores_p)
+
+      command_buffers_p = @command_buffers_buffers[command_buffers.size] ||= Fiddle::Pointer.malloc(command_buffers.size * Fiddle::SIZEOF_VOIDP)
+      array_of_pointers(command_buffers, command_buffers_p)
+
+      submit_info = @submit_infos[1].infos[0]
+      submit_info.waitSemaphoreCount   = wait_semaphores.size
+      submit_info.pWaitSemaphores      = wait_semaphores_p
+      submit_info.pWaitDstStageMask    = wait_stages_p
+      submit_info.commandBufferCount   = command_buffers.size
+      submit_info.pCommandBuffers      = command_buffers_p
+      submit_info.signalSemaphoreCount = signal_semaphores.size
+      submit_info.pSignalSemaphores    = signal_semaphores_p
+
+      submit_infos(@submit_infos[1].infos, fence)
+    end
+
+    def present(swapchains:, image_indices:, wait_semaphores: [])
+      raise ArgumentError, "swapchains and image_indices must have same sizes" unless swapchains.size == image_indices.size
+
+      wait_semaphores_p = @wait_semaphores_buffers[wait_semaphores.size] ||= Fiddle::Pointer.malloc(wait_semaphores.size * Fiddle::SIZEOF_VOIDP)
+      array_of_pointers(wait_semaphores, wait_semaphores_p)
+
+      image_indices_p = @image_indices_buffers[image_indices.size] ||= Vulkan.struct(["uint32_t indices[#{image_indices.size}]"]).malloc
+      data = image_indices.pack("I*")
+      image_indices_p[0, data.size] = data
+
+      swapchains_p = @swapchains_buffers[swapchains.size] ||= Fiddle::Pointer.malloc(swapchains.size * Fiddle::SIZEOF_VOIDP)
+      array_of_pointers(swapchains, swapchains_p)
+
+      @present_info.waitSemaphoreCount = wait_semaphores.size
+      @present_info.pWaitSemaphores = wait_semaphores_p
+      @present_info.swapchainCount = swapchains.size
+      @present_info.pSwapchains = swapchains_p
+      @present_info.pImageIndices = image_indices_p
+      @present_info.pResults = nil
+      check_result @vk.vkQueuePresentKHR(to_ptr, @present_info)
+    end
+
+    def to_ptr
+      @handle
+    end
+  end
+end

data/lib/vulkan/queue_family.rb

@@ -0,0 +1,27 @@
+module Vulkan
+  class QueueFamily < Hash
+    include Vulkan::Checks
+    
+    attr_reader :physical_device
+
+    def initialize(instance, physical_device, family_index)
+      super()
+      @physical_device = physical_device
+      @vk = Vulkan[instance, nil]
+      @family_index = family_index
+    end
+
+    def supports?(feature)
+      self[:supports].include?(feature)
+    end
+
+    def supports_presentation?(surface)
+      supported_p = Vulkan.create_value('VkBool32', 0)
+      check_result @vk.vkGetPhysicalDeviceSurfaceSupportKHR(@physical_device.to_ptr,
+                                                                   @family_index,
+                                                                   surface.to_ptr,
+                                                                   supported_p)
+      return supported_p.value == VK_TRUE
+    end
+  end
+end

data/lib/vulkan/render_pass/subpass.rb

@@ -0,0 +1,80 @@
+module Vulkan
+  class RenderPass
+    class Subpass
+      include Vulkan::Conversions
+
+      def initialize(vk, bind_point: :graphics)
+        @color_attachments    = []
+        @input_attachments    = []
+        @resolve_attachments  = []
+        @preserve_attachments = []
+
+        @ptr = VkSubpassDescription.malloc
+        @ptr.pipelineBindPoint       = sym_to_pipeline_bind_point(bind_point)
+        @ptr.colorAttachmentCount    = 0
+        @ptr.pColorAttachments       = nil
+        @ptr.inputAttachmentCount    = 0
+        @ptr.pInputAttachments       = nil
+        @ptr.pResolveAttachments     = nil
+        @ptr.pDepthStencilAttachment = nil
+        @ptr.preserveAttachmentCount = 0
+        @ptr.pPreserveAttachments    = nil
+      end
+
+      def add_attachment_ref(ary, index:, layout:, addr_mbr:, count_mbr:)
+        ary << create_attachment_ref(index, layout)
+        update_attachment_refs(ary, addr_mbr: addr_mbr, count_mbr: count_mbr)
+      end
+
+      def update_attachment_refs(ary, addr_mbr:, count_mbr:)
+        @ptr.send(:"#{addr_mbr}=",  array_of_structures(ary))
+        @ptr.send(:"#{count_mbr}=", ary.size) if count_mbr
+      end
+
+      def add_color_attachment_ref(index:, layout: :color)
+        add_attachment_ref(@color_attachments, index: index,
+                                               layout: layout,
+                                               addr_mbr: :pColorAttachments,
+                                               count_mbr: :colorAttachmentCount)
+      end
+
+      def add_resolve_attachment_ref(index:, layout: :color)
+        add_attachment_ref(@resolve_attachments, index: index,
+                                                 layout: layout,
+                                                 addr_mbr: :pResolveAttachments,
+                                                 count_mbr: nil)
+      end
+
+      def add_input_attachment_ref(index:, layout:)
+        add_attachment_ref(@input_attachments, index: index,
+                                               layout: layout,
+                                               addr_mbr: :pInputAttachments,
+                                               count_mbr: :inputAttachmentCount)
+      end
+
+      def add_preserve_attachment_ref(index:, layout:)
+        add_attachment_ref(@preserve_attachments, index: index,
+                                                  layout: layout,
+                                                  addr_mbr: :pPreserveStencilAttachments,
+                                                  count_mbr: :preserveStencilAttachmentCount)
+      end
+
+      def set_depth_stencil_attachment_ref(index:, layout: :depth_stencil_attachment_optimal)
+        ref = create_attachment_ref(index, layout)
+        @depth_stencil_attachment = ref
+        @ptr.pDepthStencilAttachment = ref
+      end
+
+      def to_ptr
+        @ptr&.to_ptr
+      end
+
+      def create_attachment_ref(index, layout)
+        ref = VkAttachmentReference.malloc
+        ref.attachment = index # attachment index
+        ref.layout = sym_to_image_layout(layout)
+        ref
+      end
+    end
+  end
+end

data/lib/vulkan/render_pass.rb

@@ -0,0 +1,71 @@
+module Vulkan
+  class RenderPass
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    attr_reader :attachments
+
+    def initialize(vk)
+      @vk = vk
+      @attachments = []
+      @subpasses = []
+    end
+
+    def to_ptr
+      super || raise(RuntimeError, 'call #commit first')
+    end
+
+    def commit
+      render_pass_info = VkRenderPassCreateInfo.malloc
+      render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
+      render_pass_info.attachmentCount = @attachments.size
+      render_pass_info.pAttachments = array_of_structures(@attachments)
+      render_pass_info.subpassCount = @subpasses.size
+      render_pass_info.pSubpasses = array_of_structures(@subpasses)
+
+      dependency = VkSubpassDependency.malloc
+      dependency.srcSubpass = VK_SUBPASS_EXTERNAL
+      dependency.dstSubpass = 0
+      dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
+      dependency.srcAccessMask = 0
+      dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
+      dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
+      
+      render_pass_info.dependencyCount = 1
+      render_pass_info.pDependencies = dependency
+
+      render_pass_p = Vulkan.create_value('void *', nil)
+      check_result @vk.vkCreateRenderPass(@vk.device, render_pass_info, nil, render_pass_p)
+      @handle = render_pass_p.value
+      finalize_with @vk, :vkDestroyRenderPass, @vk.device, @handle, nil
+    end
+
+    def add_attachment(format:,
+                       samples: 1,
+                       load_op: :clear,
+                       store_op: :store,
+                       stencil_load_op: :dont_care,
+                       stencil_store_op: :dont_care,
+                       initial_layout: nil,
+                       final_layout: :presentation_src)
+      attachment = VkAttachmentDescription.malloc
+      attachment.format         = sym_to_image_format(format)
+      attachment.samples        = num_to_samples(samples)
+      attachment.loadOp         = sym_to_load_op(load_op)
+      attachment.storeOp        = sym_to_store_op(store_op)
+      attachment.stencilLoadOp  = sym_to_load_op(stencil_load_op)
+      attachment.stencilStoreOp = sym_to_store_op(stencil_store_op)
+      attachment.initialLayout  = sym_to_image_layout(initial_layout)
+      attachment.finalLayout    = sym_to_image_layout(final_layout)
+      @attachments << attachment
+      @attachments.size - 1
+    end
+
+    def add_subpass(**args)
+      subpass = Vulkan::RenderPass::Subpass.new(@vk, **args)
+      @subpasses << subpass
+      subpass
+    end
+  end
+end

data/lib/vulkan/sampler.rb

@@ -0,0 +1,48 @@
+module Vulkan
+  class Sampler
+    include Vulkan::Checks
+    include Vulkan::Conversions
+    include Vulkan::Finalizer
+
+    def initialize(vk, device,
+                       mag_filter: :linear,
+                       min_filter: :linear,
+                       address_mode_u: :repeat,
+                       address_mode_v: :repeat,
+                       address_mode_w: :repeat,
+                       anisotropy: device.feature_enabled?(:sampler_anisotropy),
+                       max_anisotropy: anisotropy ? 16 : 1,
+                       border_color: :int_opaque_black,
+                       unnormalized_coords: false,
+                       compare: false,
+                       compare_op: :always,
+                       mipmap_mode: :linear,
+                       mip_lod_bias: 0,
+                       min_lod: 0,
+                       max_lod: 0
+                  )
+      sampler_info = VkSamplerCreateInfo.malloc
+      sampler_info.sType                   = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
+      sampler_info.magFilter               = sym_to_filter(mag_filter)
+      sampler_info.minFilter               = sym_to_filter(min_filter)
+      sampler_info.addressModeU            = sym_to_sampler_address_mode(address_mode_u)
+      sampler_info.addressModeV            = sym_to_sampler_address_mode(address_mode_v)
+      sampler_info.addressModeW            = sym_to_sampler_address_mode(address_mode_w)
+      sampler_info.anisotropyEnable        = bool_to_vk(anisotropy)
+      sampler_info.maxAnisotropy           = max_anisotropy
+      sampler_info.borderColor             = sym_to_border_color(border_color)
+      sampler_info.unnormalizedCoordinates = bool_to_vk(unnormalized_coords)
+      sampler_info.compareEnable           = bool_to_vk(compare)
+      sampler_info.compareOp               = sym_to_compare_op(compare_op)
+      sampler_info.mipmapMode              = sym_to_sampler_mipmap_mode(mipmap_mode)
+      sampler_info.mipLodBias              = mip_lod_bias
+      sampler_info.minLod                  = min_lod
+      sampler_info.maxLod                  = max_lod
+    
+      handle_p = Vulkan.create_value('void *', nil)
+      check_result vk.vkCreateSampler(vk.device, sampler_info, nil, handle_p)
+      @handle = handle_p.value
+      finalize_with vk, :vkDestroySampler, vk.device, @handle, nil
+    end
+  end
+end

data/lib/vulkan/semaphore.rb

@@ -0,0 +1,16 @@
+module Vulkan
+  class Semaphore
+    include Vulkan::Checks
+    include Vulkan::Finalizer
+
+    def initialize(vk)
+      @vk = vk
+      semaphore_info = VkSemaphoreCreateInfo.malloc
+      semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
+      sem_p = Vulkan.create_value('void *', nil)
+      check_result @vk.vkCreateSemaphore(@vk.device, semaphore_info, nil, sem_p)
+      @handle = sem_p.value
+      finalize_with @vk, :vkDestroySemaphore, @vk.device, @handle, nil
+    end
+  end
+end