wgpu 1.0.0

data/lib/wgpu/core/instance.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Instance
+    attr_reader :handle
+
+    def initialize
+      desc = Native::InstanceDescriptor.new
+      desc[:next_in_chain] = nil
+      desc[:features][:next_in_chain] = nil
+      desc[:features][:timed_wait_any_enable] = 0
+      desc[:features][:timed_wait_any_max_count] = 0
+
+      @handle = Native.wgpuCreateInstance(desc)
+      raise InitializationError, "Failed to create WebGPU instance" if @handle.null?
+    end
+
+    def request_adapter(power_preference: :high_performance, backend: nil, feature_level: :core, force_fallback_adapter: false, compatible_surface: nil)
+      Adapter.request(
+        self,
+        power_preference: power_preference,
+        backend: backend,
+        feature_level: feature_level,
+        force_fallback_adapter: force_fallback_adapter,
+        compatible_surface: compatible_surface
+      )
+    end
+
+    def request_adapter_async(power_preference: :high_performance, backend: nil, feature_level: :core, force_fallback_adapter: false, compatible_surface: nil)
+      AsyncTask.new do
+        request_adapter(
+          power_preference: power_preference,
+          backend: backend,
+          feature_level: feature_level,
+          force_fallback_adapter: force_fallback_adapter,
+          compatible_surface: compatible_surface
+        )
+      end
+    end
+
+    def enumerate_adapters(backends: nil)
+      options = nil
+      if backends
+        options = Native::InstanceEnumerateAdapterOptions.new
+        options[:next_in_chain] = nil
+        options[:backends] = backends
+      end
+
+      count = Native.wgpuInstanceEnumerateAdapters(@handle, options, nil)
+      return [] if count == 0
+
+      adapters_ptr = FFI::MemoryPointer.new(:pointer, count)
+      Native.wgpuInstanceEnumerateAdapters(@handle, options, adapters_ptr)
+
+      adapters_ptr.read_array_of_pointer(count).map do |ptr|
+        Adapter.from_handle(ptr)
+      end
+    end
+
+    def enumerate_adapters_async(backends: nil)
+      AsyncTask.new do
+        enumerate_adapters(backends: backends)
+      end
+    end
+
+    def get_canvas_context(present_info)
+      CanvasContext.new(self, present_info)
+    end
+
+    def process_events
+      Native.wgpuInstanceProcessEvents(@handle)
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuInstanceRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+  end
+end

