wgpu 1.0.0

data/lib/wgpu/pipeline/shader_module.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module WGPU
+  class ShaderModule
+    attr_reader :handle
+
+    def initialize(device, label: nil, code:, compilation_hints: [])
+      @device = device
+      @pointers = []
+      compilation_hints # currently unused by wgpu-native API
+
+      source_ptr = build_shader_source(code, label: label)
+
+      desc = Native::ShaderModuleDescriptor.new
+      desc[:next_in_chain] = source_ptr
+      if label
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        @pointers << label_ptr
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreateShaderModule(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create shader module"
+        raise ShaderError, msg
+      end
+    end
+
+    def get_compilation_info
+      result_holder = { done: false, status: nil, messages: [] }
+
+      callback = FFI::Function.new(
+        :void, [:uint32, :pointer, :pointer, :pointer]
+      ) do |status, compilation_info_ptr, _userdata1, _userdata2|
+        result_holder[:done] = true
+        result_holder[:status] = Native::CompilationInfoRequestStatus[status]
+
+        unless compilation_info_ptr.null?
+          info = Native::CompilationInfo.new(compilation_info_ptr)
+          count = info[:message_count]
+          if count > 0 && !info[:messages].null?
+            count.times do |i|
+              msg_ptr = info[:messages] + (i * Native::CompilationMessage.size)
+              msg = Native::CompilationMessage.new(msg_ptr)
+              message_text = if msg[:message][:data] && !msg[:message][:data].null? && msg[:message][:length] > 0
+                               msg[:message][:data].read_string(msg[:message][:length])
+                             else
+                               ""
+                             end
+              result_holder[:messages] << {
+                type: msg[:type],
+                message: message_text,
+                line_num: msg[:line_num],
+                line_pos: msg[:line_pos],
+                offset: msg[:offset],
+                length: msg[:length]
+              }
+            end
+          end
+        end
+      end
+
+      callback_info = Native::CompilationInfoCallbackInfo.new
+      callback_info[:next_in_chain] = nil
+      callback_info[:mode] = 1
+      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
+
+      {
+        status: result_holder[:status],
+        messages: result_holder[:messages]
+      }
+    end
+
+    def get_compilation_info_async
+      AsyncTask.new { get_compilation_info }
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuShaderModuleRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    private
+
+    def build_shader_source(code, label:)
+      if code.is_a?(String)
+        if spirv_binary?(code)
+          build_spirv_source(code.b)
+        elsif glsl_source?(code)
+          build_glsl_source(code, label: label)
+        else
+          build_wgsl_source(code)
+        end
+      elsif code.is_a?(Array)
+        build_spirv_source(code.pack("L<*"))
+      elsif code.respond_to?(:to_str)
+        build_shader_source(code.to_str, label: label)
+      else
+        # Assume binary SPIR-V for byte-like objects.
+        build_spirv_source(code)
+      end
+    end
+
+    def glsl_source?(source)
+      source.lstrip.start_with?("#version")
+    end
+
+    def spirv_binary?(source)
+      source.bytesize >= 4 && source.byteslice(0, 4).bytes == [0x03, 0x02, 0x23, 0x07]
+    end
+
+    def build_wgsl_source(source)
+      code_ptr = FFI::MemoryPointer.from_string(source)
+      @pointers << code_ptr
+
+      wgsl = Native::ShaderSourceWGSL.new
+      wgsl[:chain][:next] = nil
+      wgsl[:chain][:s_type] = :shader_source_wgsl
+      wgsl[:code][:data] = code_ptr
+      wgsl[:code][:length] = source.bytesize
+
+      @pointers << wgsl
+      wgsl.to_ptr
+    end
+
+    def build_spirv_source(binary)
+      bytes =
+        if binary.is_a?(String)
+          binary
+        elsif binary.respond_to?(:to_str)
+          binary.to_str
+        elsif binary.respond_to?(:to_a)
+          binary.to_a.pack("C*")
+        else
+          raise ArgumentError, "Unsupported SPIR-V data type: #{binary.class}"
+        end
+
+      raise ArgumentError, "SPIR-V bytecode size must be a multiple of 4" if (bytes.bytesize % 4) != 0
+
+      byte_ptr = FFI::MemoryPointer.new(:char, bytes.bytesize)
+      byte_ptr.put_bytes(0, bytes)
+      @pointers << byte_ptr
+
+      spirv = Native::ShaderSourceSPIRV.new
+      spirv[:chain][:next] = nil
+      spirv[:chain][:s_type] = :shader_source_spirv
+      spirv[:code_size] = bytes.bytesize / 4
+      spirv[:code] = byte_ptr
+
+      @pointers << spirv
+      spirv.to_ptr
+    end
+
+    def build_glsl_source(source, label:)
+      stage = shader_stage_for_glsl(label)
+      raise ArgumentError, "GLSL shader requires label containing comp/vert/frag" if stage.nil?
+
+      code_ptr = FFI::MemoryPointer.from_string(source)
+      @pointers << code_ptr
+
+      glsl = Native::ShaderSourceGLSL.new
+      glsl[:chain][:next] = nil
+      glsl[:chain][:s_type] = :shader_source_glsl
+      glsl[:stage] = stage
+      glsl[:code][:data] = code_ptr
+      glsl[:code][:length] = source.bytesize
+      glsl[:define_count] = 0
+      glsl[:defines] = nil
+
+      @pointers << glsl
+      glsl.to_ptr
+    end
+
+    def shader_stage_for_glsl(label)
+      return nil unless label
+
+      down = label.downcase
+      return Native::ShaderStage[:compute] if down.include?("comp")
+      return Native::ShaderStage[:vertex] if down.include?("vert")
+      return Native::ShaderStage[:fragment] if down.include?("frag")
+
+      nil
+    end
+  end
+end

data/lib/wgpu/resources/buffer.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Buffer
+    attr_reader :handle, :size, :usage
+
+    def initialize(device, label: nil, size:, usage:, mapped_at_creation: false)
+      @device = device
+      @size = size
+      @usage = normalize_usage(usage)
+      @mapped = mapped_at_creation
+      @map_callbacks = []
+
+      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
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreateBuffer(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create buffer"
+        raise BufferError, msg
+      end
+    end
+
+    def write(data, offset: 0)
+      ptr, byte_size = data_to_pointer(data)
+      Native.wgpuQueueWriteBuffer(@device.queue.handle, @handle, offset, ptr, byte_size)
+    end
+
+    def mapped_range(offset: 0, size: nil)
+      raise BufferError, "Buffer is not mapped" unless @mapped
+
+      size ||= @size - offset
+      ptr = Native.wgpuBufferGetMappedRange(@handle, offset, size)
+      raise BufferError, "Failed to get mapped range" if ptr.null?
+
+      BufferMappedRange.new(ptr, size)
+    end
+
+    def get_mapped_range(offset: 0, size: nil)
+      mapped_range(offset: offset, size: size)
+    end
+
+    def unmap
+      Native.wgpuBufferUnmap(@handle)
+      @mapped = false
+    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)
+      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)
+      AsyncTask.new do
+        wait_for_map(status_holder)
+        finalize_map(status_holder)
+      ensure
+        @map_callbacks.delete(callback)
+      end
+    end
+
+    def read_mapped_data(offset: 0, size: nil)
+      raise BufferError, "Buffer is not mapped" unless @mapped
+
+      size ||= @size - offset
+      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)
+    end
+
+    def write_mapped(data, offset: 0)
+      raise BufferError, "Buffer is not mapped" unless @mapped
+
+      ptr, byte_size = data_to_pointer(data)
+      target = Native.wgpuBufferGetMappedRange(@handle, offset, byte_size)
+      raise BufferError, "Failed to get mapped range" if target.null?
+
+      target.put_bytes(0, ptr.read_bytes(byte_size))
+    end
+
+    def read_mapped_floats(offset: 0, count: nil)
+      raise BufferError, "Buffer is not mapped" unless @mapped
+
+      size = count ? count * 4 : @size - offset
+      ptr = Native.wgpuBufferGetConstMappedRange(@handle, offset, size)
+      raise BufferError, "Failed to get mapped range" if ptr.null?
+
+      ptr.read_array_of_float(size / 4)
+    end
+
+    def map_state
+      state = Native.wgpuBufferGetMapState(@handle)
+      state || (@mapped ? :mapped : :unmapped)
+    end
+
+    def destroy
+      Native.wgpuBufferDestroy(@handle)
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuBufferRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    private
+
+    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
+
+      status_holder = { done: false, status: nil }
+      callback = FFI::Function.new(:void, [:uint32, :pointer]) do |status, _userdata|
+        status_holder[:done] = true
+        status_holder[:status] = Native::MapAsyncStatus[status]
+      end
+      @map_callbacks << callback
+
+      callback_info = Native::BufferMapCallbackInfo.new
+      callback_info[:next_in_chain] = nil
+      callback_info[:mode] = 1
+      callback_info[:callback] = callback
+      callback_info[:userdata] = nil
+
+      Native.wgpuBufferMapAsync(@handle, mode_flag, offset, size, callback_info)
+
+      [status_holder, callback]
+    end
+
+    def wait_for_map(status_holder)
+      until status_holder[:done]
+        Native.wgpuDevicePoll(@device.handle, 0, nil)
+        sleep(0.001)
+      end
+    end
+
+    def finalize_map(status_holder)
+      if status_holder[:status] == :success
+        @mapped = true
+        true
+      else
+        raise BufferError, "Failed to map buffer: #{status_holder[:status]}"
+      end
+    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
+    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
+    end
+  end
+
+  class BufferMappedRange
+    def initialize(pointer, size)
+      @pointer = pointer
+      @size = size
+    end
+
+    def read_floats(count = nil)
+      count ||= @size / 4
+      @pointer.read_array_of_float(count)
+    end
+
+    def write_floats(data)
+      @pointer.write_array_of_float(data)
+    end
+
+    def read_bytes
+      @pointer.read_bytes(@size)
+    end
+
+    def write_bytes(data)
+      @pointer.put_bytes(0, data)
+    end
+  end
+end

