wgpu 1.1.0 → 1.2.0

data/lib/wgpu/resources/buffer.rb

@@ -7,36 +7,38 @@ module WGPU
     def initialize(device, label: nil, size:, usage:, mapped_at_creation: false)
       @device = device
       @size = size
-      @usage = normalize_usage(usage)
+      @usage =
+        begin
+          normalize_usage(usage)
+        rescue ArgumentError => e
+          raise BufferError, buffer_error_message(e.message, label)
+        end
       @mapped = mapped_at_creation
-      @map_callbacks = []
+      @map_state = mapped_at_creation ? :mapped : :unmapped
 
-      desc = Native::BufferDescriptor.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[:usage] = @usage
-      desc[:size] = size
-      desc[:mapped_at_creation] = mapped_at_creation ? 1 : 0
+      desc, keepalive = build_descriptor(
+        label:,
+        size:,
+        usage: @usage,
+        mapped_at_creation:
+      )
+      @descriptor_keepalive = keepalive
 
       device.push_error_scope(:validation)
       @handle = Native.wgpuDeviceCreateBuffer(device.handle, desc)
       error = device.pop_error_scope
+      @descriptor_keepalive = nil
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)
         msg = error[:message] || "Failed to create buffer"
-        raise BufferError, msg
+        raise BufferError, buffer_error_message(msg, label)
       end
     end
 
-    def write(data, offset: 0)
-      ptr, byte_size = data_to_pointer(data)
+    def write(data, offset: 0, type: :f32)
+      ptr, byte_size = DataTypes.to_pointer(data, type:)
+      DataTypes.validate_alignment!(offset, 4, name: "offset")
+      DataTypes.validate_alignment!(byte_size, 4, name: "data size")
       Native.wgpuQueueWriteBuffer(@device.queue.handle, @handle, offset, ptr, byte_size)
     end
 
@@ -44,6 +46,7 @@ module WGPU
       raise BufferError, "Buffer is not mapped" unless @mapped
 
       size ||= @size - offset
+      validate_map_range!(offset, size)
       ptr = Native.wgpuBufferGetMappedRange(@handle, offset, size)
       raise BufferError, "Failed to get mapped range" if ptr.null?
 
@@ -57,23 +60,24 @@ module WGPU
     def unmap
       Native.wgpuBufferUnmap(@handle)
       @mapped = false
+      @map_state = :unmapped
     end
 
-    def map_sync(mode, offset: 0, size: nil)
-      status_holder, callback, future = begin_map_request(mode, offset: offset, size: size)
-      wait_for_map(status_holder, future)
+    def map_sync(mode, offset: 0, size: nil, timeout: nil)
+      status_holder, callback_token, future = begin_map_request(mode, offset: offset, size: size)
+      wait_for_map(status_holder, future, timeout:)
       finalize_map(status_holder)
     ensure
-      @map_callbacks.delete(callback) if callback
+      CallbackKeepalive.release(self, callback_token)
     end
 
     def map_async(mode, offset: 0, size: nil)
-      status_holder, callback, future = begin_map_request(mode, offset: offset, size: size)
+      status_holder, callback_token, future = begin_map_request(mode, offset: offset, size: size)
       AsyncTask.new do
         wait_for_map(status_holder, future)
         finalize_map(status_holder)
       ensure
-        @map_callbacks.delete(callback)
+        CallbackKeepalive.release(self, callback_token)
       end
     end
 
@@ -81,20 +85,23 @@ module WGPU
       raise BufferError, "Buffer is not mapped" unless @mapped
 
       size ||= @size - offset
+      validate_map_range!(offset, size)
       ptr = Native.wgpuBufferGetConstMappedRange(@handle, offset, size)
       raise BufferError, "Failed to get mapped range" if ptr.null?
 
       ptr.read_bytes(size)
     end
 
-    def read_mapped(offset: 0, size: nil)
-      read_mapped_data(offset: offset, size: size)
+    def read_mapped(offset: 0, size: nil, type: nil)
+      bytes = read_mapped_data(offset: offset, size: size)
+      type ? DataTypes.unpack(bytes, type:) : bytes
     end
 
-    def write_mapped(data, offset: 0)
+    def write_mapped(data, offset: 0, type: :f32)
       raise BufferError, "Buffer is not mapped" unless @mapped
 
