vulkan-ruby 0.1.0

data/examples/shaders/depth_buffering.vert

@@ -0,0 +1,25 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 0) uniform UniformBufferObject {
+    mat4 model;
+    mat4 view;
+    mat4 proj;
+} ubo;
+
+layout(location = 0) in vec3 inPosition;
+layout(location = 1) in vec3 inColor;
+layout(location = 2) in vec2 inTexCoord;
+
+layout(location = 0) out vec3 fragColor;
+layout(location = 1) out vec2 fragTexCoord;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+    gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0);
+    fragColor = inColor;
+    fragTexCoord = inTexCoord;
+}

data/examples/shaders/model_loading.frag

@@ -0,0 +1,13 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 1) uniform sampler2D texSampler;
+
+layout(location = 0) in vec3 fragColor;
+layout(location = 1) in vec2 fragTexCoord;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor * texture(texSampler, fragTexCoord).rgb, 1.0);
+}

data/examples/shaders/model_loading.vert

@@ -0,0 +1,25 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 0) uniform UniformBufferObject {
+    mat4 model;
+    mat4 view;
+    mat4 proj;
+} ubo;
+
+layout(location = 0) in vec3 inPosition;
+layout(location = 1) in vec3 inColor;
+layout(location = 2) in vec2 inTexCoord;
+
+layout(location = 0) out vec3 fragColor;
+layout(location = 1) out vec2 fragTexCoord;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+    gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0);
+    fragColor = inColor;
+    fragTexCoord = inTexCoord;
+}

data/examples/shaders/textures.frag

@@ -0,0 +1,13 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 1) uniform sampler2D texSampler;
+
+layout(location = 0) in vec3 fragColor;
+layout(location = 1) in vec2 fragTexCoord;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor * texture(texSampler, fragTexCoord * 2.0).rgb, 1.0);
+}

data/examples/shaders/textures.vert

@@ -0,0 +1,25 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 0) uniform UniformBufferObject {
+    mat4 model;
+    mat4 view;
+    mat4 proj;
+} ubo;
+
+layout(location = 0) in vec2 inPosition;
+layout(location = 1) in vec3 inColor;
+layout(location = 2) in vec2 inTexCoord;
+
+layout(location = 0) out vec3 fragColor;
+layout(location = 1) out vec2 fragTexCoord;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+    gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 0.0, 1.0);
+    fragColor = inColor;
+    fragTexCoord = inTexCoord;
+}

data/examples/shaders/triangle.frag

@@ -0,0 +1,10 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}

data/examples/shaders/triangle.vert

@@ -0,0 +1,25 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+layout(location = 0) out vec3 fragColor;
+
+vec2 positions[3] = vec2[](
+    vec2(0.0, -0.5),
+    vec2(-0.5, 0.5),
+    vec2(0.5, 0.5)
+);
+
+vec3 colors[3] = vec3[](
+    vec3(1.0, 0.0, 0.0),
+    vec3(0.0, 1.0, 0.0),
+    vec3(0.0, 0.0, 1.0)
+);
+
+void main() {
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    fragColor = colors[gl_VertexIndex];
+}

data/examples/shaders/uniform_buffer.vert

@@ -0,0 +1,22 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(binding = 0) uniform UniformBufferObject {
+    mat4 model;
+    mat4 view;
+    mat4 proj;
+} ubo;
+
+layout(location = 0) in vec2 inPosition;
+layout(location = 1) in vec3 inColor;
+
+layout(location = 0) out vec3 fragColor;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+    gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 0.0, 1.0);
+    fragColor = inColor;
+}

data/examples/shaders/vertex_buffer.vert

@@ -0,0 +1,16 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec2 inPosition;
+layout(location = 1) in vec3 inColor;
+
+layout(location = 0) out vec3 fragColor;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+    gl_Position = vec4(inPosition, 0.0, 1.0);
+    fragColor = inColor;
+}

data/examples/vt00_dump_info.rb

@@ -0,0 +1,24 @@
+require 'bundler/setup'
+require 'simplecov'
+require 'vulkan'
+require 'pp'
+
+puts 'SUPPORTED EXTENSIONS'
+puts '--------------------'
+puts
+pp Vulkan::Instance.extensions
+puts
+puts
+
+puts 'SUPPORTED LAYERS'
+puts '--------------------'
+puts
+pp Vulkan::Instance.layers
+puts
+puts
+
+puts 'PHYSICAL DEVICES'
+puts '----------------'
+puts
+pp Vulkan::Instance.new(extensions: []).physical_devices.map { |dev| dev.to_hash }
+puts

data/examples/vt01_triangle.rb

