wgpu 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 512271e2d60995dd34229880d73287b135c827e69d99b7a757de1a145c4f20e3
-  data.tar.gz: d8ea4fe71b901767d8a53dce17dc58841de03cfb3fe933688eba07b871d64337
+  metadata.gz: bd711bce02ed7be442c0f636460bf55f23df6e9b26cb7a6f07ed1b48b99ca78b
+  data.tar.gz: f6ffe9530b72876da7b91805ab22b9a20dd065857bfc7fe99c66a79823fb4c75
 SHA512:
-  metadata.gz: 99320911c5862fa7efe153f225bd295ff47bd471a2dfb295482cca10f66e1f728e1dfe72d0ec7925a0643f7c74b641e3aa1fc31d4575b470781635f92a3645bc
-  data.tar.gz: 74888fd58146595b8f6cf73f2ce1c426b60e05be15416c4ba84cc1b914bd0d9ad2ea51b4f7d5c94d469b9bb4f243f6119f18bbdb1458c6605b75b469ea9062de
+  metadata.gz: 3430e9a25cdc932eb8441903b9f5f5aa83ebdafd34d56311ac8f794240a983b9adb6745fef484293dc968fb76b7e1f5da7813faa5a63b46b46126bb817e1b2eb
+  data.tar.gz: 75b6031fc4e7654541e6e8596434f8c1e3c4b24d89a16d5b946a29a40ba8da0b6082e395d8ac0a47928e7bc56b2e1e473a350051d78b9a9e6edc4945d293deed

data/lib/wgpu/core/adapter.rb

@@ -2,13 +2,12 @@
 
 module WGPU
   class Adapter
-    attr_reader :handle
+    attr_reader :handle, :instance
 
-    CALLBACK_MODE_WAIT_ANY_ONLY = 1
-
-    def self.from_handle(handle)
+    def self.from_handle(handle, instance: nil)
       adapter = allocate
       adapter.instance_variable_set(:@handle, handle)
+      adapter.instance_variable_set(:@instance, instance)
       adapter
     end
 
@@ -17,13 +16,14 @@ module WGPU
       status_holder = { value: nil, message: nil }
 
       callback = FFI::Function.new(
-        :void, [:uint32, :pointer, Native::StringView.by_value, :pointer]
-      ) do |status, adapter, message, _userdata|
+        :void, [:uint32, :pointer, Native::StringView.by_value, :pointer, :pointer]
+      ) do |status, adapter, message, _userdata1, _userdata2|
         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)
+        status_holder[:done] = true
       end
 
       options = Native::RequestAdapterOptions.new
@@ -36,11 +36,14 @@ module WGPU
 
       callback_info = Native::RequestAdapterCallbackInfo.new
       callback_info[:next_in_chain] = nil
-      callback_info[:mode] = CALLBACK_MODE_WAIT_ANY_ONLY
+      callback_info[:mode] = AsyncWaiter.callback_mode(instance: instance)
       callback_info[:callback] = callback
-      callback_info[:userdata] = nil
+      callback_info[:userdata1] = nil
+      callback_info[:userdata2] = nil
 
-      Native.wgpuInstanceRequestAdapter(instance.handle, options, callback_info)
+      status_holder[:done] = false
+      future = Native.wgpuInstanceRequestAdapter(instance.handle, options, callback_info)
+      AsyncWaiter.wait(status_holder: status_holder, instance: instance, future: future)
 
       handle = adapter_ptr.read_pointer
       if handle.null? || status_holder[:value] != :success
@@ -48,11 +51,12 @@ module WGPU
         raise AdapterError, "Failed to request adapter: #{msg}"
       end
 
-      new(handle)
+      new(handle, instance: instance)
     end
 
-    def initialize(handle)
+    def initialize(handle, instance: nil)
       @handle = handle
+      @instance = instance
     end
 
     def request_device(label: nil, required_features: [], required_limits: nil)

