wgpu 0.1.0

data/lib/wgpu/core/surface.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Surface
+    attr_reader :handle
+
+    def self.from_metal_layer(instance, layer)
+      source = Native::SurfaceSourceMetalLayer.new
+      source[:chain][:next] = nil
+      source[:chain][:s_type] = Native::SType[:surface_descriptor_from_metal_layer]
+      source[:layer] = layer
+
+      desc = Native::SurfaceDescriptor.new
+      desc[:next_in_chain] = source.to_ptr
+      desc[:label][:data] = nil
+      desc[:label][:length] = 0
+
+      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      raise SurfaceError, "Failed to create surface from Metal layer" if handle.null?
+
+      new(handle, instance)
+    end
+
+    def self.from_windows_hwnd(instance, hinstance, hwnd)
+      source = Native::SurfaceSourceWindowsHWND.new
+      source[:chain][:next] = nil
+      source[:chain][:s_type] = Native::SType[:surface_descriptor_from_windows_hwnd]
+      source[:hinstance] = hinstance
+      source[:hwnd] = hwnd
+
+      desc = Native::SurfaceDescriptor.new
+      desc[:next_in_chain] = source.to_ptr
+      desc[:label][:data] = nil
+      desc[:label][:length] = 0
+
+      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      raise SurfaceError, "Failed to create surface from Windows HWND" if handle.null?
+
+      new(handle, instance)
+    end
+
+    def self.from_xlib_window(instance, display, window)
+      source = Native::SurfaceSourceXlibWindow.new
+      source[:chain][:next] = nil
+      source[:chain][:s_type] = Native::SType[:surface_descriptor_from_xlib_window]
+      source[:display] = display
+      source[:window] = window
+
+      desc = Native::SurfaceDescriptor.new
+      desc[:next_in_chain] = source.to_ptr
+      desc[:label][:data] = nil
+      desc[:label][:length] = 0
+
+      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      raise SurfaceError, "Failed to create surface from Xlib window" if handle.null?
+
+      new(handle, instance)
+    end
+
+    def self.from_wayland_surface(instance, display, surface)
+      source = Native::SurfaceSourceWaylandSurface.new
+      source[:chain][:next] = nil
+      source[:chain][:s_type] = Native::SType[:surface_descriptor_from_wayland_surface]
+      source[:display] = display
+      source[:surface] = surface
+
+      desc = Native::SurfaceDescriptor.new
+      desc[:next_in_chain] = source.to_ptr
+      desc[:label][:data] = nil
+      desc[:label][:length] = 0
+
+      handle = Native.wgpuInstanceCreateSurface(instance.handle, desc)
+      raise SurfaceError, "Failed to create surface from Wayland surface" if handle.null?
+
+      new(handle, instance)
+    end
+
+    def initialize(handle, instance)
+      @handle = handle
+      @instance = instance
+      @configured = false
+    end
+
+    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[:format] = format
+      config[:usage] = normalize_usage(usage)
+      config[:width] = width
+      config[:height] = height
+      config[:view_format_count] = view_formats.size
+      config[:view_formats] = nil
+      config[:alpha_mode] = Native::CompositeAlphaMode[alpha_mode]
+      config[:present_mode] = Native::PresentMode[present_mode]
+
+      Native.wgpuSurfaceConfigure(@handle, config)
+      @configured = true
+      @device = device
+    end
+
+    def unconfigure
+      Native.wgpuSurfaceUnconfigure(@handle)
+      @configured = false
+    end
+
+    def current_texture
+      raise SurfaceError, "Surface is not configured" unless @configured
+
+      surface_texture = Native::SurfaceTexture.new
+      Native.wgpuSurfaceGetCurrentTexture(@handle, surface_texture)
+
+      status = Native::SurfaceGetCurrentTextureStatus[surface_texture[:status]]
+      unless status == :success
+        raise SurfaceError, "Failed to get current texture: #{status}"
+      end
+
+      Texture.from_handle(surface_texture[:texture])
+    end
+
+    def present
+      Native.wgpuSurfacePresent(@handle)
+    end
+
+    def capabilities(adapter)
+      caps = Native::SurfaceCapabilities.new
+      Native.wgpuSurfaceGetCapabilities(@handle, adapter.handle, caps)
+
+      formats = []
+      if caps[:format_count] > 0 && !caps[:formats].null?
+        formats = caps[:formats].read_array_of_uint32(caps[:format_count]).map do |f|
+          Native::TextureFormat[f]
+        end
+      end
+
+      present_modes = []
+      if caps[:present_mode_count] > 0 && !caps[:present_modes].null?
+        present_modes = caps[:present_modes].read_array_of_uint32(caps[:present_mode_count]).map do |m|
+          Native::PresentMode[m]
+        end
+      end
+
+      alpha_modes = []
+      if caps[:alpha_mode_count] > 0 && !caps[:alpha_modes].null?
+        alpha_modes = caps[:alpha_modes].read_array_of_uint32(caps[:alpha_mode_count]).map do |a|
+          Native::CompositeAlphaMode[a]
+        end
+      end
+
+      {
+        formats: formats,
+        present_modes: present_modes,
+        alpha_modes: alpha_modes,
+        usages: caps[:usages]
+      }
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuSurfaceRelease(@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/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module WGPU
+  class Error < StandardError; end
+  class InitializationError < Error; end
+  class AdapterError < Error; end
+  class DeviceError < Error; end
+  class BufferError < Error; end
+  class TextureError < Error; end
+  class ResourceError < Error; end
+  class ShaderError < Error; end
+  class PipelineError < Error; end
+  class CommandError < Error; end
+  class SurfaceError < Error; end
+  class RenderBundleError < Error; end
+end

data/lib/wgpu/native/callbacks.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WGPU
+  module Native
+    callback :request_adapter_callback,
+             [RequestAdapterStatus, :pointer, StringView.by_value, :pointer], :void
+
+    callback :request_device_callback,
+             [RequestDeviceStatus, :pointer, StringView.by_value, :pointer], :void
+
+    callback :buffer_map_callback,
+             [MapAsyncStatus, :pointer], :void
+
+    callback :error_callback,
+             [:uint32, StringView.by_value, :pointer], :void
+
+    callback :device_lost_callback,
+             [:pointer, :uint32, StringView.by_value, :pointer], :void
+
+    callback :pop_error_scope_callback,
+             [PopErrorScopeStatus, ErrorType, StringView.by_value, :pointer, :pointer], :void
+
+    callback :queue_work_done_callback,
+             [QueueWorkDoneStatus, :pointer, :pointer], :void
+  end
+end