-      ptr, byte_size = data_to_pointer(data)
+      ptr, byte_size = DataTypes.to_pointer(data, type:)
+      validate_map_range!(offset, byte_size)
       target = Native.wgpuBufferGetMappedRange(@handle, offset, byte_size)
       raise BufferError, "Failed to get mapped range" if target.null?
 
@@ -102,18 +109,39 @@ module WGPU
     end
 
     def read_mapped_floats(offset: 0, count: nil)
-      raise BufferError, "Buffer is not mapped" unless @mapped
+      read_mapped_values(type: :f32, offset:, count:)
+    end
 
-      size = count ? count * 4 : @size - offset
-      ptr = Native.wgpuBufferGetConstMappedRange(@handle, offset, size)
-      raise BufferError, "Failed to get mapped range" if ptr.null?
+    def read_mapped_uint32s(offset: 0, count: nil)
+      read_mapped_values(type: :u32, offset:, count:)
+    end
+
+    def read_mapped_int32s(offset: 0, count: nil)
+      read_mapped_values(type: :i32, offset:, count:)
+    end
 
-      ptr.read_array_of_float(size / 4)
+    def read_mapped_float64s(offset: 0, count: nil)
+      read_mapped_values(type: :f64, offset:, count:)
+    end
+
+    def read_mapped_uint16s(offset: 0, count: nil)
+      read_mapped_values(type: :u16, offset:, count:)
+    end
+
+    def read_mapped_uint8s(offset: 0, count: nil)
+      read_mapped_values(type: :u8, offset:, count:)
+    end
+
+    def read_mapped_values(type: :f32, offset: 0, count: nil)
+      element_size = DataTypes.byte_size(type)
+      size = count ? count * element_size : @size - offset
+      DataTypes.unpack(read_mapped_data(offset:, size:), type:)
     end
 
     def map_state
-      state = Native.wgpuBufferGetMapState(@handle)
-      state || (@mapped ? :mapped : :unmapped)
+      return @map_state unless Native.buffer_map_state_available?
+
+      Native.wgpuBufferGetMapState(@handle) || @map_state
     end
 
     def destroy
@@ -128,14 +156,21 @@ module WGPU
 
     private
 
+    def build_descriptor(label:, size:, usage:, mapped_at_creation:)
+      keepalive = []
+      desc = Native::BufferDescriptor.new
+      desc[:next_in_chain] = nil
+      DescriptorHelpers.set_label(desc, label, keepalive:)
+      desc[:usage] = usage
+      desc[:size] = size
+      desc[:mapped_at_creation] = mapped_at_creation ? 1 : 0
+      [desc, keepalive]
+    end
+
     def begin_map_request(mode, offset:, size:)
       size ||= @size - offset
-      mode_flag = case mode
-                  when :read then Native::MapMode[:read]
-                  when :write then Native::MapMode[:write]
-                  when Integer then mode
-                  else raise ArgumentError, "Invalid map mode: #{mode}"
-                  end
+      validate_map_range!(offset, size)
+      mode_flag = Native::EnumHelper.coerce(Native::MapMode, mode, name: "map mode")
 
       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|
@@ -145,7 +180,7 @@ module WGPU
           status_holder[:message] = message[:data].read_string(message[:length])
         end
       end
-      @map_callbacks << callback
+      callback_token = CallbackKeepalive.retain(self, callback)
 
       callback_info = Native::BufferMapCallbackInfo.new
       callback_info[:next_in_chain] = nil
@@ -155,24 +190,28 @@ module WGPU
       callback_info[:userdata2] = nil
 
       future = Native.wgpuBufferMapAsync(@handle, mode_flag, offset, size, callback_info)
+      @map_state = :pending
 
-      [status_holder, callback, future]
+      [status_holder, callback_token, future]
     end
 
-    def wait_for_map(status_holder, future)
+    def wait_for_map(status_holder, future, timeout: nil)
       AsyncWaiter.wait(
         status_holder: status_holder,
         instance: @device.adapter&.instance,
         device: @device,
-        future: future
+        future: future,
+        timeout: timeout
       )
     end
 
     def finalize_map(status_holder)
       if status_holder[:status] == :success
         @mapped = true
+        @map_state = :mapped
         true
       else
+        @map_state = :unmapped
         detail = status_holder[:message]
         base = "Failed to map buffer: #{status_holder[:status]}"
         raise BufferError, detail && !detail.empty? ? "#{base} (#{detail})" : base