data/lib/wgpu/core/queue.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Queue
+    attr_reader :handle
+
+    def initialize(handle, device: nil)
+      @handle = handle
+      @device = device
+    end
+
+    def submit(command_buffers)
+      buffers = Array(command_buffers)
+      return if buffers.empty?
+
+      handles = buffers.map(&:handle)
+      ptr = FFI::MemoryPointer.new(:pointer, handles.size)
+      ptr.write_array_of_pointer(handles)
+
+      Native.wgpuQueueSubmit(@handle, handles.size, ptr)
+    end
+
+    def write_buffer(buffer, buffer_offset, data, data_offset: 0, size: nil)
+      data_ptr, byte_size = data_to_pointer(data)
+      data_offset = Integer(data_offset)
+      raise ArgumentError, "data_offset must be non-negative" if data_offset.negative?
+      raise ArgumentError, "data_offset out of range" if data_offset > byte_size
+
+      write_size = size.nil? ? (byte_size - data_offset) : Integer(size)
+      raise ArgumentError, "size must be non-negative" if write_size.negative?
+      raise ArgumentError, "data_offset + size out of range" if data_offset + write_size > byte_size
+
+      Native.wgpuQueueWriteBuffer(
+        @handle,
+        buffer.handle,
+        buffer_offset,
+        data_ptr + data_offset,
+        write_size
+      )
+    end
+
+    def write_texture(destination:, data:, data_layout:, size:)
+      data_ptr, byte_size = data_to_pointer(data)
+
+      dst = Native::ImageCopyTexture.new
+      dst[:texture] = destination[:texture].handle
+      dst[:mip_level] = destination[:mip_level] || 0
+      dst[:origin][:x] = destination.dig(:origin, :x) || 0
+      dst[:origin][:y] = destination.dig(:origin, :y) || 0
+      dst[:origin][:z] = destination.dig(:origin, :z) || 0
+      dst[:aspect] = destination[:aspect] || :all
+
+      extent = Native::Extent3D.new
+      if size.is_a?(Array)
+        extent[:width] = size[0]
+        extent[:height] = size[1] || 1
+        extent[:depth_or_array_layers] = size[2] || 1
+      else
+        extent[:width] = size[:width]
+        extent[:height] = size[:height] || 1
+        extent[:depth_or_array_layers] = size[:depth_or_array_layers] || 1
+      end
+
+      layout = Native::TextureDataLayout.new
+      layout[:offset] = data_layout[:offset] || 0
+      layout[:bytes_per_row] = data_layout[:bytes_per_row]
+      layout[:rows_per_image] = data_layout[:rows_per_image] || extent[:height]
+
+      Native.wgpuQueueWriteTexture(@handle, dst, data_ptr, byte_size, layout, extent)
+    end
+
+    def read_buffer(buffer, offset: 0, size: nil, device:)
+      size ||= buffer.size - offset
+
+      staging = Buffer.new(device,
+        size: size,
+        usage: [:map_read, :copy_dst]
+      )
+
+      encoder = CommandEncoder.new(device)
+      encoder.copy_buffer_to_buffer(
+        source: buffer,
+        source_offset: offset,
+        destination: staging,
+        destination_offset: 0,
+        size: size
+      )
+      command_buffer = encoder.finish
+      submit([command_buffer])
+
+      staging.map_sync(:read)
+      data = staging.read_mapped_data
+      staging.unmap
+      staging.release
+
+      data
+    end
+
+    def read_texture(source:, data_layout:, size:, device:)
+      width = size[:width] || size[0]
+      height = size[:height] || size[1] || 1
+      depth = size[:depth_or_array_layers] || size[2] || 1
+      bytes_per_row = data_layout[:bytes_per_row]
+      rows_per_image = data_layout[:rows_per_image] || height
+      buffer_size = bytes_per_row * rows_per_image * depth
+
+      staging = Buffer.new(device,
+        size: buffer_size,
+        usage: [:map_read, :copy_dst]
+      )
+
+      encoder = CommandEncoder.new(device)
+      encoder.copy_texture_to_buffer(
+        source: source,
+        destination: {
+          buffer: staging,
+          offset: 0,
+          bytes_per_row: bytes_per_row,
+          rows_per_image: rows_per_image
+        },
+        copy_size: size
+      )
+      command_buffer = encoder.finish
+      submit([command_buffer])
+
+      staging.map_sync(:read)
+      data = staging.read_mapped_data
+      staging.unmap
+      staging.release
+
+      data
+    end
+
+    def on_submitted_work_done(device: nil)
+      device ||= @device
+      status_holder = { done: false, status: nil }
+
+      callback = FFI::Function.new(
+        :void, [:uint32, :pointer, :pointer]
+      ) do |status, _userdata1, _userdata2|
+        status_holder[:done] = true
+        status_holder[:status] = Native::QueueWorkDoneStatus[status]
+      end
+
+      callback_info = Native::QueueWorkDoneCallbackInfo.new
+      callback_info[:next_in_chain] = nil
+      callback_info[:mode] = 1
+      callback_info[:callback] = callback
+      callback_info[:userdata1] = nil
+      callback_info[:userdata2] = nil
+
+      Native.wgpuQueueOnSubmittedWorkDone(@handle, callback_info)
+
+      if device
+        until status_holder[:done]
+          Native.wgpuDevicePoll(device.handle, 0, nil)
+          sleep(0.001)
+        end
+      else
+        sleep(0.001) until status_holder[:done]
+      end
+
+      status_holder[:status]
+    end
+
+    def on_submitted_work_done_async(device: nil)
+      AsyncTask.new do
+        on_submitted_work_done(device: device)
+      end
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuQueueRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    private
+
+    def data_to_pointer(data)
+      case data
+      when String
+        ptr = FFI::MemoryPointer.new(:char, data.bytesize)
+        ptr.put_bytes(0, data)
+        [ptr, data.bytesize]
+      when Array
+        ptr = FFI::MemoryPointer.new(:float, data.size)
+        ptr.write_array_of_float(data)
+        [ptr, data.size * 4]
+      when FFI::Pointer
+        [data, data.size]
+      else
+        raise ArgumentError, "Unsupported data type: #{data.class}"
+      end
+    end
+  end
+end