data/lib/wgpu/core/async_waiter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module WGPU
+  module AsyncWaiter
+    POLL_INTERVAL_SECONDS = 0.001
+    CALLBACK_MODE_FALLBACK = {
+      allow_process_events: 2,
+      allow_spontaneous: 3
+    }.freeze
+
+    module_function
+
+    def callback_mode(instance:)
+      if instance
+        callback_mode_value(:allow_process_events)
+      else
+        callback_mode_value(:allow_spontaneous)
+      end
+    end
+
+    def wait(status_holder:, instance: nil, device: nil, future: nil)
+      wait_info = build_wait_info(future) if instance && Native.future_api?
+
+      until status_holder[:done]
+        if instance && wait_info
+          wait_with_wait_any(instance, wait_info)
+        elsif instance
+          instance.process_events
+        elsif device && Native.device_poll_available?
+          Native.wgpuDevicePoll(device.handle, 0, nil)
+        end
+        sleep(POLL_INTERVAL_SECONDS) unless status_holder[:done]
+      end
+    end
+
+    def callback_mode_value(name)
+      Native::CallbackMode[name] || CALLBACK_MODE_FALLBACK.fetch(name)
+    end
+    private_class_method :callback_mode_value
+
+    def build_wait_info(future)
+      return nil unless future.respond_to?(:[])
+
+      id = future[:id].to_i
+      return nil if id.zero?
+
+      wait_info = Native::FutureWaitInfo.new
+      wait_info[:future] = future
+      wait_info[:completed] = 0
+      wait_info
+    rescue StandardError
+      nil
+    end
+    private_class_method :build_wait_info
+
+    def wait_with_wait_any(instance, wait_info)
+      status = Native.wgpuInstanceWaitAny(instance.handle, 1, wait_info.to_ptr, 0)
+      return if [:success, :timed_out].include?(status)
+
+      raise Error, "wgpuInstanceWaitAny failed: #{status.inspect}"
+    end
+    private_class_method :wait_with_wait_any
+  end
+end

data/lib/wgpu/core/device.rb

@@ -4,21 +4,21 @@ module WGPU
   class Device
     attr_reader :handle, :queue, :adapter
 
-    CALLBACK_MODE_WAIT_ANY_ONLY = 1
     LIMIT_FIELDS = Native::Limits.members.freeze
 
     def self.request(adapter, label: nil, required_features: [], required_limits: nil)
       device_ptr = FFI::MemoryPointer.new(:pointer)
-      status_holder = { value: nil, message: nil }
+      status_holder = { done: false, value: nil, message: nil }
 
       callback = FFI::Function.new(
-        :void, [:uint32, :pointer, Native::StringView.by_value, :pointer]
-      ) do |status, device, message, _userdata|
+        :void, [:uint32, :pointer, Native::StringView.by_value, :pointer, :pointer]
+      ) do |status, device, message, _userdata1, _userdata2|
         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)
+        status_holder[:done] = true
       end
 
       queue_desc = Native::QueueDescriptor.new
@@ -30,12 +30,14 @@ module WGPU
       device_lost_info[:next_in_chain] = nil
       device_lost_info[:mode] = 0
       device_lost_info[:callback] = nil
-      device_lost_info[:userdata] = nil
+      device_lost_info[:userdata1] = nil
+      device_lost_info[:userdata2] = nil
 
       error_info = Native::UncapturedErrorCallbackInfo.new
       error_info[:next_in_chain] = nil
       error_info[:callback] = nil
-      error_info[:userdata] = nil
+      error_info[:userdata1] = nil
+      error_info[:userdata2] = nil
 
       desc = Native::DeviceDescriptor.new
       desc[:next_in_chain] = nil
@@ -67,11 +69,13 @@ module WGPU
 
       callback_info = Native::RequestDeviceCallbackInfo.new
       callback_info[:next_in_chain] = nil
-      callback_info[:mode] = CALLBACK_MODE_WAIT_ANY_ONLY
+      callback_info[:mode] = AsyncWaiter.callback_mode(instance: adapter.instance)
       callback_info[:callback] = callback
-      callback_info[:userdata] = nil
+      callback_info[:userdata1] = nil
+      callback_info[:userdata2] = nil
 
-      Native.wgpuAdapterRequestDevice(adapter.handle, desc, callback_info)
+      future = Native.wgpuAdapterRequestDevice(adapter.handle, desc, callback_info)
+      AsyncWaiter.wait(status_holder: status_holder, instance: adapter.instance, future: future)
 
       handle = device_ptr.read_pointer
       if handle.null? || status_holder[:value] != :success
@@ -235,7 +239,12 @@ module WGPU
     end
 
     def poll(wait: false)