@@ -0,0 +1,140 @@
+# https://vulkan-tutorial.com/code/16_swap_chain_recreation.cpp
+
+require 'bundler/setup'
+require 'simplecov'
+require 'vulkan'
+require 'sdl2_vulkan'
+
+# Create a window that we plan to draw to
+SDL2.init(SDL2::INIT_EVERYTHING)
+window = SDL2::Window.create "Hello Triangle", 0, 0, 640, 480,
+                             SDL2::Window::Flags::VULKAN |
+                             SDL2::Window::Flags::RESIZABLE |
+                             0x00002000 # SDL2::Window::Flags::ALLOW_HIGHDPI
+
+# Create a Vulkan instance
+instance = Vulkan::Instance.new extensions: window.vk_instance_extensions
+
+# Create a rendering surface
+surface = instance.create_window_surface(window)
+
+# Choose an adequate physical device
+dev = instance.physical_devices.detect do |dev|
+  next false unless swapchain_surface_info = dev.swapchain_surface_info(surface)
+  builder = Vulkan::SwapchainBuilder.new(swapchain_surface_info)
+  dev.properties[:device_type] == :discrete_gpu &&
+    (builder.format rescue false) && (builder.presentation_mode rescue false)
+end
+raise 'could not find a suitable physical device' unless dev
+
+# Find a queue family that supports graphics
+graphics_queue_family = dev.queue_families.detect do |family|
+  family[:queue_count] > 0 && family.supports?(:graphics)
+end
+raise 'no graphics queue family available' unless graphics_queue_family
+
+# Find a queue family that supports presentation to the rendering surface
+presentation_queue_family = dev.queue_families.detect do |family|
+  family[:queue_count] > 0 && family.supports_presentation?(surface)
+end
+raise 'no graphics queue family available' unless presentation_queue_family
+
+# Create a logical device along with the needed extensions and chosen queues
+if graphics_queue_family == presentation_queue_family
+  device = dev.create queues: [{ family: graphics_queue_family,     priorities: [1.0] }],
+                      extensions: ['VK_KHR_swapchain']
+  presentation_queue = graphics_queue = device.queue_families[0][:queues][0]
+else
+  device = dev.create queues: [{ family: graphics_queue_family,     priorities: [1.0] },
+                               { family: presentation_queue_family, priorities: [1.0] }],
+                      extensions: ['VK_KHR_swapchain']
+  graphics_queue     = device.queue_families[0][:queues][0]
+  presentation_queue = device.queue_families[1][:queues][0]
+end
+
+command_pool = device.create_command_pool queue_family: graphics_queue_family
+
+shader_stages = [
+  device.create_shader_stage(file_path: File.expand_path('./shaders/triangle.vert.spv', __dir__),
+                             stage: Vulkan::VK_SHADER_STAGE_VERTEX_BIT),
+  device.create_shader_stage(file_path: File.expand_path('./shaders/triangle.frag.spv', __dir__),
+                             stage: Vulkan::VK_SHADER_STAGE_FRAGMENT_BIT)
+]
+
+rebuild_swap_chain = proc do
+  # Create a swapchain for image presentation
+  $swapchain = device.create_swapchain surface: surface,
+                                       surface_width: window.vk_drawable_size[0],
+                                       surface_height: window.vk_drawable_size[1]
+
+  # Create render pass with one subpass
+  render_pass = device.create_renderpass
+  subpass = render_pass.add_subpass
+  subpass.add_color_attachment_ref index: render_pass.add_attachment(format: $swapchain.format),
+                                   layout: :color
+  render_pass.commit
+
+  # Create a framebuffer for each image in the swap chain
+  framebuffers = $swapchain.image_views.map do |swapchain_image_view|
+    device.create_framebuffer(width: $swapchain.width,
+                              height: $swapchain.height,
+                              render_pass: render_pass,
+                              attachments: [swapchain_image_view])
+  end
+
+  # Create graphic pipeline
+  pipeline = device.create_pipeline(viewport: { width: $swapchain.width, height: $swapchain.height })
+  shader_stages.each { |stage| pipeline.add_shader_stage(stage) }
+  pipeline.commit(render_pass)
+
+  $command_buffers = command_pool.create_command_buffers(framebuffers.size) do |cmd, index|
+    cmd.render_pass(render_pass, framebuffer: framebuffers[index]) do
+      cmd.bind_pipeline(:graphics, pipeline)
+      cmd.draw(3, 1, 0, 0)
+    end
+  end
+end
+
+rebuild_swap_chain.call
+
+MAX_FRAMES_IN_FLIGHT = 2
+image_available_semaphores = MAX_FRAMES_IN_FLIGHT.times.map { device.create_semaphore }
+render_finished_semaphores = MAX_FRAMES_IN_FLIGHT.times.map { device.create_semaphore }
+in_flight_fences           = MAX_FRAMES_IN_FLIGHT.times.map { device.create_fence signaled: true }
+current_frame = 0
+frame_counter = 0
+done = false
+
+# Begin main event loop & drawing
+until done
+  frame_counter += 1
+  break if ENV['MAX_FRAMES'].to_i == frame_counter
+  while event = SDL2::Event.poll
+    case event
+    when SDL2::Event::Quit, SDL2::Event::KeyDown then done = true
+    when SDL2::Event::Window::RESIZED then rebuild_swap_chain.call
+    end
+  end
+
+  begin
+    in_flight_fences[current_frame].wait_and_reset
+    image_index = $swapchain.next_image_index(semaphore: image_available_semaphores[current_frame])
+    graphics_queue.submit([$command_buffers[image_index]],
+                          wait_semaphores:   [image_available_semaphores[current_frame]],
+                          wait_stages:       [Vulkan::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT],
+                          signal_semaphores: [render_finished_semaphores[current_frame]],
+                          fence:             in_flight_fences[current_frame])
+    presentation_queue.present(swapchains:      [$swapchain],
+                               image_indices:   [image_index],
+                               wait_semaphores: [render_finished_semaphores[current_frame]])
+    current_frame = (current_frame + 1) % MAX_FRAMES_IN_FLIGHT
+  rescue Vulkan::Error
+    case $!.code
+    when Vulkan::VK_ERROR_OUT_OF_DATE_KHR, Vulkan::VK_SUBOPTIMAL_KHR
+      rebuild_swap_chain.call
+    else raise
+    end
+  end
+end
+
+in_flight_fences.each { |fence| fence.wait_and_reset }

