wgpu 1.0.0 → 1.2.0

data/lib/wgpu/commands/command_encoder.rb

@@ -7,6 +7,7 @@ module WGPU
     def initialize(device, label: nil)
       @device = device
       @finished = false
+      @active_pass = nil
 
       desc = Native::CommandEncoderDescriptor.new
       desc[:next_in_chain] = nil
@@ -24,13 +25,26 @@ module WGPU
     end
 
     def begin_compute_pass(label: nil, timestamp_writes: nil)
-      raise CommandError, "Encoder already finished" if @finished
-      ComputePass.new(self, label: label, timestamp_writes: timestamp_writes)
+      ensure_can_begin_pass!
+      pass = ComputePass.new(self, label: label, timestamp_writes: timestamp_writes)
+      @active_pass = pass
+      return pass unless block_given?
+
+      begin
+        yield pass
+      ensure
+        begin
+          pass.end_pass unless pass.ended?
+        ensure
+          pass.release
+          pass_ended(pass)
+        end
+      end
     end
 
     def begin_render_pass(color_attachments:, depth_stencil_attachment: nil, occlusion_query_set: nil, timestamp_writes: nil, max_draw_count: nil, label: nil)
-      raise CommandError, "Encoder already finished" if @finished
-      RenderPass.new(self,
+      ensure_can_begin_pass!
+      pass = RenderPass.new(self,
         color_attachments: color_attachments,
         depth_stencil_attachment: depth_stencil_attachment,
         occlusion_query_set: occlusion_query_set,
@@ -38,6 +52,19 @@ module WGPU
         max_draw_count: max_draw_count,
         label: label
       )
+      @active_pass = pass
+      return pass unless block_given?
+
+      begin
+        yield pass
+      ensure
+        begin
+          pass.end_pass unless pass.ended?
+        ensure
+          pass.release
+          pass_ended(pass)
+        end
+      end
     end
 
     def copy_buffer_to_buffer(source:, source_offset: 0, destination:, destination_offset: 0, size:)
@@ -70,7 +97,11 @@ module WGPU
       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
+      dst[:aspect] = Native::EnumHelper.coerce(
+        Native::TextureAspect,
+        destination[:aspect] || :all,
+        name: "texture aspect"
+      )
 
       Native.wgpuCommandEncoderCopyBufferToTexture(@handle, src, dst, size)
     end
@@ -89,7 +120,11 @@ module WGPU
       src[:origin][:x] = source.dig(:origin, :x) || 0
       src[:origin][:y] = source.dig(:origin, :y) || 0
       src[:origin][:z] = source.dig(:origin, :z) || 0
-      src[:aspect] = source[:aspect] || :all
+      src[:aspect] = Native::EnumHelper.coerce(
+        Native::TextureAspect,
+        source[:aspect] || :all,
+        name: "texture aspect"
+      )
 
       dst = Native::ImageCopyBuffer.new
       dst[:layout][:offset] = destination[:offset] || 0
@@ -109,7 +144,11 @@ module WGPU
       src[:origin][:x] = source.dig(:origin, :x) || 0
       src[:origin][:y] = source.dig(:origin, :y) || 0
       src[:origin][:z] = source.dig(:origin, :z) || 0
-      src[:aspect] = source[:aspect] || :all
+      src[:aspect] = Native::EnumHelper.coerce(
+        Native::TextureAspect,
+        source[:aspect] || :all,
+        name: "source texture aspect"
+      )
 
       dst = Native::ImageCopyTexture.new
       dst[:texture] = destination[:texture].handle
@@ -117,7 +156,11 @@ module WGPU
       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
+      dst[:aspect] = Native::EnumHelper.coerce(
+        Native::TextureAspect,
+        destination[:aspect] || :all,
+        name: "destination texture aspect"
+      )
 
       size = Native::Extent3D.new
       size[:width] = copy_size[:width] || copy_size[0]
@@ -175,6 +218,9 @@ module WGPU
 
     def finish(label: nil)
       raise CommandError, "Encoder already finished" if @finished
+      if @active_pass && !@active_pass.ended?
+        raise CommandError, "Cannot finish command encoder while a pass is active"
+      end
       @finished = true
 
       desc = nil
@@ -197,5 +243,16 @@ module WGPU
       Native.wgpuCommandEncoderRelease(@handle)
       @handle = FFI::Pointer::NULL
     end
+
+    private
+
+    def ensure_can_begin_pass!
+      raise CommandError, "Encoder already finished" if @finished
+      raise CommandError, "A command pass is already active" if @active_pass && !@active_pass.ended?
+    end
+
+    def pass_ended(pass)
+      @active_pass = nil if @active_pass.equal?(pass)
+    end
   end
 end

data/lib/wgpu/commands/compute_pass.rb

@@ -5,6 +5,8 @@ module WGPU
     attr_reader :handle
 
     def initialize(encoder, label: nil, timestamp_writes: nil)
+      @encoder = encoder
+      @ended = false
       desc = Native::ComputePassDescriptor.new
       desc[:next_in_chain] = nil
       if label
@@ -73,13 +75,21 @@ module WGPU
     end
 
     def end_pass
+      return if @ended
+
       Native.wgpuComputePassEncoderEnd(@handle)
+      @ended = true
+      @encoder.send(:pass_ended, self)
     end
 
     def end
       end_pass
     end
 
+    def ended?
+      @ended
+    end
+
     def release
       return if @handle.null?
       Native.wgpuComputePassEncoderRelease(@handle)

data/lib/wgpu/commands/render_bundle_encoder.rb

@@ -21,13 +21,19 @@ module WGPU
         desc[:label][:length] = 0
       end
 
-      formats = Array(color_formats).map { |f| Native::TextureFormat[f] }
+      formats = Array(color_formats).map do |format|
+        Native::EnumHelper.coerce(Native::TextureFormat, format, name: "color format")
+      end
       @formats_ptr = FFI::MemoryPointer.new(:uint32, formats.size)
       @formats_ptr.write_array_of_uint32(formats)
       desc[:color_format_count] = formats.size
       desc[:color_formats] = @formats_ptr
 
-      desc[:depth_stencil_format] = depth_stencil_format || :undefined
+      desc[:depth_stencil_format] = Native::EnumHelper.coerce(
+        Native::TextureFormat,
+        depth_stencil_format || :undefined,
+        name: "depth stencil format"
+      )
       desc[:sample_count] = sample_count
       desc[:depth_read_only] = depth_read_only ? 1 : 0
       desc[:stencil_read_only] = stencil_read_only ? 1 : 0
@@ -65,7 +71,8 @@ module WGPU
       raise RenderBundleError, "Encoder already finished" if @finished
 
       size ||= buffer.size - offset
-      Native.wgpuRenderBundleEncoderSetIndexBuffer(@handle, buffer.handle, format, offset, size)
+      format_value = Native::EnumHelper.coerce(Native::IndexFormat, format, name: "index format")
+      Native.wgpuRenderBundleEncoderSetIndexBuffer(@handle, buffer.handle, format_value, offset, size)
     end
 
     def draw(vertex_count, instance_count: 1, first_vertex: 0, first_instance: 0)

data/lib/wgpu/commands/render_pass.rb

@@ -8,6 +8,7 @@ module WGPU
       @encoder = encoder
       @pointers = []
       @max_draw_count = max_draw_count
+      @ended = false
 
       desc = Native::RenderPassDescriptor.new
       desc[:next_in_chain] = nil
@@ -61,7 +62,8 @@ module WGPU
 
     def set_index_buffer(buffer, format, offset: 0, size: nil)
       size ||= buffer.size - offset
-      Native.wgpuRenderPassEncoderSetIndexBuffer(@handle, buffer.handle, format, offset, size)
+      format_value = Native::EnumHelper.coerce(Native::IndexFormat, format, name: "index format")
+      Native.wgpuRenderPassEncoderSetIndexBuffer(@handle, buffer.handle, format_value, offset, size)
     end
 
     def draw(vertex_count, instance_count: 1, first_vertex: 0, first_instance: 0)
@@ -137,13 +139,21 @@ module WGPU
     end
 
     def end_pass
+      return if @ended
+
       Native.wgpuRenderPassEncoderEnd(@handle)
+      @ended = true
+      @encoder.send(:pass_ended, self)
     end
 
     def end
       end_pass
     end
 
+    def ended?
+      @ended
+    end
+
     def release
       return if @handle.null?
       Native.wgpuRenderPassEncoderRelease(@handle)
@@ -169,13 +179,13 @@ module WGPU
       @pointers << ptr
 
       attachments.each_with_index do |att, i|
-        ca = Native::RenderPassColorAttachment.new(ptr + i * Native::RenderPassColorAttachment.size)
+        ca = Native::RenderPassColorAttachment.new(ptr + (i * Native::RenderPassColorAttachment.size))
         ca[:next_in_chain] = nil
         ca[:view] = att[:view].handle
         ca[:depth_slice] = att[:depth_slice] || 0xFFFFFFFF
         ca[:resolve_target] = att[:resolve_target]&.handle
-        ca[:load_op] = att[:load_op] || :clear
-        ca[:store_op] = att[:store_op] || :store
+        ca[:load_op] = Native::EnumHelper.coerce(Native::LoadOp, att[:load_op] || :clear, name: "load op")
+        ca[:store_op] = Native::EnumHelper.coerce(Native::StoreOp, att[:store_op] || :store, name: "store op")
 
         clear = att[:clear_value] || { r: 0.0, g: 0.0, b: 0.0, a: 1.0 }
         ca[:clear_value][:r] = clear[:r] || 0.0
@@ -192,12 +202,28 @@ module WGPU
       @pointers << ds
 
       ds[:view] = att[:view].handle
-      ds[:depth_load_op] = att[:depth_load_op] || :clear
-      ds[:depth_store_op] = att[:depth_store_op] || :store
+      ds[:depth_load_op] = Native::EnumHelper.coerce(
+        Native::LoadOp,
+        att[:depth_load_op] || :clear,
+        name: "depth load op"
+      )
+      ds[:depth_store_op] = Native::EnumHelper.coerce(
+        Native::StoreOp,
+        att[:depth_store_op] || :store,
+        name: "depth store op"
+      )
       ds[:depth_clear_value] = att[:depth_clear_value] || 1.0
       ds[:depth_read_only] = att[:depth_read_only] ? 1 : 0
-      ds[:stencil_load_op] = att[:stencil_load_op] || :clear
-      ds[:stencil_store_op] = att[:stencil_store_op] || :store
+      ds[:stencil_load_op] = Native::EnumHelper.coerce(
+        Native::LoadOp,
+        att[:stencil_load_op] || :clear,
+        name: "stencil load op"
+      )
+      ds[:stencil_store_op] = Native::EnumHelper.coerce(
+        Native::StoreOp,
+        att[:stencil_store_op] || :store,
+        name: "stencil store op"
+      )
       ds[:stencil_clear_value] = att[:stencil_clear_value] || 0
       ds[:stencil_read_only] = att[:stencil_read_only] ? 1 : 0
 

data/lib/wgpu/core/adapter.rb

@@ -2,45 +2,66 @@
 
 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
 
-    def self.request(instance, power_preference: :high_performance, backend: nil, feature_level: :core, force_fallback_adapter: false, compatible_surface: nil)
+    def self.request(instance, power_preference: :high_performance, backend: nil, feature_level: :core,
+                     force_fallback_adapter: false, compatible_surface: nil, timeout: 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|
+        :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
       options[:next_in_chain] = nil
-      options[:feature_level] = feature_level
-      options[:power_preference] = power_preference
+      options[:feature_level] = Native::EnumHelper.coerce(
+        Native::FeatureLevel,
+        feature_level,
+        name: "feature level"
+      )
+      options[:power_preference] = Native::EnumHelper.coerce(
+        Native::PowerPreference,
+        power_preference,
+        name: "power preference"
+      )
       options[:force_fallback_adapter] = force_fallback_adapter ? 1 : 0
-      options[:backend_type] = backend || :undefined
+      options[:backend_type] = Native::EnumHelper.coerce(
+        Native::BackendType,
+        backend || :undefined,
+        name: "backend type"
+      )
       options[:compatible_surface] = compatible_surface&.handle
 
       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
-
-      Native.wgpuInstanceRequestAdapter(instance.handle, options, callback_info)
+      callback_info[:userdata1] = nil
+      callback_info[:userdata2] = nil
+
+      callback_token = CallbackKeepalive.retain(instance, callback)
+      begin
+        status_holder[:done] = false
+        future = Native.wgpuInstanceRequestAdapter(instance.handle, options, callback_info)
+        AsyncWaiter.wait(status_holder: status_holder, instance: instance, future: future, timeout: timeout)
+      ensure
+        CallbackKeepalive.release(instance, callback_token)
+      end
 
       handle = adapter_ptr.read_pointer
       if handle.null? || status_holder[:value] != :success
@@ -48,23 +69,31 @@ 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)
-      Device.request(self, label: label, required_features: required_features, required_limits: required_limits)
+    def request_device(label: nil, required_features: [], required_limits: nil, timeout: nil)
+      Device.request(
+        self,
+        label: label,
+        required_features: required_features,
+        required_limits: required_limits,
+        timeout: timeout
+      )
     end
 
-    def request_device_async(label: nil, required_features: [], required_limits: nil)
+    def request_device_async(label: nil, required_features: [], required_limits: nil, timeout: nil)
       AsyncTask.new do
         request_device(
           label: label,
           required_features: required_features,
-          required_limits: required_limits
+          required_limits: required_limits,
+          timeout: timeout
         )
       end
     end

data/lib/wgpu/core/async_waiter.rb

@@ -0,0 +1,92 @@
+# 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 poll_interval
+      @poll_interval ||= POLL_INTERVAL_SECONDS
+    end
+
+    def poll_interval=(seconds)
+      value = Float(seconds)
+      raise ArgumentError, "poll interval must be positive" unless value.positive?
+
+      @poll_interval = value
+    end
+
+    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, timeout: nil)
+      timeout = Float(timeout) if timeout
+      raise ArgumentError, "timeout must be non-negative" if timeout&.negative?
+
+      deadline = monotonic_time + timeout if timeout
+      wait_info = build_wait_info(future) if instance && Native.future_api?
+
+      until status_holder[:done]
+        raise_timeout!(timeout) if deadline && monotonic_time >= deadline
+
+        waited = false
+        if instance && wait_info
+          waited = 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) unless status_holder[:done] || waited
+      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 false if [:success, :timed_out].include?(status)
+
+      raise Error, "wgpuInstanceWaitAny failed: #{status.inspect}"
+    end
+    private_class_method :wait_with_wait_any
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+    private_class_method :monotonic_time
+
+    def raise_timeout!(timeout)
+      raise TimeoutError, "GPU operation timed out after #{timeout} seconds"
+    end
+    private_class_method :raise_timeout!
+  end
+end

data/lib/wgpu/core/canvas_context.rb

@@ -29,8 +29,6 @@ module WGPU
 
     def configure(device:, format: nil, usage: :render_attachment, view_formats: [], color_space: "srgb", tone_mapping: nil, alpha_mode: :opaque, width: nil, height: nil, present_mode: :fifo)
       ensure_surface
-      color_space # reserved for API parity
-      tone_mapping # reserved for API parity
 
       width = width || @physical_size[0]
       height = height || @physical_size[1]