data/lib/wgpu/resources/query_set.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module WGPU
+  class QuerySet
+    attr_reader :handle
+
+    def initialize(device, label: nil, type:, count:)
+      @device = device
+
+      desc = Native::QuerySetDescriptor.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[:type] = type
+      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
+      Native.wgpuQuerySetDestroy(@handle)
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuQuerySetRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/resources/sampler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Sampler
+    attr_reader :handle
+
+    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
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreateSampler(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create sampler"
+        raise ResourceError, msg
+      end
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuSamplerRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/resources/texture.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Texture
+    attr_reader :handle
+
+    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
+
+      device.push_error_scope(:validation)
+      @handle = Native.wgpuDeviceCreateTexture(device.handle, desc)
+      error = device.pop_error_scope
+
+      if @handle.null? || (error[:type] && error[:type] != :no_error)
+        msg = error[:message] || "Failed to create texture"
+        raise ResourceError, msg
+      end
+    end
+
+    def self.from_handle(handle)
+      texture = allocate
+      texture.instance_variable_set(:@handle, handle)
+      texture.instance_variable_set(:@device, nil)
+      texture
+    end
+
+    def create_view(label: nil, format: nil, dimension: nil, base_mip_level: 0, mip_level_count: nil, base_array_layer: 0, array_layer_count: nil, aspect: :all)
+      TextureView.new(self,
+        label: label,
+        format: format,
+        dimension: dimension,
+        base_mip_level: base_mip_level,
+        mip_level_count: mip_level_count,
+        base_array_layer: base_array_layer,
+        array_layer_count: array_layer_count,
+        aspect: aspect
+      )
+    end
+
+    def width
+      Native.wgpuTextureGetWidth(@handle)
+    end
+
+    def size
+      {
+        width: width,
+        height: height,
+        depth_or_array_layers: depth_or_array_layers
+      }
+    end
+
+    def height
+      Native.wgpuTextureGetHeight(@handle)
+    end
+
+    def depth_or_array_layers
+      Native.wgpuTextureGetDepthOrArrayLayers(@handle)
+    end
+
+    def mip_level_count
+      Native.wgpuTextureGetMipLevelCount(@handle)
+    end
+
+    def sample_count
+      Native.wgpuTextureGetSampleCount(@handle)
+    end
+
+    def dimension
+      Native.wgpuTextureGetDimension(@handle)
+    end
+
+    def format
+      Native.wgpuTextureGetFormat(@handle)
+    end
+
+    def usage
+      Native.wgpuTextureGetUsage(@handle)
+    end
+
+    def destroy
+      Native.wgpuTextureDestroy(@handle)
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuTextureRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    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}"
+      end
+    end
+  end
+end

data/lib/wgpu/resources/texture_view.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module WGPU
+  class TextureView
+    attr_reader :handle, :texture
+
+    def initialize(texture, label: nil, format: nil, dimension: nil, base_mip_level: 0, mip_level_count: nil, base_array_layer: 0, array_layer_count: nil, aspect: :all)
+      @texture = texture
+
+      desc = Native::TextureViewDescriptor.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[:format] = format || :undefined
+      desc[:dimension] = dimension || :undefined
+      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
+
+      @handle = Native.wgpuTextureCreateView(texture.handle, desc)
+      raise ResourceError, "Failed to create texture view" if @handle.null?
+    end
+
+    def self.from_handle(handle)
+      view = allocate
+      view.instance_variable_set(:@handle, handle)
+      view.instance_variable_set(:@texture, nil)
+      view
+    end
+
+    def size
+      @texture&.size
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuTextureViewRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/version.rb

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