wgpu 0.1.0

data/lib/wgpu/pipeline/bind_group_layout.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module WGPU
+  class BindGroupLayout
+    attr_reader :handle
+
+    def self.from_handle(handle)
+      layout = allocate
+      layout.instance_variable_set(:@handle, handle)
+      layout.instance_variable_set(:@device, nil)
+      layout
+    end
+
+    def initialize(device, label: nil, entries:)
+      @device = device
+
+      entries_array = entries.map { |e| create_entry(e) }
+      entries_ptr = FFI::MemoryPointer.new(Native::BindGroupLayoutEntry, entries_array.size)
+      entries_array.each_with_index do |entry, i|
+        offset = i * Native::BindGroupLayoutEntry.size
+        (entries_ptr + offset).put_bytes(0, entry.pointer.read_bytes(Native::BindGroupLayoutEntry.size))
+      end
+
+      desc = Native::BindGroupLayoutDescriptor.new
+      desc[:next_in_chain] = nil
+      if label
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+      desc[:entry_count] = entries_array.size
+      desc[:entries] = entries_ptr
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreateBindGroupLayout(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create bind group layout"
+        raise PipelineError, msg
+      end
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuBindGroupLayoutRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    private
+
+    def create_entry(entry_hash)
+      entry = Native::BindGroupLayoutEntry.new
+      entry[:next_in_chain] = nil
+      entry[:binding] = entry_hash[:binding]
+      entry[:visibility] = normalize_visibility(entry_hash[:visibility])
+
+      entry[:buffer][:next_in_chain] = nil
+      entry[:buffer][:type] = :binding_not_used
+      entry[:buffer][:has_dynamic_offset] = 0
+      entry[:buffer][:min_binding_size] = 0
+
+      entry[:sampler][:next_in_chain] = nil
+      entry[:sampler][:type] = :binding_not_used
+
+      entry[:texture][:next_in_chain] = nil
+      entry[:texture][:sample_type] = :binding_not_used
+      entry[:texture][:view_dimension] = :undefined
+      entry[:texture][:multisampled] = 0
+
+      entry[:storage_texture][:next_in_chain] = nil
+      entry[:storage_texture][:access] = :binding_not_used
+      entry[:storage_texture][:format] = :undefined
+      entry[:storage_texture][:view_dimension] = :undefined
+
+      if entry_hash[:buffer]
+        buffer_info = entry_hash[:buffer]
+        entry[:buffer][:type] = buffer_info[:type] || :storage
+        entry[:buffer][:has_dynamic_offset] = buffer_info[:has_dynamic_offset] ? 1 : 0
+        entry[:buffer][:min_binding_size] = buffer_info[:min_binding_size] || 0
+      end
+
+      if entry_hash[:sampler]
+        sampler_info = entry_hash[:sampler]
+        entry[:sampler][:type] = sampler_info[:type] || :filtering
+      end
+
+      if entry_hash[:texture]
+        texture_info = entry_hash[:texture]
+        entry[:texture][:sample_type] = texture_info[:sample_type] || :float
+        entry[:texture][:view_dimension] = texture_info[:view_dimension] || :d2
+        entry[:texture][:multisampled] = texture_info[:multisampled] ? 1 : 0
+      end
+
+      if entry_hash[:storage_texture]
+        st_info = entry_hash[:storage_texture]
+        entry[:storage_texture][:access] = st_info[:access] || :write_only
+        entry[:storage_texture][:format] = st_info[:format]
+        entry[:storage_texture][:view_dimension] = st_info[:view_dimension] || :d2
+      end
+
+      entry
+    end
+
+    def normalize_visibility(visibility)
+      case visibility
+      when Integer
+        visibility
+      when Symbol
+        Native::ShaderStage[visibility]
+      when Array
+        visibility.reduce(0) { |acc, v| acc | Native::ShaderStage[v] }
+      else
+        raise ArgumentError, "Invalid visibility: #{visibility}"
+      end
+    end
+  end
+end

data/lib/wgpu/pipeline/compute_pipeline.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module WGPU
+  class ComputePipeline
+    attr_reader :handle
+
+    def initialize(device, label: nil, layout:, compute:)
+      @device = device
+
+      entry_point = compute[:entry_point] || "main"
+      entry_point_ptr = FFI::MemoryPointer.from_string(entry_point)
+
+      desc = Native::ComputePipelineDescriptor.new
+      desc[:next_in_chain] = nil
+      if label
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+      desc[:layout] = layout.handle
+
+      desc[:compute][:next_in_chain] = nil
+      desc[:compute][:module] = compute[:module].handle
+      desc[:compute][:entry_point][:data] = entry_point_ptr
+      desc[:compute][:entry_point][:length] = entry_point.bytesize
+      desc[:compute][:constant_count] = 0
+      desc[:compute][:constants] = nil
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreateComputePipeline(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create compute pipeline"
+        raise PipelineError, msg
+      end
+    end
+
+    def get_bind_group_layout(index)
+      handle = Native.wgpuComputePipelineGetBindGroupLayout(@handle, index)
+      raise PipelineError, "Failed to get bind group layout at index #{index}" if handle.null?
+      BindGroupLayout.from_handle(handle)
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuComputePipelineRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/pipeline/pipeline_layout.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module WGPU
+  class PipelineLayout
+    attr_reader :handle
+
+    def initialize(device, label: nil, bind_group_layouts:)
+      @device = device
+
+      layouts = Array(bind_group_layouts)
+      layouts_ptr = FFI::MemoryPointer.new(:pointer, layouts.size)
+      layouts_ptr.write_array_of_pointer(layouts.map(&:handle))
+
+      desc = Native::PipelineLayoutDescriptor.new
+      desc[:next_in_chain] = nil
+      if label
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+      desc[:bind_group_layout_count] = layouts.size
+      desc[:bind_group_layouts] = layouts_ptr
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreatePipelineLayout(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create pipeline layout"
+        raise PipelineError, msg
+      end
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuPipelineLayoutRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/pipeline/render_pipeline.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module WGPU
+  class RenderPipeline
+    attr_reader :handle
+
+    def initialize(device, label: nil, layout:, vertex:, primitive: {}, depth_stencil: nil, multisample: {}, fragment: nil)
+      @device = device
+      @pointers = []
+
+      desc = Native::RenderPipelineDescriptor.new
+      desc[:next_in_chain] = nil
+      setup_label(desc, label)
+      desc[:layout] = layout.handle
+
+      setup_vertex_state(desc[:vertex], vertex)
+      setup_primitive_state(desc[:primitive], primitive)
+      setup_multisample_state(desc[:multisample], multisample)
+
+      if depth_stencil
+        ds_ptr = setup_depth_stencil_state(depth_stencil)
+        desc[:depth_stencil] = ds_ptr
+      else
+        desc[:depth_stencil] = nil
+      end
+
+      if fragment
+        frag_ptr = setup_fragment_state(fragment)
+        desc[:fragment] = frag_ptr
+      else
+        desc[:fragment] = nil
+      end
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreateRenderPipeline(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create render pipeline"
+        raise PipelineError, msg
+      end
+    end
+
+    def get_bind_group_layout(index)
+      handle = Native.wgpuRenderPipelineGetBindGroupLayout(@handle, index)
+      raise PipelineError, "Failed to get bind group layout at index #{index}" if handle.null?
+      BindGroupLayout.from_handle(handle)
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuRenderPipelineRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    private
+
+    def setup_label(desc, label)
+      if label
+        ptr = FFI::MemoryPointer.from_string(label)
+        @pointers << ptr
+        desc[:label][:data] = ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+    end
+
+    def setup_vertex_state(vertex_state, vertex)
+      vertex_state[:next_in_chain] = nil
+      vertex_state[:module] = vertex[:module].handle
+
+      entry_point = vertex[:entry_point] || "main"
+      entry_ptr = FFI::MemoryPointer.from_string(entry_point)
+      @pointers << entry_ptr
+      vertex_state[:entry_point][:data] = entry_ptr
+      vertex_state[:entry_point][:length] = entry_point.bytesize
+
+      vertex_state[:constant_count] = 0
+      vertex_state[:constants] = nil
+
+      buffers = vertex[:buffers] || []
+      if buffers.empty?
+        vertex_state[:buffer_count] = 0
+        vertex_state[:buffers] = nil
+      else
+        buffer_layouts = setup_vertex_buffer_layouts(buffers)
+        vertex_state[:buffer_count] = buffers.size
+        vertex_state[:buffers] = buffer_layouts
+      end
+    end
+
+    def setup_vertex_buffer_layouts(buffers)
+      layouts_ptr = FFI::MemoryPointer.new(Native::VertexBufferLayout, buffers.size)
+      @pointers << layouts_ptr
+
+      buffers.each_with_index do |buf, i|
+        layout = Native::VertexBufferLayout.new(layouts_ptr + i * Native::VertexBufferLayout.size)
+        layout[:array_stride] = buf[:array_stride]
+        layout[:step_mode] = buf[:step_mode] || :vertex
+
+        attrs = buf[:attributes] || []
+        if attrs.empty?
+          layout[:attribute_count] = 0
+          layout[:attributes] = nil
+        else
+          attrs_ptr = FFI::MemoryPointer.new(Native::VertexAttribute, attrs.size)
+          @pointers << attrs_ptr
+          attrs.each_with_index do |attr, j|
+            a = Native::VertexAttribute.new(attrs_ptr + j * Native::VertexAttribute.size)
+            a[:format] = attr[:format]
+            a[:offset] = attr[:offset]
+            a[:shader_location] = attr[:shader_location]
+          end
+          layout[:attribute_count] = attrs.size
+          layout[:attributes] = attrs_ptr
+        end
+      end
+
+      layouts_ptr
+    end
+
+    def setup_primitive_state(primitive_state, primitive)
+      primitive_state[:next_in_chain] = nil
+      primitive_state[:topology] = primitive[:topology] || :triangle_list
+      primitive_state[:strip_index_format] = primitive[:strip_index_format] || :undefined
+      primitive_state[:front_face] = primitive[:front_face] || :ccw
+      primitive_state[:cull_mode] = primitive[:cull_mode] || :none
+      primitive_state[:unclipped_depth] = primitive[:unclipped_depth] ? 1 : 0
+    end
+
+    def setup_multisample_state(multisample_state, multisample)
+      multisample_state[:next_in_chain] = nil
+      multisample_state[:count] = multisample[:count] || 1
+      multisample_state[:mask] = multisample[:mask] || 0xFFFFFFFF
+      multisample_state[:alpha_to_coverage_enabled] = multisample[:alpha_to_coverage_enabled] ? 1 : 0
+    end
+
+    def setup_depth_stencil_state(depth_stencil)
+      ds = Native::DepthStencilState.new
+      @pointers << ds
+      ds[:next_in_chain] = nil
+      ds[:format] = depth_stencil[:format]
+      ds[:depth_write_enabled] = depth_stencil[:depth_write_enabled] ? 1 : 0
+      ds[:depth_compare] = depth_stencil[:depth_compare] || :always
+
+      setup_stencil_face(ds[:stencil_front], depth_stencil[:stencil_front] || {})
+      setup_stencil_face(ds[:stencil_back], depth_stencil[:stencil_back] || {})
+
+      ds[:stencil_read_mask] = depth_stencil[:stencil_read_mask] || 0xFFFFFFFF
+      ds[:stencil_write_mask] = depth_stencil[:stencil_write_mask] || 0xFFFFFFFF
+      ds[:depth_bias] = depth_stencil[:depth_bias] || 0
+      ds[:depth_bias_slope_scale] = depth_stencil[:depth_bias_slope_scale] || 0.0
+      ds[:depth_bias_clamp] = depth_stencil[:depth_bias_clamp] || 0.0
+
+      ds.to_ptr
+    end
+
+    def setup_stencil_face(face, config)
+      face[:compare] = config[:compare] || :always
+      face[:fail_op] = config[:fail_op] || :keep
+      face[:depth_fail_op] = config[:depth_fail_op] || :keep
+      face[:pass_op] = config[:pass_op] || :keep
+    end
+
+    def setup_fragment_state(fragment)
+      frag = Native::FragmentState.new
+      @pointers << frag
+      frag[:next_in_chain] = nil
+      frag[:module] = fragment[:module].handle
+
+      entry_point = fragment[:entry_point] || "main"
+      entry_ptr = FFI::MemoryPointer.from_string(entry_point)
+      @pointers << entry_ptr
+      frag[:entry_point][:data] = entry_ptr
+      frag[:entry_point][:length] = entry_point.bytesize
+
+      frag[:constant_count] = 0
+      frag[:constants] = nil
+
+      targets = fragment[:targets] || []
+      if targets.empty?
+        frag[:target_count] = 0
+        frag[:targets] = nil
+      else
+        targets_ptr = setup_color_targets(targets)
+        frag[:target_count] = targets.size
+        frag[:targets] = targets_ptr
+      end
+
+      frag.to_ptr
+    end
+
+    def setup_color_targets(targets)
+      targets_ptr = FFI::MemoryPointer.new(Native::ColorTargetState, targets.size)
+      @pointers << targets_ptr
+
+      targets.each_with_index do |target, i|
+        ct = Native::ColorTargetState.new(targets_ptr + i * Native::ColorTargetState.size)
+        ct[:next_in_chain] = nil
+        ct[:format] = target[:format]
+        ct[:write_mask] = normalize_write_mask(target[:write_mask])
+
+        if target[:blend]
+          blend_ptr = setup_blend_state(target[:blend])
+          ct[:blend] = blend_ptr
+        else
+          ct[:blend] = nil
+        end
+      end
+
+      targets_ptr
+    end
+
+    def setup_blend_state(blend)
+      bs = Native::BlendState.new
+      @pointers << bs
+
+      color = blend[:color] || {}
+      bs[:color][:operation] = color[:operation] || :add
+      bs[:color][:src_factor] = color[:src_factor] || :one
+      bs[:color][:dst_factor] = color[:dst_factor] || :zero
+
+      alpha = blend[:alpha] || {}
+      bs[:alpha][:operation] = alpha[:operation] || :add
+      bs[:alpha][:src_factor] = alpha[:src_factor] || :one
+      bs[:alpha][:dst_factor] = alpha[:dst_factor] || :zero
+
+      bs.to_ptr
+    end
+
+    def normalize_write_mask(mask)
+      case mask
+      when nil
+        Native::ColorWriteMask[:all]
+      when Integer
+        mask
+      when Symbol
+        Native::ColorWriteMask[mask]
+      when Array
+        mask.reduce(0) { |acc, m| acc | Native::ColorWriteMask[m] }
+      else
+        raise ArgumentError, "Invalid write_mask: #{mask}"
+      end
+    end
+  end
+end

data/lib/wgpu/pipeline/shader_module.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module WGPU
+  class ShaderModule
+    attr_reader :handle
+
+    def initialize(device, label: nil, code:)
+      @device = device
+      @code_ptr = FFI::MemoryPointer.from_string(code)
+
+      wgsl_desc = Native::ShaderSourceWGSL.new
+      wgsl_desc[:chain][:next] = nil
+      wgsl_desc[:chain][:s_type] = :shader_source_wgsl
+      wgsl_desc[:code][:data] = @code_ptr
+      wgsl_desc[:code][:length] = code.bytesize
+
+      desc = Native::ShaderModuleDescriptor.new
+      desc[:next_in_chain] = wgsl_desc.to_ptr
+      if label
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreateShaderModule(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create shader module"
+        raise ShaderError, msg
+      end
+    end
+
+    def get_compilation_info
+      result_holder = { done: false, status: nil, messages: [] }
+
+      callback = FFI::Function.new(
+        :void, [:uint32, :pointer, :pointer, :pointer]
+      ) do |status, compilation_info_ptr, _userdata1, _userdata2|
+        result_holder[:done] = true
+        result_holder[:status] = Native::CompilationInfoRequestStatus[status]
+
+        unless compilation_info_ptr.null?
+          info = Native::CompilationInfo.new(compilation_info_ptr)
+          count = info[:message_count]
+          if count > 0 && !info[:messages].null?
+            count.times do |i|
+              msg_ptr = info[:messages] + (i * Native::CompilationMessage.size)
+              msg = Native::CompilationMessage.new(msg_ptr)
+              message_text = if msg[:message][:data] && !msg[:message][:data].null? && msg[:message][:length] > 0
+                               msg[:message][:data].read_string(msg[:message][:length])
+                             else
+                               ""
+                             end
+              result_holder[:messages] << {
+                type: msg[:type],
+                message: message_text,
+                line_num: msg[:line_num],
+                line_pos: msg[:line_pos],
+                offset: msg[:offset],
+                length: msg[:length]
+              }
+            end
+          end
+        end
+      end
+
+      callback_info = Native::CompilationInfoCallbackInfo.new
+      callback_info[:next_in_chain] = nil
+      callback_info[:mode] = 1
+      callback_info[:callback] = callback
+      callback_info[:userdata1] = nil
+      callback_info[:userdata2] = nil
+
+      Native.wgpuShaderModuleGetCompilationInfo(@handle, callback_info)
+
+      until result_holder[:done]
+        Native.wgpuDevicePoll(@device.handle, 0, nil)
+        sleep(0.001)
+      end
+
+      {
+        status: result_holder[:status],
+        messages: result_holder[:messages]
+      }
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuShaderModuleRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end