wgpu 1.2.1 → 1.2.2

data/lib/wgpu/core/device.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "monitor"
+
 module WGPU
   class Device
     attr_reader :handle, :queue, :adapter
@@ -18,6 +20,7 @@ module WGPU
     # @raise [TimeoutError] if the request exceeds +timeout+
     # @raise [ArgumentError] if +timeout+ is used without an instance-backed adapter
     def self.request(adapter, label: nil, required_features: [], required_limits: nil, timeout: nil)
+      timeout = AsyncWaiter.normalize_timeout(timeout)
       if timeout && !adapter.instance
         raise ArgumentError,
           "Device.request timeout requires an instance-backed adapter; " \
@@ -134,7 +137,7 @@ module WGPU
       callback_token = CallbackKeepalive.retain(adapter, callback)
       future =
         begin
-          Native.wgpuAdapterRequestDevice(adapter.handle, desc, callback_info)
+          Native.wgpuAdapterRequestDevice(NativeResource.checked_handle(adapter, expected_class: Adapter), desc, callback_info)
         rescue StandardError
           CallbackKeepalive.release(adapter, callback_token)
           release_device_callback_keepalive(device_callback_state)
@@ -148,7 +151,7 @@ module WGPU
           future: future,
           timeout: timeout
         )
-      rescue TimeoutError
+      rescue StandardError
         abandoned_device = nil
         cleanup_abandoned = status_holder[:mutex].synchronize do
           status_holder[:abandoned] = true
@@ -192,7 +195,8 @@ module WGPU
         device.send(:adopt_device_callback_keepalive)
         device
       rescue StandardError
-        device ? device.release : release_abandoned_device(handle, device_callback_state)
+        device&.release
+        release_device_callback_keepalive(device_callback_state)
         raise
       end
     end
@@ -394,6 +398,8 @@ module WGPU
         end
       end
       result
+    ensure
+      Native.wgpuSupportedFeaturesFreeMembers(supported) if supported
     end
 
     # Reports whether a feature is enabled on the device.
@@ -425,70 +431,41 @@ module WGPU
     end
 
     # Pushes a scope that captures matching GPU errors.
+    # Scopes belong to the pushing thread and serialize scoped work on this device.
+    # Pop on the same thread; do not wait here for another thread's scoped work.
     # @param filter [Symbol, Integer] error filter
     # @return [void]
     def push_error_scope(filter = :validation)
       filter_value = Native::EnumHelper.coerce(Native::ErrorFilter, filter, name: "error filter")
-      Native.wgpuDevicePushErrorScope(@handle, filter_value)
+      error_scope_monitor.enter
+      begin
+        ensure_not_released!
+        Native.wgpuDevicePushErrorScope(@handle, filter_value)
+        @error_scope_depth = (@error_scope_depth || 0) + 1
+        @error_scope_owner = Thread.current
+      rescue StandardError
+        error_scope_monitor.exit
+        raise
+      end
     end
 
     # Pops the latest error scope and waits for its result.
     # @param timeout [Numeric, nil] maximum wait time in seconds
     # @return [Hash] native status, error type, and message
     def pop_error_scope(timeout: nil)
-      error_holder = { done: false, status: nil, type: nil, message: nil }
-
-      callback_lifetime_release = device_callback_lifetime_lease
-      callback_token = nil
-      callback = FFI::Function.new(
-        :void, [:uint32, :uint32, Native::StringView.by_value, :pointer, :pointer]
-      ) do |status, error_type, message, _userdata1, _userdata2|
-        begin
-          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])
-          end
-          error_holder[:done] = true
-        ensure
-          CallbackKeepalive.release(self, callback_token)
-          callback_lifetime_release.call
-        end
-      end
-
-      callback_info = Native::PopErrorScopeCallbackInfo.new
-      callback_info[:next_in_chain] = nil
-      callback_info[:mode] = AsyncWaiter.callback_mode(instance: @adapter&.instance)
-      callback_info[:callback] = callback
-      callback_info[:userdata1] = nil
-      callback_info[:userdata2] = nil
-
-      callback_token = CallbackKeepalive.retain(self, callback)
-      future =
-        begin
-          Native.wgpuDevicePopErrorScope(@handle, callback_info)
-        rescue StandardError
-          CallbackKeepalive.release(self, callback_token)
-          callback_lifetime_release.call
-          raise
-        end
-      AsyncWaiter.wait(
-        status_holder: error_holder,
-        instance: @adapter&.instance,
-        device: self,
-        future: future,
-        timeout: timeout
-      )
-
-      error_holder
+      timeout = AsyncWaiter.normalize_timeout(timeout)
+      error_holder, future = begin_pop_error_scope
+      wait_for_error_scope(error_holder, future, timeout: timeout)
     end
 
