wgpu 0.1.0

data/lib/wgpu/resources/buffer.rb

@@ -0,0 +1,184 @@
+# 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
+
+      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 unmap
+      Native.wgpuBufferUnmap(@handle)
+      @mapped = false
+    end
+
+    def map_async(mode, offset: 0, size: nil)
+      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
+
+      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)
+
+      until status_holder[:done]
+        Native.wgpuDevicePoll(@device.handle, 0, nil)
+        sleep(0.001)
+      end
+
+      if status_holder[:status] == :success
+        @mapped = true
+        true
+      else
+        raise BufferError, "Failed to map buffer: #{status_holder[:status]}"
+      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_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
+      @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 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,118 @@
+# 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
+      desc[:view_formats] = nil
+
+      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 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,45 @@
+# frozen_string_literal: true
+
+module WGPU
+  class TextureView
+    attr_reader :handle
+
+    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 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 = "0.1.0"
+end

data/lib/wgpu.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "wgpu/version"
+require_relative "wgpu/error"
+require_relative "wgpu/native/loader"
+
+require_relative "wgpu/resources/buffer"
+require_relative "wgpu/resources/texture"
+require_relative "wgpu/resources/texture_view"
+require_relative "wgpu/resources/sampler"
+require_relative "wgpu/resources/query_set"
+
+require_relative "wgpu/pipeline/shader_module"
+require_relative "wgpu/pipeline/bind_group_layout"
+require_relative "wgpu/pipeline/bind_group"
+require_relative "wgpu/pipeline/pipeline_layout"
+require_relative "wgpu/pipeline/compute_pipeline"
+require_relative "wgpu/pipeline/render_pipeline"
+
+require_relative "wgpu/commands/command_buffer"
+require_relative "wgpu/commands/compute_pass"
+require_relative "wgpu/commands/render_pass"
+require_relative "wgpu/commands/render_bundle"
+require_relative "wgpu/commands/render_bundle_encoder"
+require_relative "wgpu/commands/command_encoder"
+
+require_relative "wgpu/core/queue"
+require_relative "wgpu/core/device"
+require_relative "wgpu/core/adapter"
+require_relative "wgpu/core/instance"
+require_relative "wgpu/core/surface"
+
+module WGPU
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: wgpu
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+description: Ruby bindings for the WebGPU API, providing GPU compute and graphics
+  capabilities through the wgpu-native library.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions:
+- ext/wgpu/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE-APACHE
+- LICENSE-MIT
+- README.md
+- ext/wgpu/Makefile
+- ext/wgpu/extconf.rb
+- lib/wgpu.rb
+- lib/wgpu/commands/command_buffer.rb
+- lib/wgpu/commands/command_encoder.rb
+- lib/wgpu/commands/compute_pass.rb
+- lib/wgpu/commands/render_bundle.rb
+- lib/wgpu/commands/render_bundle_encoder.rb
+- lib/wgpu/commands/render_pass.rb
+- lib/wgpu/core/adapter.rb
+- lib/wgpu/core/device.rb
+- lib/wgpu/core/instance.rb
+- lib/wgpu/core/queue.rb
+- lib/wgpu/core/surface.rb
+- lib/wgpu/error.rb
+- lib/wgpu/native/callbacks.rb
+- lib/wgpu/native/enums.rb
+- lib/wgpu/native/functions.rb
+- lib/wgpu/native/loader.rb
+- lib/wgpu/native/structs.rb
+- lib/wgpu/pipeline/bind_group.rb
+- lib/wgpu/pipeline/bind_group_layout.rb
+- lib/wgpu/pipeline/compute_pipeline.rb
+- lib/wgpu/pipeline/pipeline_layout.rb
+- lib/wgpu/pipeline/render_pipeline.rb
+- lib/wgpu/pipeline/shader_module.rb
+- lib/wgpu/resources/buffer.rb
+- lib/wgpu/resources/query_set.rb
+- lib/wgpu/resources/sampler.rb
+- lib/wgpu/resources/texture.rb
+- lib/wgpu/resources/texture_view.rb
+- lib/wgpu/version.rb
+homepage: https://github.com/ydah/wgpu-ruby
+licenses:
+- MIT
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/ydah/wgpu-ruby
+  source_code_uri: https://github.com/ydah/wgpu-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Ruby bindings for WebGPU via wgpu-native
+test_files: []