@@ -180,33 +219,17 @@ module WGPU
     end
 
     def normalize_usage(usage)
-      case usage
-      when Integer
-        usage
-      when Symbol
-        Native::BufferUsage[usage]
-      when Array
-        usage.reduce(0) { |acc, u| acc | Native::BufferUsage[u] }
-      else
-        raise ArgumentError, "Invalid usage type: #{usage.class}"
-      end
+      Native::EnumHelper.coerce_flags(Native::BufferUsage, usage, name: "buffer usage")
     end
 
-    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
+    def buffer_error_message(message, label)
+      context = label ? " #{label.inspect}" : ""
+      "create buffer#{context}: #{message}"
+    end
+
+    def validate_map_range!(offset, size)
+      DataTypes.validate_alignment!(offset, 8, name: "map offset")
+      DataTypes.validate_alignment!(size, 4, name: "map size")
     end
   end
 
@@ -217,12 +240,64 @@ module WGPU
     end
 
     def read_floats(count = nil)
-      count ||= @size / 4
-      @pointer.read_array_of_float(count)
+      read(type: :f32, count:)
     end
 
     def write_floats(data)
-      @pointer.write_array_of_float(data)
+      write(data, type: :f32)
+    end
+
+    def read_uint32s(count = nil)
+      read(type: :u32, count:)
+    end
+
+    def write_uint32s(data)
+      write(data, type: :u32)
+    end
+
+    def read_int32s(count = nil)
+      read(type: :i32, count:)
+    end
+
+    def write_int32s(data)
+      write(data, type: :i32)
+    end
+
+    def read_float64s(count = nil)
+      read(type: :f64, count:)
+    end
+
+    def write_float64s(data)
+      write(data, type: :f64)
+    end
+
+    def read_uint16s(count = nil)
+      read(type: :u16, count:)
+    end
+
+    def write_uint16s(data)
+      write(data, type: :u16)
+    end
+
+    def read_uint8s(count = nil)
+      read(type: :u8, count:)
+    end
+
+    def write_uint8s(data)
+      write(data, type: :u8)
+    end
+
+    def read(type: :f32, count: nil)
+      byte_size = DataTypes.byte_size(type)
+      count ||= @size / byte_size
+      DataTypes.unpack(@pointer.read_bytes(count * byte_size), type:)
+    end
+
+    def write(data, type: :f32)
+      bytes = data.is_a?(String) ? data : DataTypes.pack(data, type:)
+      raise ArgumentError, "data exceeds mapped range" if bytes.bytesize > @size
+
+      @pointer.put_bytes(0, bytes)
     end
 
     def read_bytes

data/lib/wgpu/resources/query_set.rb

@@ -2,10 +2,14 @@
 
 module WGPU
   class QuerySet
-    attr_reader :handle
+    attr_reader :handle, :count, :type
 
     def initialize(device, label: nil, type:, count:)
       @device = device
+      @count = Integer(count)
+      type_value = Native::EnumHelper.coerce(Native::QueryType, type, name: "query type")
+      @type = Native::QueryType[type_value]
+      @destroyed = false
 
       desc = Native::QuerySetDescriptor.new
       desc[:next_in_chain] = nil
@@ -17,28 +21,26 @@ module WGPU
         desc[:label][:data] = nil
         desc[:label][:length] = 0
       end
-      desc[:type] = type
-      desc[:count] = count
+      desc[:type] = type_value
+      desc[:count] = @count
 
       @handle = Native.wgpuDeviceCreateQuerySet(device.handle, desc)
       raise ResourceError, "Failed to create query set" if @handle.null?
     end
 
-    def count
-      Native.wgpuQuerySetGetCount(@handle)
-    end
-
-    def type
-      Native.wgpuQuerySetGetType(@handle)
-    end
-
     def destroy
+      return if @destroyed
+
       Native.wgpuQuerySetDestroy(@handle)
+      @destroyed = true
     end
 
     def release
       return if @handle.null?
-      Native.wgpuQuerySetRelease(@handle)
+
+      # Pinned wgpu-native v27 removes a destroyed query set from its storage;
+      # calling Release afterward aborts inside Rust instead of being harmless.
+      Native.wgpuQuerySetRelease(@handle) unless @destroyed
       @handle = FFI::Pointer::NULL
     end
   end

