wgpu 0.1.0

data/lib/wgpu/core/adapter.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Adapter
+    attr_reader :handle
+
+    CALLBACK_MODE_WAIT_ANY_ONLY = 1
+
+    def self.from_handle(handle)
+      adapter = allocate
+      adapter.instance_variable_set(:@handle, handle)
+      adapter
+    end
+
+    def self.request(instance, power_preference: :high_performance, backend: nil)
+      adapter_ptr = FFI::MemoryPointer.new(:pointer)
+      status_holder = { value: nil, message: nil }
+
+      callback = FFI::Function.new(
+        :void, [:uint32, :pointer, Native::StringView.by_value, :pointer]
+      ) do |status, adapter, message, _userdata|
+        status_holder[:value] = Native::RequestAdapterStatus[status]
+        if message[:data] && !message[:data].null? && message[:length] > 0
+          status_holder[:message] = message[:data].read_string(message[:length])
+        end
+        adapter_ptr.write_pointer(adapter)
+      end
+
+      options = Native::RequestAdapterOptions.new
+      options[:next_in_chain] = nil
+      options[:feature_level] = :core
+      options[:power_preference] = power_preference
+      options[:force_fallback_adapter] = 0
+      options[:backend_type] = backend || :undefined
+      options[:compatible_surface] = nil
+
+      callback_info = Native::RequestAdapterCallbackInfo.new
+      callback_info[:next_in_chain] = nil
+      callback_info[:mode] = CALLBACK_MODE_WAIT_ANY_ONLY
+      callback_info[:callback] = callback
+      callback_info[:userdata] = nil
+
+      Native.wgpuInstanceRequestAdapter(instance.handle, options, callback_info)
+
+      handle = adapter_ptr.read_pointer
+      if handle.null? || status_holder[:value] != :success
+        msg = status_holder[:message] || "Unknown error"
+        raise AdapterError, "Failed to request adapter: #{msg}"
+      end
+
+      new(handle)
+    end
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    def request_device(label: nil, required_features: [], required_limits: nil)
+      Device.request(self, label: label, required_features: required_features, required_limits: required_limits)
+    end
+
+    def info
+      info_struct = Native::AdapterInfo.new
+      Native.wgpuAdapterGetInfo(@handle, info_struct)
+
+      result = {
+        vendor: string_view_to_string(info_struct[:vendor]),
+        architecture: string_view_to_string(info_struct[:architecture]),
+        device: string_view_to_string(info_struct[:device]),
+        description: string_view_to_string(info_struct[:description]),
+        backend_type: info_struct[:backend_type],
+        adapter_type: info_struct[:adapter_type],
+        vendor_id: info_struct[:vendor_id],
+        device_id: info_struct[:device_id]
+      }
+
+      Native.wgpuAdapterInfoFreeMembers(info_struct)
+      result
+    end
+
+    def name
+      info[:device]
+    end
+
+    def vendor
+      info[:vendor]
+    end
+
+    def backend_type
+      info[:backend_type]
+    end
+
+    def adapter_type
+      info[:adapter_type]
+    end
+
+    def features
+      supported = Native::SupportedFeatures.new
+      Native.wgpuAdapterGetFeatures(@handle, supported)
+
+      result = []
+      if supported[:feature_count] > 0 && !supported[:features].null?
+        supported[:features].read_array_of_uint32(supported[:feature_count]).each do |f|
+          result << Native::FeatureName[f]
+        end
+      end
+      result
+    end
+
+    def has_feature?(feature)
+      features.include?(feature)
+    end
+
+    def limits
+      supported = Native::SupportedLimits.new
+      supported[:next_in_chain] = nil
+      Native.wgpuAdapterGetLimits(@handle, supported)
+      limits_to_hash(supported[:limits])
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuAdapterRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    private
+
+    def string_view_to_string(string_view)
+      return "" if string_view[:data].null? || string_view[:length] == 0
+      string_view[:data].read_string(string_view[:length])
+    end
+
+    def limits_to_hash(limits)
+      {
+        max_texture_dimension_1d: limits[:max_texture_dimension_1d],
+        max_texture_dimension_2d: limits[:max_texture_dimension_2d],
+        max_texture_dimension_3d: limits[:max_texture_dimension_3d],
+        max_texture_array_layers: limits[:max_texture_array_layers],
+        max_bind_groups: limits[:max_bind_groups],
+        max_bind_groups_plus_vertex_buffers: limits[:max_bind_groups_plus_vertex_buffers],
+        max_bindings_per_bind_group: limits[:max_bindings_per_bind_group],
+        max_dynamic_uniform_buffers_per_pipeline_layout: limits[:max_dynamic_uniform_buffers_per_pipeline_layout],
+        max_dynamic_storage_buffers_per_pipeline_layout: limits[:max_dynamic_storage_buffers_per_pipeline_layout],
+        max_sampled_textures_per_shader_stage: limits[:max_sampled_textures_per_shader_stage],
+        max_samplers_per_shader_stage: limits[:max_samplers_per_shader_stage],
+        max_storage_buffers_per_shader_stage: limits[:max_storage_buffers_per_shader_stage],
+        max_storage_textures_per_shader_stage: limits[:max_storage_textures_per_shader_stage],
+        max_uniform_buffers_per_shader_stage: limits[:max_uniform_buffers_per_shader_stage],
+        max_uniform_buffer_binding_size: limits[:max_uniform_buffer_binding_size],
+        max_storage_buffer_binding_size: limits[:max_storage_buffer_binding_size],
+        min_uniform_buffer_offset_alignment: limits[:min_uniform_buffer_offset_alignment],
+        min_storage_buffer_offset_alignment: limits[:min_storage_buffer_offset_alignment],
+        max_vertex_buffers: limits[:max_vertex_buffers],
+        max_buffer_size: limits[:max_buffer_size],
+        max_vertex_attributes: limits[:max_vertex_attributes],
+        max_vertex_buffer_array_stride: limits[:max_vertex_buffer_array_stride],
+        max_inter_stage_shader_variables: limits[:max_inter_stage_shader_variables],
+        max_color_attachments: limits[:max_color_attachments],
+        max_color_attachment_bytes_per_sample: limits[:max_color_attachment_bytes_per_sample],
+        max_compute_workgroup_storage_size: limits[:max_compute_workgroup_storage_size],
+        max_compute_invocations_per_workgroup: limits[:max_compute_invocations_per_workgroup],
+        max_compute_workgroup_size_x: limits[:max_compute_workgroup_size_x],
+        max_compute_workgroup_size_y: limits[:max_compute_workgroup_size_y],
+        max_compute_workgroup_size_z: limits[:max_compute_workgroup_size_z],
+        max_compute_workgroups_per_dimension: limits[:max_compute_workgroups_per_dimension]
+      }
+    end
+  end
+end