data/lib/wgpu/core/surface.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Surface
+    attr_reader :handle
+
+    def self.from_metal_layer(instance, layer)
+      source = Native::SurfaceSourceMetalLayer.new
+      source[:chain][:next] = nil
+      source[:chain][:s_type] = Native::SType[:surface_source_metal_layer]
+      source[:layer] = layer
+
+      desc = Native::SurfaceDescriptor.new
+      desc[:next_in_chain] = source.to_ptr
+      desc[:label][:data] = nil
+      desc[:label][:length] = 0
+
+      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      raise SurfaceError, "Failed to create surface from Metal layer" if handle.null?
+
+      new(handle, instance)
+    end
+
+    def self.from_windows_hwnd(instance, hinstance, hwnd)
+      source = Native::SurfaceSourceWindowsHWND.new
+      source[:chain][:next] = nil
+      source[:chain][:s_type] = Native::SType[:surface_source_windows_hwnd]
+      source[:hinstance] = hinstance
+      source[:hwnd] = hwnd
+
+      desc = Native::SurfaceDescriptor.new
+      desc[:next_in_chain] = source.to_ptr
+      desc[:label][:data] = nil
+      desc[:label][:length] = 0
+
+      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      raise SurfaceError, "Failed to create surface from Windows HWND" if handle.null?
+
+      new(handle, instance)
+    end
+
+    def self.from_xlib_window(instance, display, window)
+      source = Native::SurfaceSourceXlibWindow.new
+      source[:chain][:next] = nil
+      source[:chain][:s_type] = Native::SType[:surface_source_xlib_window]
+      source[:display] = display
+      source[:window] = window
+
+      desc = Native::SurfaceDescriptor.new
+      desc[:next_in_chain] = source.to_ptr
+      desc[:label][:data] = nil
+      desc[:label][:length] = 0
+
+      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      raise SurfaceError, "Failed to create surface from Xlib window" if handle.null?
+
+      new(handle, instance)
+    end
+
+    def self.from_wayland_surface(instance, display, surface)
+      source = Native::SurfaceSourceWaylandSurface.new
+      source[:chain][:next] = nil
+      source[:chain][:s_type] = Native::SType[:surface_source_wayland_surface]
+      source[:display] = display
+      source[:surface] = surface
+
+      desc = Native::SurfaceDescriptor.new
+      desc[:next_in_chain] = source.to_ptr
+      desc[:label][:data] = nil
+      desc[:label][:length] = 0
+
+      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      raise SurfaceError, "Failed to create surface from Wayland surface" if handle.null?
+
+      new(handle, instance)
+    end
+
+    def initialize(handle, instance)
+      @handle = handle
+      @instance = instance
+      @configured = false
+      @config = nil
+    end
+
+    def configure(device:, format:, usage: :render_attachment, width:, height:, present_mode: :fifo, alpha_mode: :auto, view_formats: [])
+      config = Native::SurfaceConfiguration.new
+      config[:next_in_chain] = nil
+      config[:device] = device.handle
+      config[:format] = format
+      config[:usage] = normalize_usage(usage)
+      config[:width] = width
+      config[:height] = height
+      config[:view_format_count] = view_formats.size
+      if view_formats.empty?
+        @view_formats_ptr = nil
+        config[:view_formats] = nil
+      else
+        format_values = view_formats.map do |vf|
+          vf.is_a?(Integer) ? vf : Native::TextureFormat[vf]
+        end
+        @view_formats_ptr = FFI::MemoryPointer.new(:uint32, format_values.size)
+        @view_formats_ptr.write_array_of_uint32(format_values)
+        config[:view_formats] = @view_formats_ptr
+      end
+      config[:alpha_mode] = Native::CompositeAlphaMode[alpha_mode]
+      config[:present_mode] = Native::PresentMode[present_mode]
+
+      Native.wgpuSurfaceConfigure(@handle, config)
+      @configured = true
+      @device = device
+      @config = {
+        device: device,
+        format: format,
+        usage: usage,
+        width: width,
+        height: height,
+        present_mode: present_mode,
+        alpha_mode: alpha_mode,
+        view_formats: view_formats
+      }
+    end
+
+    def unconfigure
+      Native.wgpuSurfaceUnconfigure(@handle)
+      @configured = false
+      @config = nil
+    end
+
+    def current_texture
+      raise SurfaceError, "Surface is not configured" unless @configured
+
+      surface_texture = Native::SurfaceTexture.new
+      Native.wgpuSurfaceGetCurrentTexture(@handle, surface_texture)
+
+      status = Native::SurfaceGetCurrentTextureStatus[surface_texture[:status]]
+      unless status == :success_optimal || status == :success_suboptimal
+        raise SurfaceError, "Failed to get current texture: #{status}"
+      end
+
+      texture_ptr = surface_texture[:texture]
+      if texture_ptr.nil? || texture_ptr.null?
+        raise SurfaceError, "Surface returned null texture"
+      end
+
+      Texture.from_handle(texture_ptr)
+    end
+
+    def get_current_texture
+      current_texture
+    end
+
+    def present
+      Native.wgpuSurfacePresent(@handle)
+    end
+
+    def get_configuration
+      @config
+    end
+
+    def get_preferred_format(adapter)
+      caps = capabilities(adapter)
+      caps[:formats].first || :bgra8_unorm
+    end
+
+    def capabilities(adapter)
+      caps = Native::SurfaceCapabilities.new
+      Native.wgpuSurfaceGetCapabilities(@handle, adapter.handle, caps)
+
+      formats = []
+      if caps[:format_count] > 0 && !caps[:formats].null?
+        formats = caps[:formats].read_array_of_uint32(caps[:format_count]).map do |f|
+          Native::TextureFormat[f]
+        end
+      end
+
+      present_modes = []
+      if caps[:present_mode_count] > 0 && !caps[:present_modes].null?
+        present_modes = caps[:present_modes].read_array_of_uint32(caps[:present_mode_count]).map do |m|
+          Native::PresentMode[m]
+        end
+      end
+
+      alpha_modes = []
+      if caps[:alpha_mode_count] > 0 && !caps[:alpha_modes].null?
+        alpha_modes = caps[:alpha_modes].read_array_of_uint32(caps[:alpha_mode_count]).map do |a|
+          Native::CompositeAlphaMode[a]
+        end
+      end
+
+      {
+        formats: formats,
+        present_modes: present_modes,
+        alpha_modes: alpha_modes,
+        usages: caps[:usages]
+      }
+    ensure
+      Native.wgpuSurfaceCapabilitiesFreeMembers(caps) if caps
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuSurfaceRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    private
+
+    def normalize_usage(usage)
+      case usage
+      when Integer
+        usage
+      when Symbol
+        Native::TextureUsage[usage]
+      when Array
+        usage.reduce(0) { |acc, u| acc | Native::TextureUsage[u] }
+      else
+        raise ArgumentError, "Invalid usage: #{usage}"
+      end
+    end
+  end
+end