-    # Pops the latest error scope on a background thread.
+    # Starts popping on the calling thread and waits for completion in a background task.
     #
     # @param timeout [Numeric, nil] maximum wait time in seconds
     # @return [AsyncTask] task whose value is the error hash
     def pop_error_scope_async(timeout: nil)
-      AsyncTask.new { pop_error_scope(timeout: timeout) }
+      timeout = AsyncWaiter.normalize_timeout(timeout)
+      error_holder, future = begin_pop_error_scope
+      AsyncTask.new { wait_for_error_scope(error_holder, future, timeout: timeout) }
     end
 
     # Pops the latest error scope as a typed error.
@@ -503,10 +480,11 @@ module WGPU
     # @yieldreturn [Object] block result
     # @return [Object] block result
     def with_error_scope(filter = :validation)
-      push_error_scope(filter)
-      result = yield
-      error = GPUError.from_hash(pop_error_scope)
-      error&.raise!
+      raise ArgumentError, "block is required" unless block_given?
+
+      result = nil
+      error = capture_error_scope(filter) { result = yield }
+      GPUError.from_hash(error)&.raise!
       result
     end
 
@@ -706,6 +684,85 @@ module WGPU
 
     private
 
+    def begin_pop_error_scope
+      unless @error_scope_owner == Thread.current && @error_scope_depth.to_i.positive?
+        raise DeviceError, "No error scope belongs to the current thread"
+      end
+
+      error_holder = { done: false, status: nil, type: nil, message: nil }
+
+      callback_lifetime_release = device_callback_lifetime_lease
+      callback_token = nil
+      callback = FFI::Function.new(
+        :void, [:uint32, :uint32, Native::StringView.by_value, :pointer, :pointer]
+      ) do |status, error_type, message, _userdata1, _userdata2|
+        begin
+          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])
+          end
+          error_holder[:done] = true
+        ensure
+          CallbackKeepalive.release(self, callback_token)
+          callback_lifetime_release.call
+        end
+      end
+
+      callback_info = Native::PopErrorScopeCallbackInfo.new
+      callback_info[:next_in_chain] = nil
+      callback_info[:mode] = AsyncWaiter.callback_mode(instance: @adapter&.instance)
+      callback_info[:callback] = callback
+      callback_info[:userdata1] = nil
+      callback_info[:userdata2] = nil
+
+      callback_token = CallbackKeepalive.retain(self, callback)
+      @error_scope_depth -= 1
+      @error_scope_owner = nil if @error_scope_depth.zero?
+      future =
+        begin
+          Native.wgpuDevicePopErrorScope(@handle, callback_info)
+        rescue StandardError
+          CallbackKeepalive.release(self, callback_token)
+          callback_lifetime_release.call
+          raise
+        ensure
+          error_scope_monitor.exit
+        end
+      [error_holder, future]
+    end
+
+    def wait_for_error_scope(error_holder, future, timeout:)
+      AsyncWaiter.wait(
+        status_holder: error_holder,
+        instance: @adapter&.instance,
+        device: self,
+        future: future,
+        timeout: timeout
+      )
+      error_holder
+    end
+
+    def error_scope_monitor
+      @error_scope_monitor ||= Monitor.new
+    end
+
+    # The reentrant scope lock spans push, the operation, and native pop.
+    def capture_error_scope(filter = :validation)
+      push_error_scope(filter)
+      begin
+        yield
+      ensure
+        active_error = $!
+        begin
+          error = pop_error_scope
+        rescue StandardError
+          raise unless active_error
+        end
+      end
+      error
+    end
+
     def adopt_device_callback_keepalive
       @device_callback_tokens =
         self.class.send(:transfer_device_callback_keepalive, @device_callback_state, self)