data/lib/wgpu/core/device.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Device
+    attr_reader :handle, :queue
+
+    CALLBACK_MODE_WAIT_ANY_ONLY = 1
+
+    def self.request(adapter, label: nil, required_features: [], required_limits: nil)
+      device_ptr = FFI::MemoryPointer.new(:pointer)
+      status_holder = { value: nil, message: nil }
+
+      callback = FFI::Function.new(
+        :void, [:uint32, :pointer, Native::StringView.by_value, :pointer]
+      ) do |status, device, message, _userdata|
+        status_holder[:value] = Native::RequestDeviceStatus[status]
+        if message[:data] && !message[:data].null? && message[:length] > 0
+          status_holder[:message] = message[:data].read_string(message[:length])
+        end
+        device_ptr.write_pointer(device)
+      end
+
+      queue_desc = Native::QueueDescriptor.new
+      queue_desc[:next_in_chain] = nil
+      queue_desc[:label][:data] = nil
+      queue_desc[:label][:length] = 0
+
+      device_lost_info = Native::DeviceLostCallbackInfo.new
+      device_lost_info[:next_in_chain] = nil
+      device_lost_info[:mode] = 0
+      device_lost_info[:callback] = nil
+      device_lost_info[:userdata] = nil
+
+      error_info = Native::UncapturedErrorCallbackInfo.new
+      error_info[:next_in_chain] = nil
+      error_info[:callback] = nil
+      error_info[:userdata] = nil
+
+      desc = Native::DeviceDescriptor.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[:required_feature_count] = 0
+      desc[:required_features] = nil
+      desc[:required_limits] = nil
+      desc[:default_queue] = queue_desc
+      desc[:device_lost_callback_info] = device_lost_info
+      desc[:uncaptured_error_callback_info] = error_info
+
+      callback_info = Native::RequestDeviceCallbackInfo.new
+      callback_info[:next_in_chain] = nil
+      callback_info[:mode] = CALLBACK_MODE_WAIT_ANY_ONLY
+      callback_info[:callback] = callback
+      callback_info[:userdata] = nil
+
+      Native.wgpuAdapterRequestDevice(adapter.handle, desc, callback_info)
+
+      handle = device_ptr.read_pointer
+      if handle.null? || status_holder[:value] != :success
+        msg = status_holder[:message] || "Unknown error"
+        raise DeviceError, "Failed to request device: #{msg}"
+      end
+
+      new(handle)
+    end
+
+    def initialize(handle)
+      @handle = handle
+      @queue = Queue.new(Native.wgpuDeviceGetQueue(@handle))
+    end
+
+    def create_buffer(label: nil, size:, usage:, mapped_at_creation: false)
+      Buffer.new(self, label: label, size: size, usage: usage, mapped_at_creation: mapped_at_creation)
+    end
+
+    def create_shader_module(label: nil, code:)
+      ShaderModule.new(self, label: label, code: code)
+    end
+
+    def create_command_encoder(label: nil)
+      CommandEncoder.new(self, label: label)
+    end
+
+    def create_bind_group_layout(label: nil, entries:)
+      BindGroupLayout.new(self, label: label, entries: entries)
+    end
+
+    def create_bind_group(label: nil, layout:, entries:)
+      BindGroup.new(self, label: label, layout: layout, entries: entries)
+    end
+
+    def create_pipeline_layout(label: nil, bind_group_layouts:)
+      PipelineLayout.new(self, label: label, bind_group_layouts: bind_group_layouts)
+    end
+
+    def create_compute_pipeline(label: nil, layout:, compute:)
+      ComputePipeline.new(self, label: label, layout: layout, compute: compute)
+    end
+
+    def create_render_pipeline(label: nil, layout:, vertex:, primitive: {}, depth_stencil: nil, multisample: {}, fragment: nil)
+      RenderPipeline.new(self,
+        label: label,
+        layout: layout,
+        vertex: vertex,
+        primitive: primitive,
+        depth_stencil: depth_stencil,
+        multisample: multisample,
+        fragment: fragment
+      )
+    end
+
+    def create_texture(label: nil, size:, format:, usage:, dimension: :d2, mip_level_count: 1, sample_count: 1, view_formats: [])
+      Texture.new(self,
+        label: label,
+        size: size,
+        format: format,
+        usage: usage,
+        dimension: dimension,
+        mip_level_count: mip_level_count,
+        sample_count: sample_count,
+        view_formats: view_formats
+      )
+    end
+
+    def create_sampler(label: nil, address_mode_u: :clamp_to_edge, address_mode_v: :clamp_to_edge, address_mode_w: :clamp_to_edge, mag_filter: :nearest, min_filter: :nearest, mipmap_filter: :nearest, lod_min_clamp: 0.0, lod_max_clamp: 32.0, compare: nil, max_anisotropy: 1)
+      Sampler.new(self,
+        label: label,
+        address_mode_u: address_mode_u,
+        address_mode_v: address_mode_v,
+        address_mode_w: address_mode_w,
+        mag_filter: mag_filter,
+        min_filter: min_filter,
+        mipmap_filter: mipmap_filter,
+        lod_min_clamp: lod_min_clamp,
+        lod_max_clamp: lod_max_clamp,
+        compare: compare,
+        max_anisotropy: max_anisotropy
+      )
+    end
+
+    def create_buffer_with_data(label: nil, data:, usage:)
+      data_ptr, byte_size = data_to_pointer(data)
+      buffer = create_buffer(
+        label: label,
+        size: byte_size,
+        usage: usage,
+        mapped_at_creation: true
+      )
+      buffer.mapped_range.write_bytes(data_ptr.read_bytes(byte_size))
+      buffer.unmap
+      buffer
+    end
+
+    def create_query_set(label: nil, type:, count:)
+      QuerySet.new(self, label: label, type: type, count: count)
+    end
+
+    def create_render_bundle_encoder(color_formats:, depth_stencil_format: nil, sample_count: 1,
+                                     depth_read_only: false, stencil_read_only: false, label: nil)
+      RenderBundleEncoder.new(self,
+        color_formats: color_formats,
+        depth_stencil_format: depth_stencil_format,
+        sample_count: sample_count,
+        depth_read_only: depth_read_only,
+        stencil_read_only: stencil_read_only,
+        label: label
+      )
+    end
+
+    def features
+      supported = Native::SupportedFeatures.new
+      Native.wgpuDeviceGetFeatures(@handle, supported)
+
+      result = []
+      if supported[:feature_count] > 0 && !supported[:features].null?
+        supported[:features].read_array_of_uint32(supported[:feature_count]).each do |f|
+          result << Native::FeatureName[f]
+        end
+      end
+      result
+    end
+
+    def has_feature?(feature)
+      features.include?(feature)
+    end
+
+    def limits
+      supported = Native::SupportedLimits.new
+      supported[:next_in_chain] = nil
+      Native.wgpuDeviceGetLimits(@handle, supported)
+      limits_to_hash(supported[:limits])
+    end
+
+    def poll(wait: false)
+      Native.wgpuDevicePoll(@handle, wait ? 1 : 0, nil)
+    end
+
+    def push_error_scope(filter = :validation)
+      Native.wgpuDevicePushErrorScope(@handle, filter)
+    end
+
+    def pop_error_scope
+      error_holder = { type: nil, message: nil }
+
+      callback = FFI::Function.new(
+        :void, [:uint32, :uint32, Native::StringView.by_value, :pointer, :pointer]
+      ) do |_status, error_type, message, _userdata1, _userdata2|
+        error_holder[:type] = Native::ErrorType[error_type]
+        if message[:data] && !message[:data].null? && message[:length] > 0
+          error_holder[:message] = message[:data].read_string(message[:length])
+        end
+      end
+
+      callback_info = Native::PopErrorScopeCallbackInfo.new
+      callback_info[:next_in_chain] = nil
+      callback_info[:mode] = 1
+      callback_info[:callback] = callback
+      callback_info[:userdata1] = nil
+      callback_info[:userdata2] = nil
+
+      Native.wgpuDevicePopErrorScope(@handle, callback_info)
+
+      error_holder
+    end
+
+    def with_error_scope(filter = :validation)
+      push_error_scope(filter)
+      result = yield
+      error = pop_error_scope
+      if error[:type] && error[:type] != :no_error
+        raise Error, "GPU error (#{error[:type]}): #{error[:message]}"
+      end
+      result
+    end
+
+    def release
+      @queue&.release
+      return if @handle.null?
+      Native.wgpuDeviceRelease(@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
+
+    def limits_to_hash(limits)
+      {
+        max_texture_dimension_1d: limits[:max_texture_dimension_1d],
+        max_texture_dimension_2d: limits[:max_texture_dimension_2d],
+        max_texture_dimension_3d: limits[:max_texture_dimension_3d],
+        max_texture_array_layers: limits[:max_texture_array_layers],
+        max_bind_groups: limits[:max_bind_groups],
+        max_bind_groups_plus_vertex_buffers: limits[:max_bind_groups_plus_vertex_buffers],
+        max_bindings_per_bind_group: limits[:max_bindings_per_bind_group],
+        max_dynamic_uniform_buffers_per_pipeline_layout: limits[:max_dynamic_uniform_buffers_per_pipeline_layout],
+        max_dynamic_storage_buffers_per_pipeline_layout: limits[:max_dynamic_storage_buffers_per_pipeline_layout],
+        max_sampled_textures_per_shader_stage: limits[:max_sampled_textures_per_shader_stage],
+        max_samplers_per_shader_stage: limits[:max_samplers_per_shader_stage],
+        max_storage_buffers_per_shader_stage: limits[:max_storage_buffers_per_shader_stage],
+        max_storage_textures_per_shader_stage: limits[:max_storage_textures_per_shader_stage],
+        max_uniform_buffers_per_shader_stage: limits[:max_uniform_buffers_per_shader_stage],
+        max_uniform_buffer_binding_size: limits[:max_uniform_buffer_binding_size],
+        max_storage_buffer_binding_size: limits[:max_storage_buffer_binding_size],
+        min_uniform_buffer_offset_alignment: limits[:min_uniform_buffer_offset_alignment],
+        min_storage_buffer_offset_alignment: limits[:min_storage_buffer_offset_alignment],
+        max_vertex_buffers: limits[:max_vertex_buffers],
+        max_buffer_size: limits[:max_buffer_size],
+        max_vertex_attributes: limits[:max_vertex_attributes],
+        max_vertex_buffer_array_stride: limits[:max_vertex_buffer_array_stride],
+        max_inter_stage_shader_variables: limits[:max_inter_stage_shader_variables],
+        max_color_attachments: limits[:max_color_attachments],
+        max_color_attachment_bytes_per_sample: limits[:max_color_attachment_bytes_per_sample],
+        max_compute_workgroup_storage_size: limits[:max_compute_workgroup_storage_size],
+        max_compute_invocations_per_workgroup: limits[:max_compute_invocations_per_workgroup],
+        max_compute_workgroup_size_x: limits[:max_compute_workgroup_size_x],
+        max_compute_workgroup_size_y: limits[:max_compute_workgroup_size_y],
+        max_compute_workgroup_size_z: limits[:max_compute_workgroup_size_z],
+        max_compute_workgroups_per_dimension: limits[:max_compute_workgroups_per_dimension]
+      }
+    end
+  end
+end

data/lib/wgpu/core/instance.rb

@@ -0,0 +1,52 @@
+# 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)
+      Adapter.request(self, power_preference: power_preference, backend: backend)
+    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 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,173 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Queue
+    attr_reader :handle
+
+    def initialize(handle)
+      @handle = handle
+    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, offset, data)
+      data_ptr, byte_size = data_to_pointer(data)
+      Native.wgpuQueueWriteBuffer(@handle, buffer.handle, offset, data_ptr, byte_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_async(: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_async(:read)
+      data = staging.read_mapped_data
+      staging.unmap
+      staging.release
+
+      data
+    end
+
+    def on_submitted_work_done(device: nil)
+      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
+      end
+
+      status_holder[:status]
+    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