data/lib/wgpu/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Error < StandardError; end
+  class InitializationError < Error; end
+  class AdapterError < Error; end
+  class DeviceError < Error; end
+  class BufferError < Error; end
+  class TextureError < Error; end
+  class ResourceError < Error; end
+  class ShaderError < Error; end
+  class PipelineError < Error; end
+  class CommandError < Error; end
+  class SurfaceError < Error; end
+  class RenderBundleError < Error; end
+end

data/lib/wgpu/native/callbacks.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WGPU
+  module Native
+    callback :request_adapter_callback,
+             [RequestAdapterStatus, :pointer, StringView.by_value, :pointer], :void
+
+    callback :request_device_callback,
+             [RequestDeviceStatus, :pointer, StringView.by_value, :pointer], :void
+
+    callback :buffer_map_callback,
+             [MapAsyncStatus, :pointer], :void
+
+    callback :error_callback,
+             [:uint32, StringView.by_value, :pointer], :void
+
+    callback :device_lost_callback,
+             [:pointer, :uint32, StringView.by_value, :pointer], :void
+
+    callback :pop_error_scope_callback,
+             [PopErrorScopeStatus, ErrorType, StringView.by_value, :pointer, :pointer], :void
+
+    callback :queue_work_done_callback,
+             [QueueWorkDoneStatus, :pointer, :pointer], :void
+  end
+end