data/lib/wgpu/core/queue.rb

@@ -27,7 +27,7 @@ module WGPU
         raise CommandError, "Command buffer has already been submitted" if buffer.submitted?
       end
 
-      handles = buffers.map(&:handle)
+      handles = buffers.map { |buffer| NativeResource.checked_handle(buffer, expected_class: CommandBuffer) }
       ptr = FFI::MemoryPointer.new(:pointer, handles.size)
       ptr.write_array_of_pointer(handles)
 
@@ -54,7 +54,7 @@ module WGPU
 
       Native.wgpuQueueWriteBuffer(
         @handle,
-        buffer.handle,
+        NativeResource.checked_handle(buffer, expected_class: Buffer),
         buffer_offset,
         data_ptr + data_offset,
         write_size
@@ -71,7 +71,7 @@ module WGPU
       data_ptr, byte_size = DataTypes.to_pointer(data, type:)
 
       dst = Native::ImageCopyTexture.new
-      dst[:texture] = destination[:texture].handle
+      dst[:texture] = NativeResource.checked_handle(destination[:texture], expected_class: Texture)
       dst[:mip_level] = destination[:mip_level] || 0
       dst[:origin][:x] = destination.dig(:origin, :x) || 0
       dst[:origin][:y] = destination.dig(:origin, :y) || 0
@@ -82,16 +82,7 @@ module WGPU
         name: "texture aspect"
       )
 
-      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
+      extent = DescriptorHelpers.extent_3d(size)
 
       layout = Native::TextureDataLayout.new
       layout[:offset] = data_layout[:offset] || 0
@@ -148,7 +139,8 @@ module WGPU
       device ||= @device
       raise ArgumentError, "device is required when the queue has no owning device" unless device
 
-      width, height, depth = texture_extent(size)
+      extent = DescriptorHelpers.extent_3d(size)
+      width, height, depth = extent.values
       bytes_per_row = data_layout[:bytes_per_row]
       raise ArgumentError, "data_layout[:bytes_per_row] is required" unless bytes_per_row
 
@@ -206,6 +198,7 @@ module WGPU
     # @param timeout [Numeric, nil] maximum wait time in seconds
     # @return [Symbol] native completion status
     def on_submitted_work_done(device: nil, timeout: nil)
+      timeout = AsyncWaiter.normalize_timeout(timeout)
       device ||= @device
       instance = device&.adapter&.instance
       status_holder = { done: false, status: nil }
@@ -271,14 +264,6 @@ module WGPU
 
     private
 
-    def texture_extent(size)
-      if size.is_a?(Array)
-        [size.fetch(0), size[1] || 1, size[2] || 1]
-      else
-        [size.fetch(:width), size[:height] || 1, size[:depth_or_array_layers] || 1]
-      end
-    end
-
     def validate_readback_staging!(staging, required_size)
       if staging.size < required_size
         raise ArgumentError,

data/lib/wgpu/core/surface.rb

@@ -18,7 +18,7 @@ module WGPU
       desc[:label][:data] = nil
       desc[:label][:length] = 0
 
-      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      handle = Native.wgpuInstanceCreateSurface(NativeResource.checked_handle(instance, expected_class: Instance), desc)
       raise SurfaceError, "Failed to create surface from Metal layer" if handle.null?
 
       new(handle, instance)
@@ -39,7 +39,7 @@ module WGPU
       desc[:label][:data] = nil
       desc[:label][:length] = 0
 
-      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      handle = Native.wgpuInstanceCreateSurface(NativeResource.checked_handle(instance, expected_class: Instance), desc)
       raise SurfaceError, "Failed to create surface from Windows HWND" if handle.null?
 
       new(handle, instance)