data/lib/wgpu/resources/sampler.rb

@@ -7,30 +7,25 @@ module WGPU
     def initialize(device, 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)
       @device = device
 
-      desc = Native::SamplerDescriptor.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[:address_mode_u] = address_mode_u
-      desc[:address_mode_v] = address_mode_v
-      desc[:address_mode_w] = address_mode_w
-      desc[:mag_filter] = mag_filter
-      desc[:min_filter] = min_filter
-      desc[:mipmap_filter] = mipmap_filter
-      desc[:lod_min_clamp] = lod_min_clamp
-      desc[:lod_max_clamp] = lod_max_clamp
-      desc[:compare] = compare || :undefined
-      desc[:max_anisotropy] = max_anisotropy
+      desc, keepalive = build_descriptor(
+        label:,
+        address_mode_u:,
+        address_mode_v:,
+        address_mode_w:,
+        mag_filter:,
+        min_filter:,
+        mipmap_filter:,
+        lod_min_clamp:,
+        lod_max_clamp:,
+        compare:,
+        max_anisotropy:
+      )
+      @descriptor_keepalive = keepalive
 
       device.push_error_scope(:validation)
       @handle = Native.wgpuDeviceCreateSampler(device.handle, desc)
       error = device.pop_error_scope
+      @descriptor_keepalive = nil
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)
         msg = error[:message] || "Failed to create sampler"
@@ -43,5 +38,26 @@ module WGPU
       Native.wgpuSamplerRelease(@handle)
       @handle = FFI::Pointer::NULL
     end
+
+    private
+
+    def build_descriptor(label:, address_mode_u:, address_mode_v:, address_mode_w:, mag_filter:, min_filter:,
+                         mipmap_filter:, lod_min_clamp:, lod_max_clamp:, compare:, max_anisotropy:)
+      keepalive = []
+      desc = Native::SamplerDescriptor.new
+      desc[:next_in_chain] = nil
+      DescriptorHelpers.set_label(desc, label, keepalive:)
+      desc[:address_mode_u] = Native::EnumHelper.coerce(Native::AddressMode, address_mode_u, name: "address mode")
+      desc[:address_mode_v] = Native::EnumHelper.coerce(Native::AddressMode, address_mode_v, name: "address mode")
+      desc[:address_mode_w] = Native::EnumHelper.coerce(Native::AddressMode, address_mode_w, name: "address mode")
+      desc[:mag_filter] = Native::EnumHelper.coerce(Native::FilterMode, mag_filter, name: "mag filter")
+      desc[:min_filter] = Native::EnumHelper.coerce(Native::FilterMode, min_filter, name: "min filter")
+      desc[:mipmap_filter] = Native::EnumHelper.coerce(Native::MipmapFilterMode, mipmap_filter, name: "mipmap filter")
+      desc[:lod_min_clamp] = lod_min_clamp
+      desc[:lod_max_clamp] = lod_max_clamp
+      desc[:compare] = Native::EnumHelper.coerce(Native::CompareFunction, compare || :undefined, name: "compare function")
+      desc[:max_anisotropy] = max_anisotropy
+      [desc, keepalive]
+    end
   end
 end

data/lib/wgpu/resources/texture.rb

@@ -2,45 +2,27 @@
 
 module WGPU
   class Texture
-    attr_reader :handle
+    attr_reader :handle, :surface_status
 
     def initialize(device, label: nil, size:, format:, usage:, dimension: :d2, mip_level_count: 1, sample_count: 1, view_formats: [])
       @device = device
 
-      desc = Native::TextureDescriptor.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[:usage] = normalize_usage(usage)
-      desc[:dimension] = dimension
-      desc[:size][:width] = size[:width] || size[0]
-      desc[:size][:height] = size[:height] || size[1] || 1
-      desc[:size][:depth_or_array_layers] = size[:depth_or_array_layers] || size[2] || 1
-      desc[:format] = format
-      desc[:mip_level_count] = mip_level_count
-      desc[:sample_count] = sample_count
-      desc[:view_format_count] = view_formats.size
-      if view_formats.empty?
-        @view_formats_ptr = nil
-        desc[:view_formats] = nil
-      else
-        format_values = view_formats.map do |vf|
-          vf.is_a?(Integer) ? vf : Native::TextureFormat[vf]
-        end
-        @view_formats_ptr = FFI::MemoryPointer.new(:uint32, format_values.size)
-        @view_formats_ptr.write_array_of_uint32(format_values)
-        desc[:view_formats] = @view_formats_ptr
-      end
+      desc, keepalive = build_descriptor(
+        label:,
+        size:,
+        format:,
+        usage:,
+        dimension:,
+        mip_level_count:,
+        sample_count:,
+        view_formats:
+      )
+      @descriptor_keepalive = keepalive
 
       device.push_error_scope(:validation)
       @handle = Native.wgpuDeviceCreateTexture(device.handle, desc)
       error = device.pop_error_scope