data/examples/vt02_vertex_buffer_triangle_host_visible.rb

@@ -0,0 +1,164 @@
+# https://vulkan-tutorial.com/code/18_vertex_buffer.cpp
+
+require 'bundler/setup'
+require 'simplecov'
+require 'vulkan'
+require 'sdl2_vulkan'
+
+Vertex = Vulkan.struct(['float pos[2]', 'float color[3]'])
+VertexData = Vulkan.struct('vertices[3]' => Vertex).malloc
+VertexData.vertices[0].pos = [ 0,  -0.5]; VertexData.vertices[0].color = [1, 0, 0]
+VertexData.vertices[1].pos = [-0.5, 0.5]; VertexData.vertices[1].color = [0, 1, 0]
+VertexData.vertices[2].pos = [ 0.5, 0.5]; VertexData.vertices[2].color = [0, 0, 1]
+
+# Create a window that we plan to draw to
+SDL2.init(SDL2::INIT_EVERYTHING)
+window = SDL2::Window.create "test-vulkan", 0, 0, 640, 480, SDL2::Window::Flags::VULKAN |
+                                                            SDL2::Window::Flags::RESIZABLE |
+                                                            0x00002000 # SDL2::Window::Flags::ALLOW_HIGHDPI
+
+# Create a Vulkan instance
+instance = Vulkan::Instance.new extensions: window.vk_instance_extensions
+
+# Create a rendering surface
+surface = instance.create_window_surface(window)
+
+# Choose an adequate physical device
+dev = instance.physical_devices.detect do |dev|
+  next false unless swapchain_surface_info = dev.swapchain_surface_info(surface)
+  builder = Vulkan::SwapchainBuilder.new(swapchain_surface_info)
+  dev.properties[:device_type] == :discrete_gpu &&
+    (builder.format rescue false) && (builder.presentation_mode rescue false)
+end
+raise 'could not find a suitable physical device' unless dev
+
+# Find a queue family that supports graphics
+graphics_queue_family = dev.queue_families.detect do |family|
+  family[:queue_count] > 0 && family.supports?(:graphics)
+end
+raise 'no graphics queue family available' unless graphics_queue_family
+
+# Find a queue family that supports presentation to the rendering surface
+presentation_queue_family = dev.queue_families.detect do |family|
+  family[:queue_count] > 0 && family.supports_presentation?(surface)
+end
+raise 'no graphics queue family available' unless presentation_queue_family
+
+# Create a logical device along with the needed extensions and chosen queues
+if graphics_queue_family == presentation_queue_family
+  device = dev.create queues: [{ family: graphics_queue_family,     priorities: [1.0] }],
+                      extensions: ['VK_KHR_swapchain']
+  presentation_queue = graphics_queue = device.queue_families[0][:queues][0]
+else
+  device = dev.create queues: [{ family: graphics_queue_family,     priorities: [1.0] },
+                               { family: presentation_queue_family, priorities: [1.0] }],
+                      extensions: ['VK_KHR_swapchain']
+  graphics_queue     = device.queue_families[0][:queues][0]
+  presentation_queue = device.queue_families[1][:queues][0]
+end
+
+VertexBuffer = device.create_buffer size: VertexData.class.size, usage: Vulkan::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
+VertexBuffer.map do |data|
+  data[0, VertexData.class.size] = VertexData[0, VertexData.class.size]
+end
+
+command_pool = device.create_command_pool queue_family: graphics_queue_family
+
+shader_stages = [
+  device.create_shader_stage(file_path: File.expand_path('./shaders/vertex_buffer.vert.spv', __dir__),
+                             stage: Vulkan::VK_SHADER_STAGE_VERTEX_BIT),
+  device.create_shader_stage(file_path: File.expand_path('./shaders/triangle.frag.spv', __dir__),
+                             stage: Vulkan::VK_SHADER_STAGE_FRAGMENT_BIT)
+]
+
+rebuild_swap_chain = proc do
+  # Create a swapchain for image presentation
+  $swapchain = device.create_swapchain surface: surface,
+                                       surface_width: window.vk_drawable_size[0],
+                                       surface_height: window.vk_drawable_size[1]
+
+  # Create render pass with one subpass
+  render_pass = device.create_renderpass
+  subpass = render_pass.add_subpass
+  subpass.add_color_attachment_ref index: render_pass.add_attachment(format: $swapchain.format),
+                                   layout: :color
+  render_pass.commit
+
+  # Create a framebuffer for each image in the swap chain
+  framebuffers = $swapchain.image_views.map do |swapchain_image_view|
+    device.create_framebuffer(width: $swapchain.width,
+                              height: $swapchain.height,
+                              render_pass: render_pass,
+                              attachments: [swapchain_image_view])
+  end
+
+  # Create graphic pipeline
+  pipeline = device.create_pipeline(viewport: { width: $swapchain.width, height: $swapchain.height })
+  pipeline.add_binding_description binding: 0,
+                                   stride: Vertex.size,
+                                   input_rate: Vulkan::VK_VERTEX_INPUT_RATE_VERTEX
+
+  pipeline.add_attribute_description binding: 0,
+                                     location: 0,
+                                     format: Vulkan::VK_FORMAT_R32G32_SFLOAT,
+                                     offset: Vertex.offsetof('pos')
+
+  pipeline.add_attribute_description binding: 0,
+                                     location: 1,
+                                     format: Vulkan::VK_FORMAT_R32G32B32_SFLOAT,
+                                     offset: Vertex.offsetof('color')
+  shader_stages.each { |stage| pipeline.add_shader_stage(stage) }
+  pipeline.commit(render_pass)
+
+  $command_buffers = command_pool.create_command_buffers(framebuffers.size) do |cmd, index|
+    cmd.render_pass(render_pass, framebuffer: framebuffers[index]) do
+      cmd.bind_pipeline(:graphics, pipeline)
+      cmd.bind_vertex_buffer(VertexBuffer)
+      cmd.draw(VertexData.vertices.size, 1, 0, 0)
+    end
+  end
+end
+
+rebuild_swap_chain.call
+
+MAX_FRAMES_IN_FLIGHT = 2
+image_available_semaphores = MAX_FRAMES_IN_FLIGHT.times.map { device.create_semaphore }
+render_finished_semaphores = MAX_FRAMES_IN_FLIGHT.times.map { device.create_semaphore }
+in_flight_fences           = MAX_FRAMES_IN_FLIGHT.times.map { device.create_fence signaled: true }
+current_frame = 0
+frame_counter = 0
+done = false
+
+# Begin main event loop & drawing
+until done
+  frame_counter += 1
+  break if ENV['MAX_FRAMES'].to_i == frame_counter
+  while event = SDL2::Event.poll
+    case event
+    when SDL2::Event::Quit, SDL2::Event::KeyDown then done = true
+    when SDL2::Event::Window::RESIZED then rebuild_swap_chain.call
+    end
+  end
+
+  begin
+    in_flight_fences[current_frame].wait_and_reset
+    image_index = $swapchain.next_image_index(semaphore: image_available_semaphores[current_frame])
+    graphics_queue.submit([$command_buffers[image_index]],
+                          wait_semaphores:   [image_available_semaphores[current_frame]],
+                          wait_stages:       [Vulkan::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT],
+                          signal_semaphores: [render_finished_semaphores[current_frame]],
+                          fence:             in_flight_fences[current_frame])
+    presentation_queue.present(swapchains:      [$swapchain],
+                               image_indices:   [image_index],
+                               wait_semaphores: [render_finished_semaphores[current_frame]])
+    current_frame = (current_frame + 1) % MAX_FRAMES_IN_FLIGHT
+  rescue Vulkan::Error
+    case $!.code
+    when Vulkan::VK_ERROR_OUT_OF_DATE_KHR, Vulkan::VK_SUBOPTIMAL_KHR
+      rebuild_swap_chain.call
+    else raise
+    end
+  end
+end
+
+in_flight_fences.each { |fence| fence.wait_and_reset }