@@ -60,7 +60,7 @@ module WGPU
       desc[:label][:data] = nil
       desc[:label][:length] = 0
 
-      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      handle = Native.wgpuInstanceCreateSurface(NativeResource.checked_handle(instance, expected_class: Instance), desc)
       raise SurfaceError, "Failed to create surface from Xlib window" if handle.null?
 
       new(handle, instance)
@@ -81,7 +81,7 @@ module WGPU
       desc[:label][:data] = nil
       desc[:label][:length] = 0
 
-      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      handle = Native.wgpuInstanceCreateSurface(NativeResource.checked_handle(instance, expected_class: Instance), desc)
       raise SurfaceError, "Failed to create surface from Wayland surface" if handle.null?
 
       new(handle, instance)
@@ -102,7 +102,7 @@ module WGPU
     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[:device] = NativeResource.checked_handle(device, expected_class: Device)
       config[:format] = Native::EnumHelper.coerce(Native::TextureFormat, format, name: "surface format")
       config[:usage] = normalize_usage(usage)
       config[:width] = width
@@ -216,7 +216,7 @@ module WGPU
     # @return [Hash]
     def capabilities(adapter)
       caps = Native::SurfaceCapabilities.new
-      Native.wgpuSurfaceGetCapabilities(@handle, adapter.handle, caps)
+      Native.wgpuSurfaceGetCapabilities(@handle, NativeResource.checked_handle(adapter, expected_class: Adapter), caps)
 
       formats = []
       if caps[:format_count] > 0 && !caps[:formats].null?

data/lib/wgpu/descriptor_helpers.rb

@@ -6,6 +6,28 @@ module WGPU
 
     module_function
 
+    # Normalizes an Array or Hash texture extent to a native descriptor.
+    # @param size [Array<Integer>, Hash] width, height, and depth/layer count
+    # @return [Native::Extent3D]
+    def extent_3d(size)
+      values = case size
+               when Array
+                 [size.fetch(0), size[1] || 1, size[2] || 1]
+               when Hash
+                 [size.fetch(:width), size[:height] || 1, size[:depth_or_array_layers] || 1]
+               else
+                 raise ArgumentError, "texture size must be an Array or Hash"
+               end
+      extent = Native::Extent3D.new
+      [:width, :height, :depth_or_array_layers].zip(values).each do |field, value|
+        value = Integer(value)
+        raise ArgumentError, "#{field} must be between 0 and 4294967295" unless (0..0xFFFFFFFF).cover?(value)
+
+        extent[field] = value
+      end
+      extent
+    end
+
     # Writes an optional Ruby label into a native descriptor.
     #
     # @param descriptor [FFI::Struct] descriptor with a +label+ member

data/lib/wgpu/native/functions.rb

@@ -292,6 +292,9 @@ module WGPU
     attach_function :wgpuTextureViewRelease,
                     [:pointer], :void
 
+    attach_function :wgpuSupportedFeaturesFreeMembers,
+                    [SupportedFeatures.by_value], :void
+
     attach_function :wgpuAdapterInfoFreeMembers,
                     [AdapterInfo.by_value], :void
 

data/lib/wgpu/native/installer.rb

@@ -186,7 +186,13 @@ module WGPU
             end
 
             FileUtils.mkdir_p(entry.directory? ? target : File.dirname(target))
-            entry.extract(target) { true } unless entry.directory?
+            next if entry.directory?
+
+            if entry.method(:extract).parameters.include?([:key, :destination_directory])
+              entry.extract(entry.name, destination_directory: destination) { true }
+            else
+              entry.extract(target) { true }
+            end
           end
         end
         true

data/lib/wgpu/native_resource.rb

@@ -182,6 +182,15 @@ module WGPU
   module NativeResource
     GUARDED_METHOD_EXEMPTIONS = [:initialize, :release, :released?, :handle, :label, :inspect].freeze
 