+      @descriptor_keepalive = nil
 
       if @handle.null? || (error[:type] && error[:type] != :no_error)
         msg = error[:message] || "Failed to create texture"
@@ -48,10 +30,11 @@ module WGPU
       end
     end
 
-    def self.from_handle(handle)
+    def self.from_handle(handle, surface_status: nil)
       texture = allocate
       texture.instance_variable_set(:@handle, handle)
       texture.instance_variable_set(:@device, nil)
+      texture.instance_variable_set(:@surface_status, surface_status)
       texture
     end
 
@@ -120,17 +103,36 @@ module WGPU
 
     private
 
-    def normalize_usage(usage)
-      case usage
-      when Integer
-        usage
-      when Symbol
-        Native::TextureUsage[usage]
-      when Array
-        usage.reduce(0) { |acc, u| acc | Native::TextureUsage[u] }
-      else
-        raise ArgumentError, "Invalid usage: #{usage}"
+    def build_descriptor(label:, size:, format:, usage:, dimension:, mip_level_count:, sample_count:, view_formats:)
+      keepalive = []
+      DescriptorHelpers.validate_keys!(
+        size,
+        allowed: [:width, :height, :depth_or_array_layers],
+        required: [:width],
+        context: "texture size"
+      )
+
+      desc = Native::TextureDescriptor.new
+      desc[:next_in_chain] = nil
+      DescriptorHelpers.set_label(desc, label, keepalive:)
+      desc[:usage] = normalize_usage(usage)
+      desc[:dimension] = Native::EnumHelper.coerce(Native::TextureDimension, dimension, name: "texture dimension")
+      desc[:size][:width] = size[:width] || size[0]
+      desc[:size][:height] = size[:height] || size[1] || 1
+      desc[:size][:depth_or_array_layers] = size[:depth_or_array_layers] || size[2] || 1
+      desc[:format] = Native::EnumHelper.coerce(Native::TextureFormat, format, name: "texture format")
+      desc[:mip_level_count] = mip_level_count
+      desc[:sample_count] = sample_count
+      desc[:view_format_count] = view_formats.size
+      format_values = view_formats.map do |view_format|
+        Native::EnumHelper.coerce(Native::TextureFormat, view_format, name: "view format")
       end
+      desc[:view_formats] = DescriptorHelpers.uint32_array(format_values, keepalive:)
+      [desc, keepalive]
+    end
+
+    def normalize_usage(usage)
+      Native::EnumHelper.coerce_flags(Native::TextureUsage, usage, name: "texture usage")
     end
   end
 end

data/lib/wgpu/resources/texture_view.rb

@@ -17,13 +17,21 @@ module WGPU
         desc[:label][:data] = nil
         desc[:label][:length] = 0
       end
-      desc[:format] = format || :undefined
-      desc[:dimension] = dimension || :undefined
+      desc[:format] = Native::EnumHelper.coerce(
+        Native::TextureFormat,
+        format || :undefined,
+        name: "texture view format"
+      )
+      desc[:dimension] = Native::EnumHelper.coerce(
+        Native::TextureViewDimension,
+        dimension || :undefined,
+        name: "texture view dimension"
+      )
       desc[:base_mip_level] = base_mip_level
       desc[:mip_level_count] = mip_level_count || 0xFFFFFFFF
       desc[:base_array_layer] = base_array_layer
       desc[:array_layer_count] = array_layer_count || 0xFFFFFFFF
-      desc[:aspect] = aspect
+      desc[:aspect] = Native::EnumHelper.coerce(Native::TextureAspect, aspect, name: "texture aspect")
 
       @handle = Native.wgpuTextureCreateView(texture.handle, desc)
       raise ResourceError, "Failed to create texture view" if @handle.null?