-      Native.wgpuDevicePoll(@handle, wait ? 1 : 0, nil)
+      if Native.device_poll_available?
+        Native.wgpuDevicePoll(@handle, wait ? 1 : 0, nil)
+      else
+        @adapter&.instance&.process_events
+        0
+      end
     end
 
     def push_error_scope(filter = :validation)
@@ -243,11 +252,13 @@ module WGPU
     end
 
     def pop_error_scope
-      error_holder = { type: nil, message: nil }
+      error_holder = { done: false, status: nil, type: nil, message: nil }
 
       callback = FFI::Function.new(
         :void, [:uint32, :uint32, Native::StringView.by_value, :pointer, :pointer]
-      ) do |_status, error_type, message, _userdata1, _userdata2|
+      ) do |status, error_type, message, _userdata1, _userdata2|
+        error_holder[:done] = true
+        error_holder[:status] = Native::PopErrorScopeStatus[status]
         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])
@@ -256,12 +267,13 @@ module WGPU
 
       callback_info = Native::PopErrorScopeCallbackInfo.new
       callback_info[:next_in_chain] = nil
-      callback_info[:mode] = 1
+      callback_info[:mode] = AsyncWaiter.callback_mode(instance: @adapter&.instance)
       callback_info[:callback] = callback
       callback_info[:userdata1] = nil
       callback_info[:userdata2] = nil
 
-      Native.wgpuDevicePopErrorScope(@handle, callback_info)
+      future = Native.wgpuDevicePopErrorScope(@handle, callback_info)
+      AsyncWaiter.wait(status_holder: error_holder, instance: @adapter&.instance, device: self, future: future)
 
       error_holder
     end

data/lib/wgpu/core/instance.rb

@@ -53,7 +53,7 @@ module WGPU
       Native.wgpuInstanceEnumerateAdapters(@handle, options, adapters_ptr)
 
       adapters_ptr.read_array_of_pointer(count).map do |ptr|
-        Adapter.from_handle(ptr)
+        Adapter.from_handle(ptr, instance: self)
       end
     end
 

data/lib/wgpu/core/queue.rb

@@ -133,6 +133,7 @@ module WGPU
 
     def on_submitted_work_done(device: nil)
       device ||= @device
+      instance = device&.adapter&.instance
       status_holder = { done: false, status: nil }
 
       callback = FFI::Function.new(
@@ -144,21 +145,13 @@ module WGPU
 
       callback_info = Native::QueueWorkDoneCallbackInfo.new
       callback_info[:next_in_chain] = nil
-      callback_info[:mode] = 1
+      callback_info[:mode] = AsyncWaiter.callback_mode(instance: instance)
       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
+      future = Native.wgpuQueueOnSubmittedWorkDone(@handle, callback_info)
+      AsyncWaiter.wait(status_holder: status_holder, instance: instance, device: device, future: future)
 
       status_holder[:status]
     end

data/lib/wgpu/native/callbacks.rb

@@ -3,19 +3,19 @@
 module WGPU
   module Native
     callback :request_adapter_callback,
-             [RequestAdapterStatus, :pointer, StringView.by_value, :pointer], :void
+             [RequestAdapterStatus, :pointer, StringView.by_value, :pointer, :pointer], :void
 
     callback :request_device_callback,
-             [RequestDeviceStatus, :pointer, StringView.by_value, :pointer], :void
+             [RequestDeviceStatus, :pointer, StringView.by_value, :pointer, :pointer], :void
 
     callback :buffer_map_callback,
-             [MapAsyncStatus, :pointer], :void
+             [MapAsyncStatus, StringView.by_value, :pointer, :pointer], :void
 
-    callback :error_callback,
-             [:uint32, StringView.by_value, :pointer], :void
+    callback :uncaptured_error_callback,
+             [:pointer, ErrorType, StringView.by_value, :pointer, :pointer], :void
 
     callback :device_lost_callback,
-             [:pointer, :uint32, StringView.by_value, :pointer], :void
+             [:pointer, :uint32, StringView.by_value, :pointer, :pointer], :void
 
     callback :pop_error_scope_callback,
              [PopErrorScopeStatus, ErrorType, StringView.by_value, :pointer, :pointer], :void

data/lib/wgpu/native/capabilities.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module WGPU
+  module Native
+    class << self
+      def future_api?
+        respond_to?(:wgpuInstanceWaitAny)
+      end
+
+      def device_poll_available?
+        respond_to?(:wgpuDevicePoll)
+      end
+    end
+  end
+end

data/lib/wgpu/native/enums.rb

@@ -50,13 +50,15 @@ module WGPU
       :success, 0x00000001,
       :instance_dropped, 0x00000002,
       :unavailable, 0x00000003,
-      :error, 0x00000004
+      :error, 0x00000004,
+      :unknown, 0x00000005
     )
 
     RequestDeviceStatus = enum(
       :success, 0x00000001,
       :instance_dropped, 0x00000002,
-      :error, 0x00000003
+      :error, 0x00000003,
+      :unknown, 0x00000004
     )
 
     BufferMapState = enum(
@@ -65,11 +67,18 @@ module WGPU
       :mapped, 0x00000003
     )
 