+    # Validates resource arguments before passing their handles to FFI.
+    def self.checked_handle(resource, expected_class:)
+      unless resource.is_a?(expected_class)
+        raise TypeError, "expected #{expected_class}, got #{resource.class}"
+      end
+      resource.send(:ensure_not_released!)
+      resource.handle
+    end
+
     module ClassMethods
       private
 
@@ -205,6 +214,9 @@ module WGPU
         super
         initialize_native_resource(label: kwargs.fetch(:label, UNSET))
         attach_device_callback_lifetime_from_parent
+        initialized = true
+      ensure
+        release if !initialized && @handle && !released?
       end
 
       # Releases a resource once and unregisters it from leak tracking.
@@ -284,6 +296,10 @@ module WGPU
 
     private
 
+    def initialize_copy(_source)
+      raise TypeError, "#{self.class} owns a native resource and cannot be copied"
+    end
+
     def attach_device_callback_lifetime(owner)
       lifetime = owner&.instance_variable_get(:@device_callback_lifetime)
       return self unless lifetime

data/lib/wgpu/pipeline/bind_group.rb

@@ -29,13 +29,13 @@ module WGPU
         desc[:label][:data] = nil
         desc[:label][:length] = 0
       end
-      desc[:layout] = layout.handle
+      desc[:layout] = NativeResource.checked_handle(layout, expected_class: BindGroupLayout)
       desc[:entry_count] = entries_array.size
       desc[:entries] = entries_ptr
 
-      device.push_error_scope(:validation)
-      @handle = Native.wgpuDeviceCreateBindGroup(device.handle, desc)
-      error = device.pop_error_scope
+      error = device.send(:capture_error_scope) do
+        @handle = Native.wgpuDeviceCreateBindGroup(NativeResource.checked_handle(device, expected_class: Device), desc)
+      end
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)
         msg = error[:message] || "Failed to create bind group"
@@ -74,7 +74,7 @@ module WGPU
 
       if entry_hash[:buffer]
         buffer = entry_hash[:buffer]
-        entry[:buffer] = buffer.handle
+        entry[:buffer] = NativeResource.checked_handle(buffer, expected_class: Buffer)
         entry[:offset] = entry_hash[:offset] || 0
         entry[:size] = entry_hash[:size] || buffer.size
       else
@@ -84,13 +84,13 @@ module WGPU
       end
 
       if entry_hash[:sampler]
-        entry[:sampler] = entry_hash[:sampler].handle
+        entry[:sampler] = NativeResource.checked_handle(entry_hash[:sampler], expected_class: Sampler)
       else
         entry[:sampler] = nil
       end
 
       if entry_hash[:texture_view]
-        entry[:texture_view] = entry_hash[:texture_view].handle
+        entry[:texture_view] = NativeResource.checked_handle(entry_hash[:texture_view], expected_class: TextureView)
       else
         entry[:texture_view] = nil
       end

data/lib/wgpu/pipeline/bind_group_layout.rb

@@ -24,9 +24,9 @@ module WGPU
       @device = device
       desc, @descriptor_keepalive = build_descriptor(label:, entries:)
 
-      device.push_error_scope(:validation)
-      @handle = Native.wgpuDeviceCreateBindGroupLayout(device.handle, desc)
-      error = device.pop_error_scope
+      error = device.send(:capture_error_scope) do
+        @handle = Native.wgpuDeviceCreateBindGroupLayout(NativeResource.checked_handle(device, expected_class: Device), desc)
+      end
       @descriptor_keepalive = nil
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)

data/lib/wgpu/pipeline/compute_pipeline.rb

@@ -13,9 +13,9 @@ module WGPU
       @device = device
       desc, @pointers = build_descriptor(label:, layout:, compute:)
 
-      device.push_error_scope(:validation)
-      @handle = Native.wgpuDeviceCreateComputePipeline(device.handle, desc)
-      error = device.pop_error_scope
+      error = device.send(:capture_error_scope) do
+        @handle = Native.wgpuDeviceCreateComputePipeline(NativeResource.checked_handle(device, expected_class: Device), desc)
+      end
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)
         msg = error[:message] || "Failed to create compute pipeline"
@@ -59,7 +59,7 @@ module WGPU
       DescriptorHelpers.set_label(desc, label, keepalive: @pointers)
       desc[:layout] = normalize_layout(layout)
       desc[:compute][:next_in_chain] = nil
-      desc[:compute][:module] = compute.fetch(:module).handle
+      desc[:compute][:module] = NativeResource.checked_handle(compute.fetch(:module), expected_class: ShaderModule)
       DescriptorHelpers.set_nullable_string_view(
         desc[:compute][:entry_point],
         compute[:entry_point],
@@ -72,7 +72,7 @@ module WGPU
 
     def normalize_layout(layout)
       return nil if layout.nil? || layout == :auto || layout == "auto"
-      layout.handle
+      NativeResource.checked_handle(layout, expected_class: PipelineLayout)
     end
   end
 end

data/lib/wgpu/pipeline/pipeline_layout.rb

@@ -13,7 +13,7 @@ module WGPU
 
       layouts = Array(bind_group_layouts)
       layouts_ptr = FFI::MemoryPointer.new(:pointer, layouts.size)
-      layouts_ptr.write_array_of_pointer(layouts.map(&:handle))
+      layouts_ptr.write_array_of_pointer(layouts.map { |layout| NativeResource.checked_handle(layout, expected_class: BindGroupLayout) })
 
       desc = Native::PipelineLayoutDescriptor.new
       desc[:next_in_chain] = nil
@@ -28,9 +28,9 @@ module WGPU
       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
+      error = device.send(:capture_error_scope) do
+        @handle = Native.wgpuDeviceCreatePipelineLayout(NativeResource.checked_handle(device, expected_class: Device), desc)
+      end
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)
         msg = error[:message] || "Failed to create pipeline layout"

data/lib/wgpu/pipeline/render_pipeline.rb

@@ -22,9 +22,9 @@ module WGPU
         fragment:
       )
 
-      device.push_error_scope(:validation)
-      @handle = Native.wgpuDeviceCreateRenderPipeline(device.handle, desc)
-      error = device.pop_error_scope
+      error = device.send(:capture_error_scope) do
+        @handle = Native.wgpuDeviceCreateRenderPipeline(NativeResource.checked_handle(device, expected_class: Device), desc)
+      end
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)
         msg = error[:message] || "Failed to create render pipeline"
@@ -78,7 +78,7 @@ module WGPU
         context: "render pipeline vertex descriptor"
       )
       vertex_state[:next_in_chain] = nil
-      vertex_state[:module] = vertex[:module].handle
+      vertex_state[:module] = NativeResource.checked_handle(vertex[:module], expected_class: ShaderModule)
 
       DescriptorHelpers.set_nullable_string_view(
         vertex_state[:entry_point],
@@ -265,7 +265,7 @@ module WGPU
       frag = Native::FragmentState.new
       @pointers << frag
       frag[:next_in_chain] = nil
-      frag[:module] = fragment[:module].handle
+      frag[:module] = NativeResource.checked_handle(fragment[:module], expected_class: ShaderModule)
 
       DescriptorHelpers.set_nullable_string_view(
         frag[:entry_point],
@@ -369,7 +369,7 @@ module WGPU
 
     def normalize_layout(layout)
       return nil if layout.nil? || layout == :auto || layout == "auto"
-      layout.handle
+      NativeResource.checked_handle(layout, expected_class: PipelineLayout)
     end
   end
 end

data/lib/wgpu/pipeline/shader_module.rb

@@ -30,9 +30,9 @@ module WGPU
         desc[:label][:length] = 0
       end
 
-      device.push_error_scope(:validation)
-      @handle = Native.wgpuDeviceCreateShaderModule(device.handle, desc)
-      error = device.pop_error_scope
+      error = device.send(:capture_error_scope) do
+        @handle = Native.wgpuDeviceCreateShaderModule(NativeResource.checked_handle(device, expected_class: Device), desc)
+      end
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)
         msg = error[:message] || "Failed to create shader module"