+    CallbackMode = enum(
+      :wait_any_only, 0x00000001,
+      :allow_process_events, 0x00000002,
+      :allow_spontaneous, 0x00000003
+    )
+
     MapAsyncStatus = enum(
       :success, 0x00000001,
       :instance_dropped, 0x00000002,
       :error, 0x00000003,
-      :aborted, 0x00000004
+      :aborted, 0x00000004,
+      :unknown, 0x00000005
     )
 
     BufferUsage = {
@@ -482,8 +491,16 @@ module WGPU
 
     PopErrorScopeStatus = enum(
       :success, 0x00000001,
-      :callback_cancelled, 0x00000002,
-      :error, 0x00000003
+      :instance_dropped, 0x00000002,
+      :empty_stack, 0x00000003
+    )
+
+    WaitStatus = enum(
+      :success, 0x00000001,
+      :timed_out, 0x00000002,
+      :unsupported_timeout, 0x00000003,
+      :unsupported_count, 0x00000004,
+      :unsupported_mixed_sources, 0x00000005
     )
 
     QueueWorkDoneStatus = enum(

data/lib/wgpu/native/functions.rb

@@ -9,7 +9,7 @@ module WGPU
                     [:pointer], :void
 
     attach_function :wgpuInstanceRequestAdapter,
-                    [:pointer, RequestAdapterOptions.by_ref, RequestAdapterCallbackInfo.by_value], :pointer
+                    [:pointer, RequestAdapterOptions.by_ref, RequestAdapterCallbackInfo.by_value], Future.by_value
 
     attach_function :wgpuInstanceEnumerateAdapters,
                     [:pointer, :pointer, :pointer], :size_t
@@ -17,6 +17,12 @@ module WGPU
     attach_function :wgpuInstanceProcessEvents,
                     [:pointer], :void
 
+    begin
+      attach_function :wgpuInstanceWaitAny,
+                      [:pointer, :size_t, :pointer, :uint64], WaitStatus
+    rescue FFI::NotFoundError
+    end
+
     attach_function :wgpuAdapterRelease,
                     [:pointer], :void
 
@@ -24,7 +30,7 @@ module WGPU
                     [:pointer, AdapterInfo.by_ref], :void
 
     attach_function :wgpuAdapterRequestDevice,
-                    [:pointer, DeviceDescriptor.by_ref, RequestDeviceCallbackInfo.by_value], :pointer
+                    [:pointer, DeviceDescriptor.by_ref, RequestDeviceCallbackInfo.by_value], Future.by_value
 
     attach_function :wgpuAdapterGetFeatures,
                     [:pointer, :pointer], :void
@@ -71,8 +77,11 @@ module WGPU
     attach_function :wgpuDeviceCreateCommandEncoder,
                     [:pointer, CommandEncoderDescriptor.by_ref], :pointer
 
-    attach_function :wgpuDevicePoll,
-                    [:pointer, :uint32, :pointer], :uint32
+    begin
+      attach_function :wgpuDevicePoll,
+                      [:pointer, :uint32, :pointer], :uint32
+    rescue FFI::NotFoundError
+    end
 
     attach_function :wgpuQueueRelease,
                     [:pointer], :void
@@ -81,7 +90,7 @@ module WGPU
                     [:pointer, :size_t, :pointer], :void
 
     attach_function :wgpuQueueOnSubmittedWorkDone,
-                    [:pointer, QueueWorkDoneCallbackInfo.by_value], :pointer
+                    [:pointer, QueueWorkDoneCallbackInfo.by_value], Future.by_value
 
     attach_function :wgpuQueueWriteBuffer,
                     [:pointer, :pointer, :uint64, :pointer, :size_t], :void
@@ -96,7 +105,7 @@ module WGPU
                     [:pointer], :void
 
     attach_function :wgpuBufferMapAsync,
-                    [:pointer, :uint64, :size_t, :size_t, BufferMapCallbackInfo.by_value], :pointer
+                    [:pointer, :uint64, :size_t, :size_t, BufferMapCallbackInfo.by_value], Future.by_value
 
     attach_function :wgpuBufferUnmap,
                     [:pointer], :void
@@ -120,7 +129,7 @@ module WGPU
                     [:pointer], :void
 
     attach_function :wgpuShaderModuleGetCompilationInfo,
-                    [:pointer, CompilationInfoCallbackInfo.by_value], :pointer
+                    [:pointer, CompilationInfoCallbackInfo.by_value], Future.by_value
 
     attach_function :wgpuCommandEncoderRelease,
                     [:pointer], :void
@@ -363,7 +372,7 @@ module WGPU
                     [:pointer, ErrorFilter], :void
 
     attach_function :wgpuDevicePopErrorScope,
-                    [:pointer, PopErrorScopeCallbackInfo.by_value], :pointer
+                    [:pointer, PopErrorScopeCallbackInfo.by_value], Future.by_value
 
     attach_function :wgpuComputePipelineGetBindGroupLayout,
                     [:pointer, :uint32], :pointer

data/lib/wgpu/native/loader.rb

@@ -59,3 +59,4 @@ require_relative "enums"
 require_relative "structs"
 require_relative "callbacks"
 require_relative "functions"
+require_relative "capabilities"

data/lib/wgpu/native/structs.rb

@@ -17,6 +17,15 @@ module WGPU
              :s_type, SType
     end
 
+    class Future < FFI::Struct
+      layout :id, :uint64
+    end
+
+    class FutureWaitInfo < FFI::Struct
+      layout :future, Future.by_value,
+             :completed, :uint32
+    end
+
     class InstanceCapabilities < FFI::Struct
       layout :next_in_chain, :pointer,
              :timed_wait_any_enable, :uint32,
@@ -58,13 +67,15 @@ module WGPU
       layout :next_in_chain, :pointer,
              :mode, :uint32,
              :callback, :pointer,
-             :userdata, :pointer
+             :userdata1, :pointer,
+             :userdata2, :pointer
     end
 
     class UncapturedErrorCallbackInfo < FFI::Struct
       layout :next_in_chain, :pointer,
              :callback, :pointer,
-             :userdata, :pointer
+             :userdata1, :pointer,
+             :userdata2, :pointer
     end
 
     class PopErrorScopeCallbackInfo < FFI::Struct
@@ -355,21 +366,24 @@ module WGPU
       layout :next_in_chain, :pointer,
              :mode, :uint32,
              :callback, :pointer,
-             :userdata, :pointer
+             :userdata1, :pointer,
+             :userdata2, :pointer
     end
 
     class RequestDeviceCallbackInfo < FFI::Struct
       layout :next_in_chain, :pointer,
              :mode, :uint32,
              :callback, :pointer,
-             :userdata, :pointer
+             :userdata1, :pointer,
+             :userdata2, :pointer
     end
 
     class BufferMapCallbackInfo < FFI::Struct
       layout :next_in_chain, :pointer,
              :mode, :uint32,
              :callback, :pointer,
-             :userdata, :pointer
+             :userdata1, :pointer,
+             :userdata2, :pointer
     end
 
     class TextureViewDescriptor < FFI::Struct

data/lib/wgpu/pipeline/shader_module.rb

@@ -35,6 +35,7 @@ module WGPU
 
     def get_compilation_info
       result_holder = { done: false, status: nil, messages: [] }
+      instance = @device.adapter&.instance
 
       callback = FFI::Function.new(
         :void, [:uint32, :pointer, :pointer, :pointer]
@@ -69,17 +70,13 @@ module WGPU
 
       callback_info = Native::CompilationInfoCallbackInfo.new
       callback_info[:next_in_chain] = nil
-      callback_info[:mode] = 1
+      callback_info[:mode] = AsyncWaiter.callback_mode(instance: instance)
       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
+      future = Native.wgpuShaderModuleGetCompilationInfo(@handle, callback_info)
+      AsyncWaiter.wait(status_holder: result_holder, instance: instance, device: @device, future: future)
 
       {
         status: result_holder[:status],

data/lib/wgpu/resources/buffer.rb

@@ -60,17 +60,17 @@ module WGPU
     end
 
     def map_sync(mode, offset: 0, size: nil)
-      status_holder, callback = begin_map_request(mode, offset: offset, size: size)
-      wait_for_map(status_holder)
+      status_holder, callback, future = begin_map_request(mode, offset: offset, size: size)
+      wait_for_map(status_holder, future)
       finalize_map(status_holder)
     ensure
       @map_callbacks.delete(callback) if callback
     end
 
     def map_async(mode, offset: 0, size: nil)
-      status_holder, callback = begin_map_request(mode, offset: offset, size: size)
+      status_holder, callback, future = begin_map_request(mode, offset: offset, size: size)
       AsyncTask.new do
-        wait_for_map(status_holder)
+        wait_for_map(status_holder, future)
         finalize_map(status_holder)
       ensure
         @map_callbacks.delete(callback)
@@ -137,29 +137,35 @@ module WGPU
                   else raise ArgumentError, "Invalid map mode: #{mode}"
                   end
 
-      status_holder = { done: false, status: nil }
-      callback = FFI::Function.new(:void, [:uint32, :pointer]) do |status, _userdata|
+      status_holder = { done: false, status: nil, message: nil }
+      callback = FFI::Function.new(:void, [:uint32, Native::StringView.by_value, :pointer, :pointer]) do |status, message, _userdata1, _userdata2|
         status_holder[:done] = true
         status_holder[:status] = Native::MapAsyncStatus[status]
+        if message[:data] && !message[:data].null? && message[:length] > 0
+          status_holder[:message] = message[:data].read_string(message[:length])
+        end
       end
       @map_callbacks << callback
 
       callback_info = Native::BufferMapCallbackInfo.new
       callback_info[:next_in_chain] = nil
-      callback_info[:mode] = 1
+      callback_info[:mode] = AsyncWaiter.callback_mode(instance: @device.adapter&.instance)
       callback_info[:callback] = callback
-      callback_info[:userdata] = nil
+      callback_info[:userdata1] = nil
+      callback_info[:userdata2] = nil
 
-      Native.wgpuBufferMapAsync(@handle, mode_flag, offset, size, callback_info)
+      future = Native.wgpuBufferMapAsync(@handle, mode_flag, offset, size, callback_info)
 
-      [status_holder, callback]
+      [status_holder, callback, future]
     end
 
-    def wait_for_map(status_holder)
-      until status_holder[:done]
-        Native.wgpuDevicePoll(@device.handle, 0, nil)
-        sleep(0.001)
-      end
+    def wait_for_map(status_holder, future)
+      AsyncWaiter.wait(
+        status_holder: status_holder,
+        instance: @device.adapter&.instance,
+        device: @device,
+        future: future
+      )
     end
 
     def finalize_map(status_holder)
@@ -167,7 +173,9 @@ module WGPU
         @mapped = true
         true
       else
-        raise BufferError, "Failed to map buffer: #{status_holder[:status]}"
+        detail = status_holder[:message]
+        base = "Failed to map buffer: #{status_holder[:status]}"
+        raise BufferError, detail && !detail.empty? ? "#{base} (#{detail})" : base
       end
     end
 

data/lib/wgpu/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WGPU
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/wgpu.rb

@@ -4,6 +4,7 @@ require_relative "wgpu/version"
 require_relative "wgpu/error"
 require_relative "wgpu/native/loader"
 require_relative "wgpu/async_task"
+require_relative "wgpu/core/async_waiter"
 
 require_relative "wgpu/resources/buffer"
 require_relative "wgpu/resources/texture"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wgpu
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -74,6 +74,7 @@ files:
 - lib/wgpu/commands/render_bundle_encoder.rb
 - lib/wgpu/commands/render_pass.rb
 - lib/wgpu/core/adapter.rb
+- lib/wgpu/core/async_waiter.rb
 - lib/wgpu/core/canvas_context.rb
 - lib/wgpu/core/device.rb
 - lib/wgpu/core/instance.rb
@@ -81,6 +82,7 @@ files:
 - lib/wgpu/core/surface.rb
 - lib/wgpu/error.rb
 - lib/wgpu/native/callbacks.rb
+- lib/wgpu/native/capabilities.rb
 - lib/wgpu/native/enums.rb
 - lib/wgpu/native/functions.rb
 - lib/wgpu/native/loader.rb